pass client as a param to controller impl for easier testing

package controllers

import elastic.ElasticClient

import models.CerebroRequest

import play.api.Logger

import play.api.libs.json.Json

import play.api.mvc.{Action, Controller, Result}

import scala.concurrent.Future

import scala.util.control.NonFatal

trait BaseController extends Controller {

  protected val logger = Logger("elastic")

  def execute = Action.async(parse.json) { request =>

  final def execute = Action.async(parse.json) { request =>

    try {

      processRequest(CerebroRequest(request.body))

      processRequest(CerebroRequest(request.body), ElasticClient)

    } catch {

      case _ => Future.successful(Status(500)(s"Error")) // FIXME: proper error handling

      case NonFatal(e) => Future.successful(Status(500)(Json.obj("error" -> "Error"))) // FIXME: proper error handling

    }

  }

  def processRequest: CerebroRequest => Future[Result]

  def processRequest: (CerebroRequest, ElasticClient) => Future[Result]

}

package controllers

import elastic.ElasticClient.clearIndexCache

class ClearIndexCacheController extends ElasticActionController {

  def processElasticRequest = request => clearIndexCache(request.get("indices"), request.host)

  def processElasticRequest = (request, client) => client.clearIndexCache(request.get("indices"), request.host)

}

package controllers

import elastic.ElasticClient.closeIndex

class CloseIndexController extends ElasticActionController {

  def processElasticRequest = request => closeIndex(request.get("indices"), request.host)

  def processElasticRequest = (request, client) => client.closeIndex(request.get("indices"), request.host)

}

package controllers

import elastic.ElasticClient._

import models.overview.ClusterOverview

import scala.concurrent.ExecutionContext.Implicits.global

class ClusterOverviewController extends BaseController {

  def processRequest = {

    request => {

    (request, client) => {

      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)

          client.clusterState(request.host),

          client.nodesStats(request.host),

          client.indicesStats(request.host),

          client.clusterSettings(request.host),

          client.aliases(request.host),

          client.clusterHealth(request.host),

          client.nodes(request.host),

          client.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

package controllers

import elastic.ElasticClient.deleteIndex

class DeleteIndexController extends ElasticActionController {

  def processElasticRequest = request => deleteIndex(request.get("indices"), request.host)

  def processElasticRequest = (request, client) => client.deleteIndex(request.get("indices"), request.host)

}