Add error handler to return appropriate response status code

app/controllers/MispCtrl.scala

@@ -2,6 +2,7 @@ package controllers
 
 import javax.inject.Inject
 
+import models.InvalidRequestError
 import play.api.Logger
 import play.api.libs.json.{ JsObject, JsValue }
 import play.api.mvc.{ Action, AnyContent, Controller }
@@ -17,13 +18,13 @@ class MispCtrl @Inject() (mispSrv: MispSrv, implicit val ec: ExecutionContext) e
   }
 
   def query: Action[JsValue] = Action.async(parse.json) { request ⇒
-    val module = (request.body \ "module").asOpt[String].getOrElse(sys.error("module not present in request"))
+    val module = (request.body \ "module").asOpt[String].getOrElse(throw InvalidRequestError("Module parameter is not present in request"))
     val (mispType, dataJson) = request.body.as[JsObject].fields
       .collectFirst {
         case kv @ (k, _) if k != "module" ⇒ kv
       }
-      .getOrElse(sys.error("invalid request"))
-    val data = dataJson.asOpt[String].getOrElse(sys.error("data has invalid type (expected string)"))
+      .getOrElse(throw InvalidRequestError("Request doesn't contain data to analyze"))
+    val data = dataJson.asOpt[String].getOrElse(throw InvalidRequestError("Data has invalid type (expected string)"))
     mispSrv.query(module, mispType, data)
       .map(Ok(_))
   }

app/models/Errors.scala

@@ -0,0 +1,8 @@
+package models
+
+abstract class CortexError(message: String) extends Exception(message)
+
+case class JobNotFoundError(jobId: String) extends CortexError(s"Job $jobId not found")
+case class UnexpectedError(message: String) extends CortexError(message)
+case class AnalyzerNotFoundError(analyzerId: String) extends CortexError(s"Analyzer $analyzerId not found")
+case class InvalidRequestError(message: String) extends CortexError(message)

app/services/AnalyzerSrv.scala

@@ -24,7 +24,7 @@ class AnalyzerSrv @Inject() (
   def analyze(analyzerId: String, artifact: Artifact): Future[Job] = {
     get(analyzerId)
       .map { analyzer ⇒ analyze(analyzer, artifact) }
-      .getOrElse(sys.error("analyzer not found"))
+      .getOrElse(throw AnalyzerNotFoundError(analyzerId))
   }
 
   def analyze(analyzer: Analyzer, artifact: Artifact): Future[Job] = {

app/services/ErrorHandler.scala

@@ -0,0 +1,27 @@
+package services
+
+import models.{ AnalyzerNotFoundError, InvalidRequestError, JobNotFoundError, UnexpectedError }
+import play.api.Logger
+import play.api.http.HttpErrorHandler
+import play.api.mvc.{ RequestHeader, Result, Results }
+
+import scala.concurrent.Future
+
+class ErrorHandler extends HttpErrorHandler {
+  private[ErrorHandler] lazy val logger = Logger(getClass)
+  def onClientError(request: RequestHeader, statusCode: Int, message: String): Future[Result] = Future.successful {
+    Results.Status(statusCode)(s"A client error occurred on ${request.method} ${request.uri} : $message")
+  }
+
+  def onServerError(request: RequestHeader, exception: Throwable): Future[Result] = {
+    val result = exception match {
+      case JobNotFoundError(jobId)           ⇒ Results.NotFound(s"Job $jobId not found")
+      case UnexpectedError(message)          ⇒ Results.InternalServerError(message)
+      case AnalyzerNotFoundError(analyzerId) ⇒ Results.NotFound(s"analyzer $analyzerId not found")
+      case InvalidRequestError(message)      ⇒ Results.BadRequest(message)
+      case error                             ⇒ Results.InternalServerError(s"Unexpected error: $error")
+    }
+    Logger.info(s"${request.method} ${request.uri} returned ${result.header.status}", exception)
+    Future.successful(result)
+  }
+}

app/services/JobSrv.scala

@@ -15,7 +15,6 @@ import scala.concurrent.{ ExecutionContext, Future, Promise }
 import scala.util.Random
 
 class JobSrv @Inject() (
-    //analyzerSrv: AnalyzerSrv,
     @Named("JobActor") jobActor: ActorRef,
     implicit val ec: ExecutionContext,
     implicit val system: ActorSystem) {
@@ -27,20 +26,20 @@ class JobSrv @Inject() (
   def list(dataTypeFilter: Option[String], dataFilter: Option[String], analyzerFilter: Option[String], start: Int, limit: Int): Future[(Int, Seq[Job])] = {
     (jobActor ? ListJobs(dataTypeFilter, dataFilter, analyzerFilter, start, limit)).map {
       case JobList(total, jobs) ⇒ total → jobs
-      case _                    ⇒ sys.error("TODO")
+      case m                    ⇒ throw UnexpectedError(s"JobActor.list replies with unexpected message: $m (${m.getClass})")
     }
   }
 
   def get(jobId: String): Future[Job] = (jobActor ? GetJob(jobId)).map {
     case j: Job      ⇒ j
-    case JobNotFound ⇒ sys.error("job not found")
-    case _           ⇒ sys.error("TODO")
+    case JobNotFound ⇒ throw JobNotFoundError(jobId)
+    case m           ⇒ throw UnexpectedError(s"JobActor.GetJob replies with unexpected message: $m (${m.getClass})")
   }
 
   def create(analyzer: Analyzer, artifact: Artifact, report: Future[Report]): Future[Job] = {
     (jobActor ? CreateJob(artifact, analyzer, report)) map {
       case job: Job ⇒ job
-      case _        ⇒ sys.error("TODO")
+      case m        ⇒ throw UnexpectedError(s"JobActor.CreateJob replies with unexpected message: $m (${m.getClass})")
     }
   }
 
@@ -61,8 +60,8 @@ class JobSrv @Inject() (
   def remove(jobId: String): Future[Unit] = {
     (jobActor ? RemoveJob(jobId)).map {
       case JobRemoved  ⇒ ()
-      case JobNotFound ⇒ sys.error("job not found")
-      case _           ⇒ sys.error("TODO")
+      case JobNotFound ⇒ throw JobNotFoundError(jobId)
+      case m           ⇒ throw UnexpectedError(s"JobActor.RemoveJob replies with unexpected message: $m (${m.getClass})")
     }
   }
 

conf/reference.conf

@@ -1,3 +1,6 @@
+# handler for errors (transform exception to related http status code
+play.http.errorHandler = services.ErrorHandler
+
 analyzer {
   # Directory that holds analyzers
   path = analyzers