group apis by module (df690d07) · Commits · nimrod / cerebro

app/controllers/UpdateAliasesController.scala→app/controllers/AliasesController.scala

+9 −4

Original line number	Diff line number	Diff line
		package controllers

		import models.ElasticServer
		import models.{Aliases, ElasticServer}
		import play.api.libs.json.JsArray

		import scala.concurrent.ExecutionContext.Implicits.global

		class UpdateAliasesController extends BaseController {
		class AliasesController extends BaseController {

		def getAliases = process { (request, client) =>
		client.getAliases(ElasticServer(request.host, request.authentication)).map { aliases =>
		Status(aliases.status)(Aliases(aliases.body))
		}
		}

		def execute = process { (request, client) =>
		def updateAliases = process { (request, client) =>
		val changes = request.getOptArray("changes").getOrElse(JsArray()).value
		client.updateAliases(changes, ElasticServer(request.host, request.authentication)).map { aliases =>
		Status(aliases.status)(aliases.body)

app/controllers/BaseController.scala

+5 −1

Original line number	Diff line number	Diff line
		package controllers

		import elastic.ElasticClient
		import exceptions.MissingRequiredParamException
		import models.CerebroRequest
		import play.api.Logger
		import play.api.libs.json.Json
		@@ -21,7 +22,10 @@ trait BaseController extends Controller {
		try {
		processor(CerebroRequest(request.body), client)
		} catch {
		case NonFatal(e) => Future.successful(Status(500)(Json.obj("error" -> "Error"))) // FIXME: proper error handling
		case e: MissingRequiredParamException =>
		Future.successful(Status(400)(Json.obj("error" -> e.getMessage))) // FIXME: proper error handling
		case NonFatal(e) =>
		Future.successful(Status(500)(Json.obj("error" -> "Error"))) // FIXME: proper error handling
		}
		}

app/controllers/ClearIndexCacheController.scala

deleted100644 → 0

+0 −9

Original line number	Diff line number	Diff line
		package controllers

		import models.ElasticServer

		class ClearIndexCacheController extends ElasticActionController {

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

		}

app/controllers/CloseIndexController.scala

deleted100644 → 0

+0 −9

Original line number	Diff line number	Diff line
		package controllers

		import models.ElasticServer

		class CloseIndexController extends ElasticActionController {

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

		}

app/controllers/ClusterOverviewController.scala

+61 −2

Original line number	Diff line number	Diff line
		package controllers

		import models.ElasticServer
		import models.{ElasticServer, IndexMetadata, ShardStats}
		import models.overview.ClusterOverview

		import scala.concurrent.ExecutionContext.Implicits.global
		@@ -8,7 +8,7 @@ import scala.concurrent.Future

		class ClusterOverviewController extends BaseController {

		def execute = process { (request, client) =>
		def index = process { (request, client) =>
		Future.sequence(
		Seq(
		client.clusterState(ElasticServer(request.host, request.authentication)),
		@@ -25,4 +25,63 @@ class ClusterOverviewController extends BaseController {
		}.map(Ok(_))
		}

		def disableShardAllocation = process { (request, client) =>
		client.disableShardAllocation(ElasticServer(request.host, request.authentication)).map { response =>
		Status(response.status)(response.body)
		}
		}

		def enableShardAllocation = process { (request, client) =>
		client.enableShardAllocation(ElasticServer(request.host, request.authentication)).map { response =>
		Status(response.status)(response.body)
		}
		}

		def closeIndices = process { (request, client) =>
		client.closeIndex(request.get("indices"), ElasticServer(request.host, request.authentication)).map { response =>
		Status(response.status)(response.body)
		}
		}

		def openIndices = process { (request, client) =>
		client.openIndex(request.get("indices"), ElasticServer(request.host, request.authentication)).map { response =>
		Status(response.status)(response.body)
		}
		}

		def forceMerge = process { (request, client) =>
		client.forceMerge(request.get("indices"), ElasticServer(request.host, request.authentication)).map { response =>
		Status(response.status)(response.body)
		}
		}

		def clearIndexCache = process { (request, client) =>
		client.clearIndexCache(request.get("indices"), ElasticServer(request.host, request.authentication)).map { response =>
		Status(response.status)(response.body)
		}
		}

		def refreshIndex = process { (request, client) =>
		client.refreshIndex(request.get("indices"), ElasticServer(request.host, request.authentication)).map { response =>
		Status(response.status)(response.body)
		}
		}

		def deleteIndex = process { (request, client) =>
		client.deleteIndex(request.get("indices"), ElasticServer(request.host, request.authentication)).map { response =>
		Status(response.status)(response.body)
		}
		}

		def getShardStats = process { (request, client) =>
		val index = request.get("index")
		val shard = request.getInt("shard")
		val node = request.get("node")
		client.getShardStats(index, ElasticServer(request.host, request.authentication)).zip(
		client.getIndexRecovery(index, ElasticServer(request.host, request.authentication))
		).map {
		case (stats, recovery) => Status(200)(ShardStats(index, node, shard, stats.body, recovery.body))
		}
		}

		}