Merge branch 'psk-ixolit-master'

lmenezes · May 21, 2019 · f2ed031 · f2ed031
2 parents 6a3e60e + dc0b5e9
commit f2ed031
Show file tree

Hide file tree

Showing 16 changed files with 102 additions and 55 deletions.
diff --git a/app/controllers/RestController.scala b/app/controllers/RestController.scala
@@ -47,7 +47,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)
 

diff --git a/app/elastic/HTTPElasticClient.scala b/app/elastic/HTTPElasticClient.scala
@@ -319,10 +319,13 @@ 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.headers
+
     val request =
-      authentication.foldLeft(client.url(url).withMethod(method).withHttpHeaders(headers: _*)) {
+      authentication.foldLeft(client.url(url).withMethod(method).withHttpHeaders(mergedHeaders: _*)) {
       case (request, auth) =>
         request.withAuth(auth.username, auth.password, WSAuthScheme.BASIC)
     }

diff --git a/app/models/CerebroRequest.scala b/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,10 +48,13 @@ object CerebroRequest {
       case _ => None
     }
 
-    val server = hosts.getServer(host) match {
-      case Some(ElasticServer(h, a)) => ElasticServer(h, a.orElse(requestAuth))
-      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))
     }
+
     CerebroRequest(server, body, request.user)
   }
 

diff --git a/app/models/ElasticServer.scala b/app/models/ElasticServer.scala
@@ -1,3 +1,3 @@
 package models
 
-case class ElasticServer(host: String, authentication: Option[ESAuth] = None)
+case class ElasticServer(host: Host, headers: Seq[(String, String)] = Seq.empty)
diff --git a/app/models/Host.scala b/app/models/Host.scala
@@ -0,0 +1,3 @@
+package models
+
+case class Host(name: String, authentication: Option[ESAuth] = None, headersWhitelist: Seq[String] = Seq.empty)
diff --git a/app/models/Hosts.scala b/app/models/Hosts.scala
@@ -14,29 +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 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))))
-        case _ => (name -> ElasticServer(host, None))
+        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)
 
 }
diff --git a/conf/application.conf b/conf/application.conf
@@ -65,8 +65,9 @@ auth = {
 hosts = [
   #{
   #  host = "http://localhost:9200"
-  #  name = "Some Cluster"
-  #},
+  #  name = "Localhost cluster"
+  #  headers-whitelist = [ "x-proxy-user", "x-proxy-roles", "X-Forwarded-For" ]
+  #}
   # Example of host with authentication
   #{
   #  host = "http://some-authenticated-host:9200"

diff --git a/test/controllers/AnalysisControllerSpec.scala b/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(

diff --git a/test/controllers/ClusterChangesControllerSpec.scala b/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)
   }

diff --git a/test/controllers/ClusterSettingsControllerSpec.scala b/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)
   }

diff --git a/test/controllers/CommonsControllerSpec.scala b/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)
   }

diff --git a/test/controllers/IndexSettingsControllerSpec.scala b/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)
   }