From f68b41a80bffc3eda736fb4f7c9698f371b18eee Mon Sep 17 00:00:00 2001
From: To-om <toom@thehive-project.org>
Date: Wed, 3 May 2017 12:28:56 +0200
Subject: [PATCH] #21 Fix cyclic dependency, rename logger, make
 misp-modules-loader executable

---
 app/services/Analyzer.scala    | 36 ++++++++++++++++++----------------
 contrib/misp-modules-loader.py |  0
 2 files changed, 19 insertions(+), 17 deletions(-)
 mode change 100644 => 100755 contrib/misp-modules-loader.py

diff --git a/app/services/Analyzer.scala b/app/services/Analyzer.scala
index d063747d9..6e9bb5518 100644
--- a/app/services/Analyzer.scala
+++ b/app/services/Analyzer.scala
@@ -2,7 +2,7 @@ package services
 
 import java.io.File
 import java.nio.file.{ Files, Path, Paths }
-import javax.inject.Inject
+import javax.inject.{ Inject, Provider }
 
 import akka.actor.ActorSystem
 import models.{ Analyzer, ExternalAnalyzer, MispModule }
@@ -15,29 +15,31 @@ import scala.concurrent.ExecutionContext
 import scala.util.Try
 
 class AnalyzerSrv(
-    mispSrv: MispSrv,
+    mispSrvProvider: Provider[MispSrv],
     analyzerPath: Path,
     analyzerConfig: JsObject,
     mispModulesPath: Path,
     mispModuleLoaderCommand: Option[String],
     akkaSystem: ActorSystem) {
   @Inject def this(
-    mispSrv: MispSrv,
+    mispSrvProvider: Provider[MispSrv],
     configuration: Configuration,
     akkaSystem: ActorSystem) =
     this(
-      mispSrv,
+      mispSrvProvider,
       Paths.get(configuration.getString("analyzer.path").getOrElse(".")),
       configWrites.writes(configuration.getConfig("analyzer.config").getOrElse(Configuration.empty)),
       Paths.get(configuration.getString("misp.modules.path").getOrElse(".")),
       configuration.getString("misp.modules.loader"),
       akkaSystem)
 
-  lazy val log = Logger(getClass)
+  private[AnalyzerSrv] lazy val logger = Logger(getClass)
   lazy val analyzeExecutionContext: ExecutionContext = akkaSystem.dispatchers.lookup("analyzer")
+  lazy val mispSrv = mispSrvProvider.get
 
   private lazy val externalAnalyzers: Seq[Analyzer] = getExternalAnalyzers
-  def list: Seq[Analyzer] = externalAnalyzers // ::: javaAnalyzers
+  private lazy val mispModules: Seq[Analyzer] = getMispModules
+  def list: Seq[Analyzer] = externalAnalyzers ++ mispModules // ::: javaAnalyzers
   def get(analyzerId: String): Option[Analyzer] = list.find(_.id == analyzerId)
   def listForType(dataType: String): Seq[Analyzer] = list.filter(_.dataTypeList.contains(dataType))
 
@@ -45,7 +47,7 @@ class AnalyzerSrv(
     val globalConfig = (analyzerConfig \ "global").asOpt[JsObject].getOrElse(JsObject(Nil))
     for {
       analyzerDir ← Try(Files.newDirectoryStream(analyzerPath).toSeq).getOrElse {
-        log.warn(s"Analyzer directory ($analyzerPath) is not found")
+        logger.warn(s"Analyzer directory ($analyzerPath) is not found")
         Nil
       }
       if Files.isDirectory(analyzerDir)
@@ -53,40 +55,40 @@ class AnalyzerSrv(
       if Files.isReadable(infoFile)
       info = readInfo(infoFile)
       name ← (info \ "name").asOpt[String] orElse {
-        log.warn(s"name is missing in $infoFile"); None
+        logger.warn(s"name is missing in $infoFile"); None
       }
       version ← (info \ "version").asOpt[String] orElse {
-        log.warn(s"version is missing in $infoFile"); None
+        logger.warn(s"version is missing in $infoFile"); None
       }
       description ← (info \ "description").asOpt[String] orElse {
-        log.warn(s"description is missing in $infoFile"); None
+        logger.warn(s"description is missing in $infoFile"); None
       }
       dataTypeList ← (info \ "dataTypeList").asOpt[Seq[String]] orElse {
-        log.warn(s"dataTypeList is missing in $infoFile"); None
+        logger.warn(s"dataTypeList is missing in $infoFile"); None
       }
       command ← (info \ "command").asOpt[String] orElse {
-        log.warn(s"command is missing in $infoFile"); None
+        logger.warn(s"command is missing in $infoFile"); None
       }
       author ← (info \ "author").asOpt[String] orElse {
-        log.warn(s"author is missing in $infoFile"); None
+        logger.warn(s"author is missing in $infoFile"); None
       }
       url ← (info \ "url").asOpt[String] orElse {
-        log.warn(s"url is missing in $infoFile"); None
+        logger.warn(s"url is missing in $infoFile"); None
       }
       license ← (info \ "license").asOpt[String] orElse {
-        log.warn(s"license is missing in $infoFile"); None
+        logger.warn(s"license is missing in $infoFile"); None
       }
       config = (info \ "config").asOpt[JsObject].getOrElse(JsObject(Nil))
       baseConfig = (info \ "baseConfig").asOpt[String].flatMap(c ⇒ (analyzerConfig \ c).asOpt[JsObject]).getOrElse(JsObject(Nil))
       absoluteCommand = analyzerPath.resolve(Paths.get(command.replaceAll("[\\/]", File.separator)))
-      _ = log.info(s"Register analyzer $name $version (${(name + "_" + version).replaceAll("\\.", "_")})")
+      _ = logger.info(s"Register analyzer $name $version (${(name + "_" + version).replaceAll("\\.", "_")})")
     } yield ExternalAnalyzer(name, version, description, dataTypeList, author, url, license, absoluteCommand, globalConfig deepMerge baseConfig deepMerge config)(analyzeExecutionContext)
   }
 
   private[services] def getMispModules: Seq[Analyzer] = {
     for {
       moduleFile ← Try(Files.newDirectoryStream(mispModulesPath).toSeq).getOrElse {
-        log.warn(s"MISP modules directory ($mispModulesPath) is not found")
+        logger.warn(s"MISP modules directory ($mispModulesPath) is not found")
         Nil
       }
       loaderCommand ← mispModuleLoaderCommand
diff --git a/contrib/misp-modules-loader.py b/contrib/misp-modules-loader.py
old mode 100644
new mode 100755