update to play2.2 (broken)

w3c · Jan 27, 2014 · 16fbab7 · 16fbab7
1 parent 3f9ede0
commit 16fbab7
Show file tree

Hide file tree

Showing 48 changed files with 309 additions and 354 deletions.
diff --git a/app/controllers/Job.scala b/app/controllers/Job.scala
@@ -83,17 +83,18 @@ object Job extends VSController {
 
   import play.api.mvc._
 
-  def dispatcher(implicit id: JobId): ActionA = Action { implicit req =>
+  def dispatcher(implicit id: JobId): ActionA = Action.async { implicit req =>
-    (for {
+    val action: String = (for {
       body <- req.body.asFormUrlEncoded
       param <- body.get("action")
       action <- param.headOption
-    } yield action.toLowerCase match {
+    } yield action.toLowerCase).getOrElse("notSpecified")
+    action match {
       case "delete" => delete(id)(req)
       case "run" => run(id)(req)
       case "stop" => stop(id)(req)
-      case a => BadRequest(views.html.error._400(List(("error", Messages("debug.unexpected", "unknown action " + a)))))
+      case a => Future.successful(BadRequest(views.html.error._400(List(("error", Messages("debug.unexpected", "unknown action " + a))))))
-    }).getOrElse(BadRequest(views.html.error._400(List(("error", Messages("debug.unexpected", "no action parameter was specified"))))))
+    }
   }
 
   def socket(jobId: JobId, typ: SocketType): Handler = {

diff --git a/app/controllers/VSController.scala b/app/controllers/VSController.scala
@@ -28,7 +28,7 @@ trait VSController extends Controller {
 
   def CloseWebsocket = (Iteratee.ignore[JsValue], Enumerator.eof)
 
-  implicit def toAsynchronousResult(result: Result): Future[Result] = Future.successful(result)
+  implicit def toAsynchronousResult(result: SimpleResult): Future[SimpleResult] = Future.successful(result)
 
   def getUser()(implicit reqHeader: RequestHeader): Future[User] = {
     for {
@@ -46,7 +46,7 @@ trait VSController extends Controller {
     getUser.map(Some(_)).recover{case _ => None}
   }
 
-  def Timer(name: String)(f: Future[Result]): Future[Result] = {
+  def Timer(name: String)(f: Future[SimpleResult]): Future[SimpleResult] = {
     if (name == "") {
       f
     } else {
@@ -57,21 +57,19 @@ trait VSController extends Controller {
     }
   }
 
-  def AsyncAction(name: String)(f: Request[AnyContent] => Future[Result]): Action[AnyContent] = Action { implicit req =>
+  def AsyncAction(name: String)(f: Request[AnyContent] => Future[SimpleResult]): Action[AnyContent] = Action.async { implicit req =>
-    Async {
       Timer(name) {
-        f(req) recover {
+        f(req).recoverWith[SimpleResult] {
-          case AccessNotAllowed(msg) => Forbidden(views.html.error._403(msg))
+          case AccessNotAllowed(msg) => Future.successful(Forbidden(views.html.error._403(msg)))
           case UnknownJob(_) => Global.onHandlerNotFound(req)
         }
       }
-    }
   }
-  def AsyncAction(f: Request[AnyContent] => Future[Result]): Action[AnyContent] = AsyncAction("")(f)
+  def AsyncAction(f: Request[AnyContent] => Future[SimpleResult]): Action[AnyContent] = AsyncAction("")(f)
 
   val AcceptsStream = Accepting(MimeTypes.EVENT_STREAM)
 
-  def Authenticated(f: User => Future[Result])(implicit req: RequestHeader): Future[Result] = {
+  def Authenticated(f: User => Future[SimpleResult])(implicit req: RequestHeader): Future[SimpleResult] = {
     (for {
       user <- getUser()
       result <- f(user)
@@ -90,7 +88,7 @@ trait VSController extends Controller {
     }
   }
 
-  def RootAction(f: Request[AnyContent] => User => Future[Result]): ActionA = AsyncAction { implicit req =>
+  def RootAction(f: Request[AnyContent] => User => Future[SimpleResult]): ActionA = AsyncAction { implicit req =>
     Authenticated { user =>
       user match {
         case user if user.isRoot => f(req)(user)
@@ -99,21 +97,21 @@ trait VSController extends Controller {
     }
   }
 
-  def AuthenticatedAction(name: String)(f: Request[AnyContent] => User => Future[Result]): ActionA =
+  def AuthenticatedAction(name: String)(f: Request[AnyContent] => User => Future[SimpleResult]): ActionA =
     AsyncAction(name) { implicit req => Authenticated { user => f(req)(user) } }
 
-  def AuthenticatedAction(f: Request[AnyContent] => User => Future[Result]): ActionA = AuthenticatedAction("")(f)
+  def AuthenticatedAction(f: Request[AnyContent] => User => Future[SimpleResult]): ActionA = AuthenticatedAction("")(f)
 
-  def UserAware(f: Option[User] => Future[Result])(implicit req: RequestHeader): Future[Result] = {
+  def UserAware(f: Option[User] => Future[SimpleResult])(implicit req: RequestHeader): Future[SimpleResult] = {
     for {
       userO <- getUserOption()
       result <- f(userO)
     } yield result
   }
 
-  def UserAwareAction(name: String)(f: Request[AnyContent] => Option[User] => Future[Result]): ActionA =
+  def UserAwareAction(name: String)(f: Request[AnyContent] => Option[User] => Future[SimpleResult]): ActionA =
     AsyncAction(name) { implicit req => UserAware { user => f(req)(user) } }
 
-  def UserAwareAction(f: Request[AnyContent] => Option[User] => Future[Result]): ActionA = UserAwareAction("")(f)
+  def UserAwareAction(f: Request[AnyContent] => Option[User] => Future[SimpleResult]): ActionA = UserAwareAction("")(f)
 
 }
diff --git a/app/model/Coupon.scala b/app/model/Coupon.scala
@@ -148,7 +148,7 @@ object Coupon {
 
   def getAll()(implicit conf: Database): Future[List[Coupon]] = {
     val cursor = collection.find(Json.obj()).cursor[JsValue]
-    cursor.toList() map {
+    cursor.collect[List]() map {
       list => list flatMap { coupon =>
         try {
           Some(coupon.as[Coupon])
@@ -162,7 +162,7 @@ object Coupon {
   def get(id: CouponId)(implicit conf: Database): Future[Coupon] = {
     val query = Json.obj("_id" -> toJson(id))
     val cursor = collection.find(query).cursor[JsValue]
-    cursor.headOption() map {
+    cursor.headOption map {
       case None => throw new NoSuchCouponException(id.toString)
       case Some(json) => json.as[Coupon]
     }
@@ -171,7 +171,7 @@ object Coupon {
   def get(code: String)(implicit conf: Database): Future[Coupon] = {
     val query = Json.obj("code" -> toJson(code))
     val cursor = collection.find(query).cursor[JsValue]
-    cursor.headOption() map {
+    cursor.headOption map {
       case None => throw new NoSuchCouponException(code)
       case Some(json) => json.as[Coupon]
     }

diff --git a/app/model/Job.scala b/app/model/Job.scala
@@ -459,7 +459,7 @@ object Job {
   def get(jobId: JobId)(implicit conf: Database): Future[Job] = {
     val query = Json.obj("_id" -> toJson(jobId))
     val cursor = collection.find(query).cursor[JsValue]
-    cursor.headOption() map {
+    cursor.headOption map {
       case None => throw UnknownJob(jobId) //new NoSuchElementException("Invalid jobId: " + jobId)
       case Some(json) => json.as[Job]
     }
@@ -468,7 +468,7 @@ object Job {
   /**the list of all the Jobs */
   def getAll()(implicit conf: Database): Future[List[Job]] = {
     val cursor = collection.find(Json.obj()).cursor[JsValue]
-    cursor.toList() map {
+    cursor.collect[List]() map {
       list => list flatMap { job =>
         try {
           Some(job.as[Job])
@@ -487,7 +487,7 @@ object Job {
   def getRunningJobs()(implicit conf: Database): Future[List[Job]] = {
     val query = Json.obj("status.actorName" -> Json.obj("$exists" -> JsBoolean(true)))
     val cursor = collection.find(query).cursor[JsValue]
-    cursor.toList() map {
+    cursor.collect[List]() map {
       list => list map {
         _.as[Job]
       }
@@ -539,7 +539,7 @@ object Job {
   /*def getFor(userId: UserId, jobId: JobId)(implicit conf: Database): Future[Job] = {
     val query = Json.obj("_id" -> toJson(jobId))
     val cursor = collection.find(query).cursor[JsValue]
-    cursor.headOption() map {
+    cursor.headOption map {
       case Some(json) if (json \ "creator").asOpt[UserId] === Some(userId) => json.as[Job]
       case _ => throw UnknownJob(jobId)
     }
@@ -563,7 +563,8 @@ object Job {
 
   def save(job: Job)(implicit conf: Database): Future[Job] = {
     val jobJson = toJson(job)
-    collection.insert(jobJson) map {
+    println(Json.prettyPrint(jobJson))
+    collection.insert(jobJson, writeConcern = journalCommit) map {
       lastError => job
     }
   }

diff --git a/app/model/ResourceResponse.scala b/app/model/ResourceResponse.scala
@@ -23,7 +23,7 @@ object ResourceResponse {
       "runId" -> toJson(runId),
       "event" -> toJson("resource-response") )
     val cursor = Run.collection.find(query).cursor[JsValue]
-    cursor.toList() map { list =>
+    cursor.collect[List]() map { list =>
       list.map(json => json.as[ResourceResponseEvent](ResourceResponseEventFormat).rr).toSet
     }
   }

diff --git a/app/model/Run.scala b/app/model/Run.scala
@@ -79,7 +79,7 @@ object Run {
       "rd" -> BSONInteger(1),
       "_id" -> BSONInteger(0))
     val cursor = collection.find(query, projection).cursor[JsValue]
-    cursor.headOption() flatMap {
+    cursor.headOption flatMap {
       case None => Future.failed(new NoSuchElementException(s"${runId} does not exist or is not in Done state"))
       case Some(json) =>
         (json \ "rd").as[JsArray].value.collectFirst { case json if (json \ "url") == toJson(url) =>
@@ -101,7 +101,7 @@ object Run {
       "rd" -> BSONInteger(1),
       "_id" -> BSONInteger(0))
     val cursor = collection.find(query, projection).cursor[JsValue]
-    cursor.headOption() flatMap {
+    cursor.headOption flatMap {
       case None => Future.failed(new NoSuchElementException(s"${runId} does not exist or is not in Done state"))
       case Some(json) => Future.successful {
         val rds: Seq[ResourceData] =
@@ -121,7 +121,7 @@ object Run {
       "gad" -> BSONInteger(1),
       "_id" -> BSONInteger(0))
     val cursor = collection.find(query, projection).cursor[JsValue]
-    cursor.headOption() flatMap {
+    cursor.headOption flatMap {
       case None => Future.failed(new NoSuchElementException(s"${runId} does not exist or is not in Done state"))
       case Some(json) => Future.successful {
         (json \ "gad").as[Seq[GroupedAssertionData]]
@@ -140,7 +140,7 @@ object Run {
       "runData" -> BSONInteger(1),
       "_id" -> BSONInteger(0))
     val cursor = collection.find(query, projection).cursor[JsValue]
-    cursor.headOption() flatMap {
+    cursor.headOption flatMap {
       case None => Future.failed(new NoSuchElementException(runId.toString))
       case Some(json) => Future.successful((json \ "runData").as[RunData])
     }
@@ -158,7 +158,7 @@ object Run {
       "runData" -> BSONInteger(1),
       "_id" -> BSONInteger(0))
     val cursor = collection.find(query, projection).cursor[JsValue]
-    cursor.headOption() flatMap {
+    cursor.headOption flatMap {
       case None => Future.failed(new NoSuchElementException(runId.toString))
       case Some(json) => Future.successful {
         val timestamp = (json \ "timestamp").as[DateTime]
@@ -178,7 +178,7 @@ object Run {
   def get(runId: RunId)(implicit conf: Database): Future[(Run, Iterable[RunAction])] = {
     val query = Json.obj("runId" -> toJson(runId))
     val cursor = collection.find(query).cursor[JsValue]
-    cursor.toList() map { list =>
+    cursor.collect[List]() map { list =>
       // the sort is done client-side
       val orderedEvents = list.map(_.as[RunEvent]).sortBy(_.timestamp)
       val (createRun, events) = orderedEvents match {

diff --git a/app/model/User.scala b/app/model/User.scala
@@ -177,15 +177,15 @@ object User {
     import conf._
     val query = Json.obj("_id" -> toJson(userId))
     val cursor = collection.find(query).cursor[JsValue]
-    cursor.headOption() map {
+    cursor.headOption map {
       case Some(json) => json.as[User]
       case None => sys.error("user not found")
     }
   }
 
   def getAll()(implicit conf: Database): Future[List[User]] = {
     val cursor = collection.find(Json.obj()).cursor[JsValue]
-    cursor.toList() map {
+    cursor.collect[List]() map {
       list => list flatMap { user =>
         try {
           Some(user.as[User])
@@ -280,7 +280,7 @@ object User {
     import conf._
     val query = Json.obj("email" -> JsString(email.toLowerCase))
     val cursor = collection.find(query).cursor[JsValue]
-    cursor.headOption() map {
+    cursor.headOption map {
       case Some(json) => json.as[User]
       case None => throw UnknownUser(email)
     }

diff --git a/app/store/Migration.scala b/app/store/Migration.scala
diff --git a/app/store/MongoStore.scala b/app/store/MongoStore.scala
@@ -26,7 +26,7 @@ import scala.concurrent.ExecutionContext.Implicits.global
   */
 object MongoStore {
 
-  val journalCommit = GetLastError(awaitJournalCommit = true)
+  val journalCommit = GetLastError(j = true)
 
   def reInitializeDb()(implicit conf: Database): Future[Unit] = {
     for {

diff --git a/app/vs/Global.scala b/app/vs/Global.scala
@@ -4,6 +4,7 @@ import play.api._
 import play.api.mvc._
 import play.api.mvc.Results._
 import play.api.Mode._
+import concurrent.Future
 
 object Global extends GlobalSettings with Rendering with AcceptExtractors {
 
@@ -41,31 +42,31 @@ object Global extends GlobalSettings with Rendering with AcceptExtractors {
     vs = null
   }
 
-  override def onHandlerNotFound(request : RequestHeader) : Result = {
+  override def onHandlerNotFound(request : RequestHeader): Future[SimpleResult] = {
     implicit val implReq = request
     Metrics.errors.e404()
-    render {
+    Future.successful(render {
       case Accepts.Html() => NotFound(views.html.error._404())
       case Accepts.Json() => NotFound
-    }
+    })
   }
 
-  override def onError(request: RequestHeader, ex: Throwable): Result = {
+  override def onError(request: RequestHeader, ex: Throwable): Future[SimpleResult] = {
     implicit val implReq = request
     Metrics.errors.e500()
-    render {
+    Future.successful(render {
       case Accepts.Html() => InternalServerError(views.html.error._500(List(("error", ex.getMessage))))
       case Accepts.Json() => InternalServerError
-    }
+    })
   }
 
-  override def onBadRequest(request: RequestHeader, error: String) = {
+  override def onBadRequest(request: RequestHeader, error: String): Future[SimpleResult] = {
     implicit val implReq = request
     error match {
       case "InvalidJobId" => onHandlerNotFound(request)
       case _ => {
         Metrics.errors.e400()
-        BadRequest(views.html.error._400(List(("error", error))))
+        Future.successful(BadRequest(views.html.error._400(List(("error", error)))))
       }
     }
   }

diff --git a/build.sbt b/build.sbt
@@ -0,0 +1 @@
+logLevel := Level.Warn
diff --git a/conf/application.conf b/conf/application.conf
@@ -82,7 +82,7 @@ application {
   vs {
     akka{
         loglevel = INFO
-        event-handlers = ["akka.event.slf4j.Slf4jEventHandler"]
+        loggers = ["akka.event.slf4j.Slf4jLogger"]
     }
     jobactor-dispatcher {
       mailbox-type = org.w3.vs.actor.JobActorMailbox