refactored controllers

app/controllers/BaseController.scala

+package controllers
+
+import models.CerebroRequest
+import play.api.Logger
+import play.api.mvc.{Action, Controller, Result}
+
+import scala.concurrent.Future
+
+trait BaseController extends Controller {
+
+  protected val logger = Logger("elastic")
+
+  def execute = Action.async(parse.json) { request =>
+    try {
+      processRequest(CerebroRequest(request.body))
+    } catch {
+      case _ => Future.successful(Status(500)(s"Error")) // FIXME: proper error handling
+    }
+  }
+
+  def processRequest: CerebroRequest => Future[Result]
+
+}

app/controllers/ClearIndexCacheController.scala

+package controllers
+
+import elastic.ElasticClient.clearIndexCache
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class ClearIndexCacheController extends BaseController {
+
+  def processRequest = { request =>
+    clearIndexCache(request.get("indices"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/CloseIndexController.scala

+package controllers
+
+import elastic.ElasticClient.closeIndex
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class CloseIndexController extends BaseController {
+
+  def processRequest = { request =>
+    closeIndex(request.get("indices"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/ClusterOverviewController.scala

@@ -2,30 +2,29 @@ package controllers
 
 import elastic.ElasticClient._
 import models.overview.ClusterOverview
-import play.api.mvc.{Action, Controller}
 
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 
 
-object ClusterOverviewController extends Controller {
+class ClusterOverviewController extends BaseController {
 
-  def index = Action.async {
+  def processRequest = {
     request => {
-      val host = request.queryString.getOrElse("host", Seq("http://localhost:9200")).head
-      try {
-        val response = Future.sequence(
-          Seq(clusterState(host), nodesStats(host), indicesStats(host), clusterSettings(host), aliases(host), clusterHealth(host), nodes(host), main(host))
+      Future.sequence(
+        Seq(
+          clusterState(request.host),
+          nodesStats(request.host),
+          indicesStats(request.host),
+          clusterSettings(request.host),
+          aliases(request.host),
+          clusterHealth(request.host),
+          nodes(request.host),
+          main(request.host)
+        )
       ).map { f =>
         new ClusterOverview(f(0).body, f(1).body, f(2).body, f(3).body, f(4).body, f(5).body, f(6).body, f(7).body).json
-        }.recover {
-          case e =>
-            throw e
-        }
-        response.map(Ok(_))
-      } catch {
-        case _ => Future.successful(Status(500)(s"Cannot connect to $host"))
-      }
+      }.map(Ok(_))
     }
 
   }

app/controllers/DeleteIndexController.scala

+package controllers
+
+import elastic.ElasticClient.deleteIndex
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class DeleteIndexController extends BaseController {
+
+  def processRequest = { request =>
+    deleteIndex(request.get("indices"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/DisableShardAllocationController.scala

+package controllers
+
+import elastic.ElasticClient.disableShardAllocation
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class DisableShardAllocationController extends BaseController {
+
+  def processRequest = { request =>
+    disableShardAllocation(request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/EnableShardAllocationController.scala

+package controllers
+
+import elastic.ElasticClient.enableShardAllocation
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class EnableShardAllocationController extends BaseController {
+
+  def processRequest = { request =>
+    enableShardAllocation(request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/GetIndexMapping.scala

+package controllers
+
+import elastic.ElasticClient.getIndexMapping
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class GetIndexMapping extends BaseController {
+
+  def processRequest = { request =>
+    getIndexMapping(request.get("index"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/GetIndexSettings.scala

+package controllers
+
+import elastic.ElasticClient.getIndexSettings
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class GetIndexSettings extends BaseController {
+
+  def processRequest = { request =>
+    getIndexSettings(request.get("index"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/GetShardStats.scala

+package controllers
+
+import elastic.ElasticClient.{getIndexRecovery, getShardStats}
+import models.ShardStats
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class GetShardStats extends BaseController {
+
+  def processRequest = { r =>
+    getShardStats(r.get("index"), r.host).zip(getIndexRecovery(r.get("index"), r.host)).map {
+      case (stats, recovery) =>
+        val shardStats = ShardStats(r.get("index"), r.get("node"), r.getInt("shard"), stats.body, recovery.body)
+        Status(200)(shardStats)
+    }
+  }
+
+}

app/controllers/Main.scala

 package controllers
 
-import controllers.elasticsearch.ElasticsearchController
 import elastic.ElasticClient
+import scala.concurrent.ExecutionContext.Implicits.global
 
-object Main extends ElasticsearchController {
+class Main extends BaseController {
 
-  def index = processRequest { request => ElasticClient.main(request.host) }
+  def processRequest = { request =>
+    ElasticClient.main(request.host).map { response =>
+      Status(response.status)(response.body)
+    }
+  }
 
 }

app/controllers/NodeStatsController.scala

+package controllers
+
+import elastic.ElasticClient.nodesStats
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class NodeStatsController extends BaseController {
+
+  def processRequest = { request =>
+    nodesStats(request.get("node"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/OpenIndexController.scala

+package controllers
+
+import elastic.ElasticClient.openIndex
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class OpenIndexController extends BaseController {
+
+  def processRequest = { request =>
+    openIndex(request.get("indices"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/OptimizeIndexController.scala

+package controllers
+
+import elastic.ElasticClient.optimizeIndex
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class OptimizeIndexController extends BaseController {
+
+  def processRequest = { request =>
+    optimizeIndex(request.get("indices"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/PutClusterSettings.scala

+package controllers
+
+import elastic.ElasticClient.putClusterSettings
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class PutClusterSettings extends BaseController {
+
+  def processRequest = { request =>
+    putClusterSettings(request.get("settings"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/RefreshIndexController.scala

+package controllers
+
+import elastic.ElasticClient.refreshIndex
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+class RefreshIndexController extends BaseController {
+
+  def processRequest = { request =>
+    refreshIndex(request.get("indices"), request.host).map {
+      response => Status(response.status)(response.body)
+    }
+  }
+
+}

app/controllers/elasticsearch/ClearIndexCacheController.scala

-package controllers.elasticsearch
-
-import elastic.ElasticClient
-
-class ClearIndexCacheController extends ElasticsearchController {
-
-  def index = processRequest { request => ElasticClient.clearIndexCache(request.get("indices"), request.host) }
-
-}

app/controllers/elasticsearch/CloseIndexController.scala

-package controllers.elasticsearch
-
-
-import elastic.ElasticClient
-
-class CloseIndexController extends ElasticsearchController {
-
-  def index = processRequest { request => ElasticClient.closeIndex(request.get("indices"), request.host) }
-
-}

app/controllers/elasticsearch/DeleteIndexController.scala

-package controllers.elasticsearch
-
-
-import elastic.ElasticClient
-
-class DeleteIndexController extends ElasticsearchController {
-
-  def index = processRequest { request => ElasticClient.deleteIndex(request.get("indices"), request.host) }
-
-}

app/controllers/elasticsearch/DisableShardAllocationController.scala

-package controllers.elasticsearch
-
-import elastic.ElasticClient
-
-class DisableShardAllocationController extends ElasticsearchController {
-
-  def index = processRequest { request => ElasticClient.disableShardAllocation(request.host) }
-
-}