Refactor the way of loading hosts from configuration. Add test case f…

…or CerebroRequest

app/controllers/RestController.scala

@@ -45,7 +45,7 @@ class RestController @Inject()(val authentication: AuthenticationModule,
       case Success(status, body) =>
         val data = Json.obj(
           "mappings" -> ClusterMapping(body),
-          "host"    -> request.target.host
+          "host"    -> request.target.host.name
         )
         CerebroResponse(status, data)
 

app/elastic/HTTPElasticClient.scala

@@ -319,10 +319,10 @@ class HTTPElasticClient @Inject()(client: WSClient) extends ElasticClient {
                            body: Option[String] = None,
                            target: ElasticServer,
                            headers: Seq[(String, String)] = Seq()) = {
-    val authentication = target.authentication
-    val url = s"${target.host.replaceAll("/+$", "")}$uri"
+    val authentication = target.host.authentication
+    val url = s"${target.host.name.replaceAll("/+$", "")}$uri"
 
-    val mergedHeaders = headers ++ target.forwardHeaders()
+    val mergedHeaders = headers ++ target.headers
 
     val request =
       authentication.foldLeft(client.url(url).withMethod(method).withHttpHeaders(mergedHeaders: _*)) {

app/models/CerebroRequest.scala

@@ -39,7 +39,7 @@ object CerebroRequest {
   def apply(request: AuthRequest[JsValue], hosts: Hosts): CerebroRequest = {
     val body = request.body
 
-    val host = (body \ "host").asOpt[String].getOrElse(throw MissingTargetHostException)
+    val hostName = (body \ "host").asOpt[String].getOrElse(throw MissingTargetHostException)
     val username = (body \ "username").asOpt[String]
     val password = (body \ "password").asOpt[String]
 
@@ -48,12 +48,13 @@ object CerebroRequest {
       case _ => None
     }
 
-    val server = hosts.getServer(host) match {
-      case Some(ElasticServer(h, a, forward_header)) => ElasticServer(h, a.orElse(requestAuth), forward_header)
-      case None => ElasticServer(host, requestAuth)
+    val server = hosts.getHost(hostName) match {
+      case Some(host @ Host(h, a, headersWhitelist)) =>
+        val headers = headersWhitelist.flatMap(headerName => request.headers.get(headerName).map(headerName -> _))
+        ElasticServer(host.copy(authentication = a.orElse(requestAuth)), headers)
+      case None => ElasticServer(Host(hostName, requestAuth))
     }
 
-    server.setForwardHeader(request.headers)
     CerebroRequest(server, body, request.user)
   }
 

app/models/ElasticServer.scala

@@ -1,18 +1,3 @@
 package models
 
-import play.api.mvc.Headers
-
-case class ElasticServer(host: String, authentication: Option[ESAuth] = None, forwardHeadersNames: Seq[String] = Seq.empty) {
-
-  protected var _headers: Seq[(String, String)] = Seq()
-
-  def setForwardHeader(headers : Headers) {
-    for (e <- forwardHeadersNames) {
-      if (headers.hasHeader(e)) {
-        _headers = _headers :+ (e, headers.get(e).orNull)
-      }
-    }
-  }
-
-  def forwardHeaders(): Seq[(String, String)] = _headers
-}
+case class ElasticServer(host: Host, headers: Seq[(String, String)] = Seq.empty)

app/models/Host.scala

@@ -0,0 +1,3 @@
+package models
+
+case class Host(name: String, authentication: Option[ESAuth] = None, headersWhitelist: Seq[String] = Seq.empty)

app/models/Hosts.scala

@@ -14,30 +14,30 @@ trait Hosts {
 
   def getHostNames(): Seq[String]
 
-  def getServer(name: String): Option[ElasticServer]
+  def getHost(name: String): Option[Host]
 
 }
 
 @Singleton
 class HostsImpl @Inject()(config: Configuration) extends Hosts {
 
-  val hosts: Map[String, ElasticServer] = Try(config.underlying.getConfigList("hosts").asScala.map(Configuration(_))) match {
+  val hosts: Map[String, Host] = Try(config.underlying.getConfigList("hosts").asScala.map(Configuration(_))) match {
     case Success(hostsConf) => hostsConf.map { hostConf =>
       val host = hostConf.getOptional[String]("host").get
       val name = hostConf.getOptional[String]("name").getOrElse(host)
       val username = hostConf.getOptional[String]("auth.username")
       val password = hostConf.getOptional[String]("auth.password")
-      val forward_headers = hostConf.getOptional[Seq[String]](path = "forward_headers").getOrElse(Seq.empty[String])
+      val headersWhitelist = hostConf.getOptional[Seq[String]](path = "headers-whitelist")  .getOrElse(Seq.empty[String])
       (username, password) match {
-        case (Some(username), Some(password)) => (name -> ElasticServer(host, Some(ESAuth(username, password)), forward_headers))
-        case _ => (name -> ElasticServer(host, None, forward_headers))
+        case (Some(username), Some(password)) => name -> Host(host, Some(ESAuth(username, password)), headersWhitelist)
+        case _ => name -> Host(host, None, headersWhitelist)
       }
     }.toMap
     case Failure(_) => Map()
   }
 
   def getHostNames() = hosts.keys.toSeq
 
-  def getServer(name: String) = hosts.get(name)
+  def getHost(name: String) = hosts.get(name)
 
 }

conf/application.conf

@@ -60,7 +60,7 @@ hosts = [
   #{
   #  host = "http://localhost:9200"
   #  name = "Localhost cluster"
-  #  forward_headers = [ "x-proxy-user", "x-proxy-roles", "X-Forwarded-For" ]
+  #  headers-whitelist = [ "x-proxy-user", "x-proxy-roles", "X-Forwarded-For" ]
   #}
   # Example of host with authentication
   #{

test/controllers/AnalysisControllerSpec.scala

@@ -1,7 +1,7 @@
 package controllers
 
 import elastic.{ElasticResponse, Success}
-import models.ElasticServer
+import models.{ElasticServer, Host}
 import play.api.libs.json.Json
 import play.api.test.FakeRequest
 import play.api.test.Helpers._
@@ -30,7 +30,7 @@ object AnalysisControllerSpec extends MockedServices {
         |]
       """.stripMargin
     )
-    client.getIndices(ElasticServer("somehost")) returns Future.successful(Success(200, expectedResponse))
+    client.getIndices(ElasticServer(Host("somehost"))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/analysis/indices").withBody(Json.obj("host" -> "somehost"))).get
     ensure(response, 200, Json.arr("index1", "index2"))
   }
@@ -58,7 +58,7 @@ object AnalysisControllerSpec extends MockedServices {
         |}
       """.stripMargin
     )
-    client.getIndexSettings("foo", ElasticServer("somehost")) returns Future.successful(Success(200, expectedResponse))
+    client.getIndexSettings("foo", ElasticServer(Host("somehost"))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/analysis/analyzers").withBody(Json.obj("host" -> "somehost", "index" -> "foo"))).get
     ensure(response, 200, Json.arr("foo_analyzer"))
   }
@@ -83,7 +83,7 @@ object AnalysisControllerSpec extends MockedServices {
         |}
       """.stripMargin
     )
-    client.getIndexMapping("foo", ElasticServer("somehost")) returns Future.successful(Success(200, expectedResponse))
+    client.getIndexMapping("foo", ElasticServer(Host("somehost"))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/analysis/fields").withBody(Json.obj("host" -> "somehost", "index" -> "foo"))).get
     ensure(response, 200, Json.arr("name"))
   }
@@ -104,7 +104,7 @@ object AnalysisControllerSpec extends MockedServices {
         |}
       """.stripMargin
     )
-    client.analyzeTextByAnalyzer("foo", "bar", "qux", ElasticServer("somehost")) returns Future.successful(Success(200, expectedResponse))
+    client.analyzeTextByAnalyzer("foo", "bar", "qux", ElasticServer(Host("somehost"))) returns Future.successful(Success(200, expectedResponse))
     val params = Json.obj("host" -> "somehost", "index" -> "foo", "analyzer" -> "bar", "text" -> "qux")
     val response = route(application, FakeRequest(POST, "/analysis/analyze/analyzer").withBody(params)).get
     val expected = Json.parse(
@@ -138,7 +138,7 @@ object AnalysisControllerSpec extends MockedServices {
         |}
       """.stripMargin
     )
-    client.analyzeTextByField("foo", "bar", "qux", ElasticServer("somehost")) returns Future.successful(Success(200, expectedResponse))
+    client.analyzeTextByField("foo", "bar", "qux", ElasticServer(Host("somehost"))) returns Future.successful(Success(200, expectedResponse))
     val params = Json.obj("host" -> "somehost", "index" -> "foo", "field" -> "bar", "text" -> "qux")
     val response = route(application, FakeRequest(POST, "/analysis/analyze/field").withBody(params)).get
     val expected = Json.parse(

test/controllers/ClusterChangesControllerSpec.scala

@@ -1,7 +1,7 @@
 package controllers
 
 import elastic.Success
-import models.ElasticServer
+import models.{ElasticServer, Host}
 import play.api.libs.json.Json
 import play.api.test.FakeRequest
 import play.api.test.Helpers._
@@ -117,9 +117,9 @@ object ClusterChangesControllerSpec extends MockedServices {
         |}
       """.stripMargin
     )
-    client.executeRequest("GET", "_cluster/state/blocks", None, ElasticServer("somehost", None)) returns Future.successful(Success(200, stateResponse))
-    client.executeRequest("GET", "_nodes/transport", None, ElasticServer("somehost", None)) returns Future.successful(Success(200, nodesResponse))
-    client.executeRequest("GET", "_aliases", None, ElasticServer("somehost", None)) returns Future.successful(Success(200, aliasesResponse))
+    client.executeRequest("GET", "_cluster/state/blocks", None, ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, stateResponse))
+    client.executeRequest("GET", "_nodes/transport", None, ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, nodesResponse))
+    client.executeRequest("GET", "_aliases", None, ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, aliasesResponse))
     val response = route(application, FakeRequest(POST, "/cluster_changes").withBody(Json.obj("host" -> "somehost"))).get
     ensure(response, 200, expectedResponse)
   }

test/controllers/ClusterSettingsControllerSpec.scala

@@ -1,7 +1,7 @@
 package controllers
 
 import elastic.Success
-import models.ElasticServer
+import models.{ElasticServer, Host}
 import play.api.libs.json.Json
 import play.api.test.FakeRequest
 import play.api.test.Helpers._
@@ -28,7 +28,7 @@ object ClusterSettingsControllerSpec extends MockedServices {
         |}
       """.stripMargin
     )
-    client.getClusterSettings(ElasticServer("somehost", None)) returns Future.successful(Success(200, expectedResponse))
+    client.getClusterSettings(ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/cluster_settings").withBody(Json.obj("host" -> "somehost"))).get
     ensure(response, 200, expectedResponse)
   }
@@ -50,7 +50,7 @@ object ClusterSettingsControllerSpec extends MockedServices {
         |  "transient": {}
         |}
       """.stripMargin)
