#19 code cleanup

TheHive-Project · May 1, 2017 · 1c635f3 · 1c635f3
1 parent 2fb0814
commit 1c635f3
Show file tree

Hide file tree

Showing 16 changed files with 175 additions and 63 deletions.
diff --git a/app/Module.scala b/app/Module.scala
@@ -10,7 +10,7 @@ import services.JobActor
 
 class Module(environment: Environment, configuration: Configuration) extends AbstractModule with ScalaModule with AkkaGuiceSupport {
 
-  override def configure() = {
+  override def configure(): Unit = {
     bindActor[JobActor]("JobActor")
 
     if (environment.mode == Mode.Prod)

diff --git a/app/controllers/Analyzer.scala → app/controllers/AnalyzerCtrl.scala b/app/controllers/Analyzer.scala → app/controllers/AnalyzerCtrl.scala
@@ -38,7 +38,7 @@ class AnalyzerCtrl @Inject() (
   private[controllers] def readFileArtifact(request: Request[AnyContent]) = {
     for {
       parts ← request.body.asMultipartFormData
-      filePart ← parts.file("data").headOption
+      filePart ← parts.file("data")
       attrList ← parts.dataParts.get("_json")
       attrStr ← attrList.headOption
       attr ← Json.parse(attrStr).asOpt[JsObject]
@@ -47,7 +47,7 @@ class AnalyzerCtrl @Inject() (
       ("filename" → JsString(filePart.filename)))
   }
 
-  def analyze(analyzerId: String) = Action.async { request ⇒
+  def analyze(analyzerId: String): Action[AnyContent] = Action.async { request ⇒
     readDataArtifact(request)
       .orElse(readFileArtifact(request))
       .map { artifact ⇒

diff --git a/app/controllers/Asset.scala b/app/controllers/Asset.scala
@@ -12,12 +12,12 @@ trait AssetCtrl {
 
 @Singleton
 class AssetCtrlProd @Inject() (errorHandler: HttpErrorHandler) extends Assets(errorHandler) with AssetCtrl {
-  def get(file: String) = at("/ui", file)
+  def get(file: String): Action[AnyContent] = at("/ui", file)
 }
 
 @Singleton
 class AssetCtrlDev @Inject() (environment: Environment) extends ExternalAssets(environment) with AssetCtrl {
-  def get(file: String) = {
+  def get(file: String): Action[AnyContent] = {
     if (file.startsWith("bower_components/")) {
       at("ui", file)
     }

diff --git a/app/controllers/Job.scala → app/controllers/JobCtrl.scala b/app/controllers/Job.scala → app/controllers/JobCtrl.scala
@@ -6,48 +6,46 @@ import scala.annotation.implicitNotFound
 import scala.concurrent.ExecutionContext
 import scala.concurrent.duration.Duration
 import scala.util.{ Failure, Success }
-
 import play.api.libs.json.{ JsString, Json }
-import play.api.mvc.{ Action, Controller }
-
+import play.api.mvc.{ Action, AnyContent, Controller }
 import models.JsonFormat.{ jobStatusWrites, jobWrites }
 import services.JobSrv
 
 class JobCtrl @Inject() (
     jobSrv: JobSrv,
     implicit val ec: ExecutionContext) extends Controller {
-  def list(dataTypeFilter: Option[String], dataFilter: Option[String], analyzerFilter: Option[String], start: Int, limit: Int) = Action.async { request ⇒
+  def list(dataTypeFilter: Option[String], dataFilter: Option[String], analyzerFilter: Option[String], start: Int, limit: Int): Action[AnyContent] = Action.async { request ⇒
     jobSrv.list(dataTypeFilter, dataFilter, analyzerFilter, start, limit).map {
       case (total, jobs) ⇒ Ok(Json.toJson(jobs)).withHeaders("X-Total" → total.toString)
     }
   }
 
-  def get(jobId: String) = Action.async { request ⇒
+  def get(jobId: String): Action[AnyContent] = Action.async { request ⇒
     jobSrv.get(jobId).map { job ⇒
       Ok(Json.toJson(job))
     }
   }
 
-  def remove(jobId: String) = Action.async { request ⇒
+  def remove(jobId: String): Action[AnyContent] = Action.async { request ⇒
     jobSrv.remove(jobId).map(_ ⇒ Ok(""))
   }
 
-  def report(jobId: String) = Action.async { request ⇒
+  def report(jobId: String): Action[AnyContent] = Action.async { request ⇒
     jobSrv
       .get(jobId)
       .map { job ⇒
         val report = job.report.value match {
-          case Some(Success(report)) ⇒ report
-          case Some(Failure(error))  ⇒ JsString(error.getMessage)
-          case None                  ⇒ JsString("Running")
+          case Some(Success(_report)) ⇒ _report
+          case Some(Failure(error))   ⇒ JsString(error.getMessage)
+          case None                   ⇒ JsString("Running")
         }
         Ok(jobWrites.writes(job) +
           ("status" → jobStatusWrites.writes(job.status)) +
           ("report" → report))
       }
   }
 
-  def waitReport(jobId: String, atMost: String) = Action.async { request ⇒
+  def waitReport(jobId: String, atMost: String): Action[AnyContent] = Action.async { request ⇒
     for {
       job ← jobSrv.get(jobId)
       (status, report) ← jobSrv.waitReport(jobId, Duration(atMost))

diff --git a/app/models/Analyzer.scala b/app/models/Analyzer.scala
@@ -12,5 +12,5 @@ abstract class Analyzer {
   val author: String
   val url: String
   val license: String
-  val id = (name + "_" + version).replaceAll("\\.", "_")
+  val id: String = (name + "_" + version).replaceAll("\\.", "_")
 }
diff --git a/app/models/Analyzer.scala.orig b/app/models/Analyzer.scala.orig
@@ -0,0 +1,16 @@
+package models
+
+import scala.concurrent.Future
+import play.api.libs.json.JsObject
+
+abstract class Analyzer {
+  def analyze(artifact: Artifact): Future[JsObject]
+  val name: String
+  val version: String
+  val description: String
+  val dataTypeList: Seq[String]
+  val author: String
+  val url: String
+  val license: String
+  val id = (name + "_" + version).replaceAll("\\.", "_")
+}
diff --git a/app/models/Analyzer.scala.rej b/app/models/Analyzer.scala.rej
@@ -0,0 +1,9 @@
+--- app/models/Analyzer.scala
++++ app/models/Analyzer.scala
+@@ -9,5 +9,5 @@ abstract class Analyzer {
+   val version: String
+   val description: String
+   val dataTypeList: Seq[String]
+-  val id = (name + "_" + version).replaceAll("\\.", "_")
++  val id: String = (name + "_" + version).replaceAll("\\.", "_")
+ }
diff --git a/app/models/Artifact.scala b/app/models/Artifact.scala
@@ -13,7 +13,7 @@ class FileArtifact(val data: File, val attributes: JsObject) extends Artifact(at
   }
 }
 object FileArtifact {
-  def apply(data: File, attributes: JsObject) = {
+  def apply(data: File, attributes: JsObject): FileArtifact = {
     val tempFile = File.createTempFile("cortex-", "-datafile")
     data.renameTo(tempFile)
     new FileArtifact(tempFile, attributes)

diff --git a/app/models/JsonFormat.scala b/app/models/JsonFormat.scala
@@ -1,42 +1,36 @@
 package models
 
-import scala.annotation.implicitNotFound
-
-import play.api.libs.json.Json
 import play.api.libs.json.Json.toJsFieldJsValueWrapper
-import play.api.libs.json.Writes
-import scala.concurrent.Future
-import play.api.libs.json.JsObject
-import scala.util.Success
-import scala.util.Failure
-import play.api.libs.json.JsString
-import play.api.libs.json.OWrites
+import play.api.libs.json._
 
 object JsonFormat {
-  implicit val analyzerWrites = Writes[Analyzer](analyzer ⇒ Json.obj(
-    "name" → analyzer.name,
-    "version" → analyzer.version,
-    "description" → analyzer.description,
-    "dataTypeList" → analyzer.dataTypeList,
-    "author" → analyzer.author,
-    "url" → analyzer.url,
-    "license" → analyzer.license,
-    "id" → analyzer.id))
-
-  implicit val fileArtifactWrites = OWrites[FileArtifact](fileArtifact ⇒ Json.obj(
-    "attributes" → fileArtifact.attributes))
-
-  implicit val dataArtifactWrites = Json.writes[DataArtifact]
-  implicit val dataActifactReads = Json.reads[DataArtifact]
-
-  implicit val artifactWrites = OWrites[Artifact](artifact ⇒ artifact match {
+  implicit val analyzerWrites: OWrites[Analyzer] = OWrites[Analyzer] { analyzer ⇒
+    Json.obj(
+      "name" → analyzer.name,
+      "version" → analyzer.version,
+      "description" → analyzer.description,
+      "dataTypeList" → analyzer.dataTypeList,
+      "author" → analyzer.author,
+      "url" → analyzer.url,
+      "license" → analyzer.license,
+      "id" → analyzer.id)
+  }
+
+  implicit val fileArtifactWrites: OWrites[FileArtifact] = OWrites[FileArtifact] { fileArtifact ⇒
+    Json.obj("attributes" → fileArtifact.attributes)
+  }
+
+  implicit val dataArtifactWrites: OWrites[DataArtifact] = Json.writes[DataArtifact]
+  implicit val dataActifactReads: Reads[DataArtifact] = Json.reads[DataArtifact]
+
+  implicit val artifactWrites: OWrites[Artifact] = OWrites[Artifact] {
     case dataArtifact: DataArtifact ⇒ dataArtifactWrites.writes(dataArtifact)
     case fileArtifact: FileArtifact ⇒ fileArtifactWrites.writes(fileArtifact)
-  })
+  }
 
-  implicit val jobStatusWrites = Writes[JobStatus.Type](jobStatus ⇒ JsString(jobStatus.toString))
+  implicit val jobStatusWrites: Writes[JobStatus.Type] = Writes[JobStatus.Type](jobStatus ⇒ JsString(jobStatus.toString))
 
-  implicit val jobWrites = OWrites[Job](job ⇒ Json.obj(
+  implicit val jobWrites: OWrites[Job] = OWrites[Job](job ⇒ Json.obj(
     "id" → job.id,
     "analyzerId" → job.analyzerId,
     "status" → job.status,

diff --git a/app/models/JsonFormat.scala.orig b/app/models/JsonFormat.scala.orig
@@ -0,0 +1,46 @@
+package models
+
+import scala.annotation.implicitNotFound
+
+import play.api.libs.json.Json
+import play.api.libs.json.Json.toJsFieldJsValueWrapper
+import play.api.libs.json.Writes
+import scala.concurrent.Future
+import play.api.libs.json.JsObject
+import scala.util.Success
+import scala.util.Failure
+import play.api.libs.json.JsString
+import play.api.libs.json.OWrites
+
+object JsonFormat {
+  implicit val analyzerWrites = Writes[Analyzer](analyzer ⇒ Json.obj(
+    "name" → analyzer.name,
+    "version" → analyzer.version,
+    "description" → analyzer.description,
+    "dataTypeList" → analyzer.dataTypeList,
+    "author" → analyzer.author,
+    "url" → analyzer.url,
+    "license" → analyzer.license,
+    "id" → analyzer.id))
+
+  implicit val fileArtifactWrites = OWrites[FileArtifact](fileArtifact ⇒ Json.obj(
+    "attributes" → fileArtifact.attributes))
+
+  implicit val dataArtifactWrites = Json.writes[DataArtifact]
+  implicit val dataActifactReads = Json.reads[DataArtifact]
+
+  implicit val artifactWrites = OWrites[Artifact](artifact ⇒ artifact match {
+    case dataArtifact: DataArtifact ⇒ dataArtifactWrites.writes(dataArtifact)
+    case fileArtifact: FileArtifact ⇒ fileArtifactWrites.writes(fileArtifact)
+  })
+
+  implicit val jobStatusWrites = Writes[JobStatus.Type](jobStatus ⇒ JsString(jobStatus.toString))
+
+  implicit val jobWrites = OWrites[Job](job ⇒ Json.obj(
+    "id" → job.id,
+    "analyzerId" → job.analyzerId,
+    "status" → job.status,
+    "date" → job.date,
+    "artifact" → job.artifact))
+
+}
diff --git a/app/models/JsonFormat.scala.rej b/app/models/JsonFormat.scala.rej
@@ -0,0 +1,51 @@
+--- app/models/JsonFormat.scala
++++ app/models/JsonFormat.scala
+@@ -1,39 +1,30 @@
+ package models
+
+-import scala.annotation.implicitNotFound
+-
+-import play.api.libs.json.Json
+ import play.api.libs.json.Json.toJsFieldJsValueWrapper
+-import play.api.libs.json.Writes
+-import scala.concurrent.Future
+-import play.api.libs.json.JsObject
+-import scala.util.Success
+-import scala.util.Failure
+-import play.api.libs.json.JsString
+-import play.api.libs.json.OWrites
++import play.api.libs.json._
+
+ object JsonFormat {
+-  implicit val analyzerWrites = Writes[Analyzer](analyzer ⇒ Json.obj(
++  implicit val analyzerWrites: Writes[Analyzer] = Writes[Analyzer](analyzer ⇒ Json.obj(
+     "name" → analyzer.name,
+     "version" → analyzer.version,
+     "description" → analyzer.description,
+     "dataTypeList" → analyzer.dataTypeList,
+     "id" → analyzer.id))
+
+-  implicit val fileArtifactWrites = OWrites[FileArtifact](fileArtifact ⇒ Json.obj(
++  implicit val fileArtifactWrites: OWrites[FileArtifact] = OWrites[FileArtifact](fileArtifact ⇒ Json.obj(
+     "attributes" → fileArtifact.attributes))
+
+-  implicit val dataArtifactWrites = Json.writes[DataArtifact]
+-  implicit val dataActifactReads = Json.reads[DataArtifact]
++  implicit val dataArtifactWrites: OWrites[DataArtifact] = Json.writes[DataArtifact]
++  implicit val dataActifactReads: Reads[DataArtifact] = Json.reads[DataArtifact]
+
+-  implicit val artifactWrites = OWrites[Artifact](artifact ⇒ artifact match {
++  implicit val artifactWrites: OWrites[Artifact] = OWrites[Artifact] {
+     case dataArtifact: DataArtifact ⇒ dataArtifactWrites.writes(dataArtifact)
+     case fileArtifact: FileArtifact ⇒ fileArtifactWrites.writes(fileArtifact)
+-  })
++  }
+
+-  implicit val jobStatusWrites = Writes[JobStatus.Type](jobStatus ⇒ JsString(jobStatus.toString))
++  implicit val jobStatusWrites: Writes[JobStatus.Type] = Writes[JobStatus.Type](jobStatus ⇒ JsString(jobStatus.toString))
+
+-  implicit val jobWrites = OWrites[Job](job ⇒ Json.obj(
++  implicit val jobWrites: OWrites[Job] = OWrites[Job](job ⇒ Json.obj(
+     "id" → job.id,
+     "analyzerId" → job.analyzerId,
+     "status" → job.status,
diff --git a/app/services/Analyzer.scala → app/services/AnalyzerSrv.scala b/app/services/Analyzer.scala → app/services/AnalyzerSrv.scala
diff --git a/app/services/Job.scala b/app/services/Job.scala
@@ -25,7 +25,7 @@ class JobSrv @Inject() (
     @Named("JobActor") jobActor: ActorRef,
     implicit val ec: ExecutionContext,
     implicit val system: ActorSystem) {
-  import JobActor._
+  import services.JobActor._
   implicit val timeout = Timeout(5.seconds)
 
   def list(dataTypeFilter: Option[String], dataFilter: Option[String], analyzerFilter: Option[String], start: Int, limit: Int): Future[(Int, Seq[Job])] = {
@@ -72,7 +72,7 @@ class JobSrv @Inject() (
       case duration: FiniteDuration ⇒
         val prom = Promise[(JobStatus.Type, JsValue)]()
         val timeout = system.scheduler.scheduleOnce(duration) { prom.success((JobStatus.Failure, JsString("Timeout"))); () }
-        statusResult onComplete { case _ ⇒ timeout.cancel() }
+        statusResult.onComplete(_ ⇒ timeout.cancel())
         Future.firstCompletedOf(List(statusResult, prom.future))
     }
   }
@@ -95,7 +95,7 @@ class JobActor(
     analyzerSrv: AnalyzerSrv,
     implicit val ec: ExecutionContext) extends Actor {
 
-  import JobActor._
+  import services.JobActor._
   @Inject def this(
     configuration: Configuration,
     analyzerSrv: AnalyzerSrv,
@@ -128,7 +128,7 @@ class JobActor(
         dataTypeFilter.fold(true)(j.artifact.dataTypeFilter) &&
           dataFilter.fold(true)(j.artifact.dataFilter) &&
           analyzerFilter.fold(true)(j.analyzerId.contains))
-      sender ! JobList(filteredJobs.size, filteredJobs.drop(start).take(limit))
+      sender ! JobList(filteredJobs.size, filteredJobs.slice(start, start + limit))
     case GetJob(jobId) ⇒ sender ! jobs.find(_.id == jobId).getOrElse(JobNotFound)
     case RemoveJob(jobId) ⇒
       removeJob(jobs, jobId) match {
@@ -148,5 +148,5 @@ class JobActor(
       context.become(jobState(jobs.takeWhile(_.date after limitDate)))
   }
 
-  override def receive = jobState(Nil)
+  override def receive: Receive = jobState(Nil)
 }
diff --git a/app/util/JsonConfig.scala b/app/util/JsonConfig.scala
@@ -1,25 +1,23 @@
 package util
 
-import scala.BigDecimal
-import scala.collection.JavaConversions.asScalaBuffer
-
+import com.typesafe.config.ConfigValueType.{ BOOLEAN, NULL, NUMBER, STRING }
+import com.typesafe.config.{ ConfigList, ConfigObject, ConfigValue }
 import play.api.Configuration
-import play.api.libs.json.{ JsArray, JsBoolean, JsNull, JsNumber, JsObject, JsString, OWrites, Writes }
+import play.api.libs.json._
 
-import com.typesafe.config.{ ConfigList, ConfigObject, ConfigValue }
-import com.typesafe.config.ConfigValueType.{ BOOLEAN, NULL, NUMBER, STRING }
+import scala.collection.JavaConversions.asScalaBuffer
 
 object JsonConfig {
-  implicit val configValueWrites: Writes[ConfigValue] = Writes((value: ConfigValue) ⇒ value match {
-    case v: ConfigObject             ⇒ configWrites.writes(Configuration(v.toConfig()))
+  implicit def configValueWrites: Writes[ConfigValue] = Writes[ConfigValue] {
+    case v: ConfigObject             ⇒ configWrites.writes(Configuration(v.toConfig))
     case v: ConfigList               ⇒ JsArray(v.toSeq.map(x ⇒ configValueWrites.writes(x)))
     case v if v.valueType == NUMBER  ⇒ JsNumber(BigDecimal(v.unwrapped.asInstanceOf[java.lang.Number].toString))
     case v if v.valueType == BOOLEAN ⇒ JsBoolean(v.unwrapped.asInstanceOf[Boolean])
     case v if v.valueType == NULL    ⇒ JsNull
     case v if v.valueType == STRING  ⇒ JsString(v.unwrapped.asInstanceOf[String])
-  })
+  }
 
-  implicit val configWrites = OWrites { (cfg: Configuration) ⇒
+  implicit def configWrites: OWrites[Configuration] = OWrites[Configuration] { cfg ⇒
     JsObject(cfg.subKeys.map(key ⇒ key → configValueWrites.writes(cfg.underlying.getValue(key))).toSeq)
   }
 }
diff --git a/install/docker/entrypoint b/install/docker/entrypoint
diff --git a/install/empty b/install/empty