created data service for cluster overview

app/controllers/ClusterOverviewController.scala

@@ -6,44 +6,18 @@ import controllers.auth.AuthenticationModule
 import elastic.{ElasticClient, Error}
 import models.overview.ClusterOverview
 import models.{CerebroResponse, Hosts, ShardStats}
+import services.overview.OverviewDataService
 
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 
 class ClusterOverviewController @Inject()(val authentication: AuthenticationModule,
                                           val hosts: Hosts,
+                                          val service: OverviewDataService,
                                           client: ElasticClient) extends BaseController {
 
   def index = process { request =>
-    Future.sequence(
-      Seq(
-        client.clusterState(request.target),
-        client.nodesStats(Seq("jvm","fs","os","process"), request.target),
-        client.indicesStats(request.target),
-        client.clusterSettings(request.target),
-        client.aliases(request.target),
-        client.clusterHealth(request.target),
-        client.nodes(Seq("os","jvm"), request.target),
-        client.main(request.target)
-      )
-    ).map { responses =>
-      val failed = responses.find(_.isInstanceOf[Error])
-      failed match {
-        case Some(f) => CerebroResponse(f.status, f.body)
-        case None =>
-          val overview = ClusterOverview(
-            responses(0).body,
-            responses(1).body,
-            responses(2).body,
-            responses(3).body,
-            responses(4).body,
-            responses(5).body,
-            responses(6).body,
-            responses(7).body
-          )
-          CerebroResponse(200, overview)
-      }
-    }
+    service.overview(request.target).map(CerebroResponse(200, _))
   }
 
   def disableShardAllocation = process { request =>

app/models/overview/ClusterOverview.scala

@@ -6,8 +6,7 @@ object ClusterOverview {
 
   def apply(clusterState: JsValue, nodesStats: JsValue, indicesStats: JsValue,
             clusterSettings: JsValue, aliases: JsValue, clusterHealth: JsValue,
-            nodesInfo: JsValue, main: JsValue): JsValue = {
-
+            nodesInfo: JsValue): JsValue = {
     val indices = buildIndices(clusterState, indicesStats, aliases)
 
     val masterNodeId = (clusterState \ "master_node").as[String]

app/services/overview/OverviewDataService.scala

+package services.overview
+
+import com.google.inject.Inject
+import elastic.{ElasticClient, Error}
+import models.ElasticServer
+import models.overview.ClusterOverview
+import play.api.libs.json.JsValue
+import services.exception.RequestFailedException
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+
+class OverviewDataService @Inject()(client: ElasticClient) {
+
+  def overview(target: ElasticServer): Future[JsValue] = {
+    val apis = Seq(
+      "_cluster/state/master_node,routing_table,routing_nodes,blocks",
+      "_nodes/stats/jvm,fs,os,process?human=true",
+      "_stats/docs,store",
+      "_cluster/settings",
+      "_aliases",
+      "_cluster/health",
+      s"_nodes/_all/os,jvm?human=true",
+      ""
+    )
+
+    val start = System.currentTimeMillis()
+    Future.sequence(apis.map(client.executeRequest("GET", _, None, target))).map { responses =>
+      responses.zipWithIndex.find(_._1.isInstanceOf[Error]) match {
+        case Some((failed, idx)) =>
+          throw RequestFailedException(apis(idx), failed.status, failed.body.toString())
+
+        case None =>
+          val end = System.currentTimeMillis()
+          val overview = ClusterOverview(
+            responses(0).body,
+            responses(1).body,
+            responses(2).body,
+            responses(3).body,
+            responses(4).body,
+            responses(5).body,
+            responses(6).body,
+            responses(7).body
+          )
+          println(s"Requesting took [${end - start}]")
+          overview
+      }
+    }
+  }
+
+}