-    client.saveClusterSettings(body, ElasticServer("somehost", None)) returns Future.successful(Success(200, expectedResponse))
+    client.saveClusterSettings(body, ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/cluster_settings/save").withBody(Json.obj("host" -> "somehost", "settings" -> body))).get
     ensure(response, 200, expectedResponse)
   }

test/controllers/CommonsControllerSpec.scala

@@ -1,7 +1,7 @@
 package controllers
 
 import elastic.Success
-import models.ElasticServer
+import models.{ElasticServer, Host}
 import play.api.libs.json.Json
 import play.api.test.FakeRequest
 import play.api.test.Helpers._
@@ -36,7 +36,7 @@ class CommonsControllerSpec extends MockedServices {
         |]
       """.stripMargin
     )
-    client.getIndices(ElasticServer("somehost", None)) returns Future.successful(Success(200, expectedResponse))
+    client.getIndices(ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/commons/indices").withBody(Json.obj("host" -> "somehost"))).get
     ensure(response, 200, Json.arr("index1", "index2"))
   }
@@ -52,7 +52,7 @@ class CommonsControllerSpec extends MockedServices {
       """.stripMargin
     )
     val body = Json.obj("host" -> "somehost", "index" -> "someIndex")
-    client.getIndexMapping("someIndex", ElasticServer("somehost", None)) returns Future.successful(Success(200, expectedResponse))
+    client.getIndexMapping("someIndex", ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/commons/get_index_mapping").withBody(body)).get
     ensure(response, 200, expectedResponse)
   }
@@ -84,7 +84,7 @@ class CommonsControllerSpec extends MockedServices {
       """.stripMargin
     )
     val body = Json.obj("host" -> "somehost", "index" -> "someIndex")
-    client.getIndexSettings("someIndex", ElasticServer("somehost", None)) returns Future.successful(Success(200, expectedResponse))
+    client.getIndexSettings("someIndex", ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/commons/get_index_settings").withBody(body)).get
     ensure(response, 200, expectedResponse)
   }
@@ -524,7 +524,7 @@ class CommonsControllerSpec extends MockedServices {
       """.stripMargin
     )
     val body = Json.obj("host" -> "somehost", "node" -> "someNode")
-    client.nodeStats("someNode", ElasticServer("somehost", None)) returns Future.successful(Success(200, expectedResponse))
+    client.nodeStats("someNode", ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/commons/get_node_stats").withBody(body)).get
     ensure(response, 200, expectedResponse)
   }

test/controllers/IndexSettingsControllerSpec.scala

@@ -1,7 +1,7 @@
 package controllers
 
 import elastic.Success
-import models.ElasticServer
+import models.{ElasticServer, Host}
 import play.api.libs.json.Json
 import play.api.test.FakeRequest
 import play.api.test.Helpers._
@@ -35,7 +35,7 @@ object IndexSettingsControllerSpec extends MockedServices {
         |}
       """.stripMargin
     )
-    client.getIndexSettingsFlat("foo", ElasticServer("somehost", None)) returns Future.successful(Success(200, expectedResponse))
+    client.getIndexSettingsFlat("foo", ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/index_settings").withBody(Json.obj("host" -> "somehost", "index" -> "foo"))).get
     ensure(response, 200, expectedResponse)
   }
@@ -57,7 +57,7 @@ object IndexSettingsControllerSpec extends MockedServices {
         |  "acknowledged":true
         |}
       """.stripMargin)
-    client.updateIndexSettings("foo", body, ElasticServer("somehost", None)) returns Future.successful(Success(200, expectedResponse))
+    client.updateIndexSettings("foo", body, ElasticServer(Host("somehost", None))) returns Future.successful(Success(200, expectedResponse))
     val response = route(application, FakeRequest(POST, "/index_settings/update").withBody(Json.obj("host" -> "somehost", "index" -> "foo", "settings" -> body))).get
     ensure(response, 200, expectedResponse)
   }