Merge branch 'develop'

Author: Leonardo Menezes

README.md

@@ -71,3 +71,38 @@ hosts: [
 	}
 ]
 ```
+
+### User authentication
+It is possible to control access to cerebro through authentication.
+
+At the moment, there are no roles/permission level, and either an user is able to access or not.
+
+There are two methods of authentication:
+
+  - Basic: username and password on the configuration file
+  - LDAP: connect to an external provider for authentication
+
+Example for basic:
+```yaml
+auth {
+  type: basic
+  settings: {
+    username = "admin"
+    password = "1234"
+  }
+}
+```
+
+Example for LDAP:
+
+```yaml
+auth {
+  type: ldap
+  settings: {
+    url = "ldap://host:port"
+    base-dn = "ou=active,ou=Employee"
+    method  = "simple"
+    user-domain = "domain.com"
+  }
+}
+```

app/controllers/AliasesController.scala

@@ -1,21 +1,27 @@
 package controllers
 
-import models.{Aliases, ElasticServer}
+import javax.inject.Inject
+
+import controllers.auth.AuthenticationModule
+import elastic.ElasticClient
+import models.{Aliases, CerebroResponse}
 import play.api.libs.json.JsArray
+
 import scala.concurrent.ExecutionContext.Implicits.global
 
-class AliasesController extends BaseController {
+class AliasesController @Inject()(val authentication: AuthenticationModule,
+                                  client: ElasticClient) extends BaseController {
 
-  def getAliases = process { (request, client) =>
-    client.getAliases(ElasticServer(request.host, request.authentication)).map { aliases =>
-      Status(aliases.status)(Aliases(aliases.body))
+  def getAliases = process { request =>
+    client.getAliases(request.target).map { aliases =>
+      CerebroResponse(aliases.status, Aliases(aliases.body))
     }
   }
 
-  def updateAliases = process { (request, client) =>
+  def updateAliases = process { request =>
     val changes = request.getOptArray("changes").getOrElse(JsArray()).value
-    client.updateAliases(changes, ElasticServer(request.host, request.authentication)).map { aliases =>
-      Status(aliases.status)(aliases.body)
+    client.updateAliases(changes, request.target).map { aliases =>
+      CerebroResponse(aliases.status, aliases.body)
     }
   }
 

app/controllers/AnalysisController.scala

@@ -1,47 +1,52 @@
 package controllers
 
+import javax.inject.Inject
+
+import controllers.auth.AuthenticationModule
+import elastic.ElasticClient
+import models.{CerebroResponse, ElasticServer}
 import models.analysis.{IndexAnalyzers, IndexFields, OpenIndices, Tokens}
-import models.ElasticServer
 
 import scala.concurrent.ExecutionContext.Implicits.global
 
-class AnalysisController extends BaseController {
+class AnalysisController @Inject()(val authentication: AuthenticationModule,
+                                   client: ElasticClient) extends BaseController {
 
-  def getIndices = process { (request, client) =>
-    client.getIndices(ElasticServer(request.host, request.authentication)).map { response =>
-      Status(response.status)(OpenIndices(response.body))
+  def getIndices = process { request =>
+    client.getIndices(request.target).map { response =>
+      CerebroResponse(response.status, OpenIndices(response.body))
     }
   }
 
-  def getIndexAnalyzers = process { (request, client) =>
+  def getIndexAnalyzers = process { request =>
     val index = request.get("index")
-    client.getIndexSettings(index, ElasticServer(request.host, request.authentication)).map { response =>
-       Status(response.status)(IndexAnalyzers(index, response.body))
+    client.getIndexSettings(index, request.target).map { response =>
+      CerebroResponse(response.status, IndexAnalyzers(index, response.body))
     }
   }
 
-  def getIndexFields = process { (request, client) =>
+  def getIndexFields = process { request =>
     val index = request.get("index")
-    client.getIndexMapping(index, ElasticServer(request.host, request.authentication)).map { response =>
-      Status(response.status)(IndexFields(index, response.body))
+    client.getIndexMapping(index, request.target).map { response =>
+      CerebroResponse(response.status, IndexFields(index, response.body))
     }
   }
 
-  def analyzeByField = process { (request, client) =>
+  def analyzeByField = process { request =>
     val index = request.get("index")
     val field = request.get("field")
     val text = request.get("text")
-    client.analyzeTextByField(index, field, text, ElasticServer(request.host, request.authentication)).map { response =>
-      Status(response.status)(Tokens(response.body))
+    client.analyzeTextByField(index, field, text, request.target).map { response =>
+      CerebroResponse(response.status, Tokens(response.body))
     }
   }
 
-  def analyzeByAnalyzer = process { (request, client) =>
+  def analyzeByAnalyzer = process { request =>
     val index = request.get("index")
     val analyzer = request.get("analyzer")
     val text = request.get("text")
-    client.analyzeTextByAnalyzer(index, analyzer, text, ElasticServer(request.host, request.authentication)).map { response =>
-      Status(response.status)(Tokens(response.body))
+    client.analyzeTextByAnalyzer(index, analyzer, text, request.target).map { response =>
+      CerebroResponse(response.status, Tokens(response.body))
     }
   }
 

app/controllers/Application.scala

@@ -1,11 +1,12 @@
 package controllers
 
-import play.api.mvc.{Action, Controller}
-import play.api.http.MimeTypes
+import com.google.inject.Inject
+import controllers.auth.AuthenticationModule
+import play.api.mvc.Controller
 
-object Application extends Controller {
+class Application @Inject()(val authentication: AuthenticationModule) extends Controller with AuthSupport {
 
-  def index = Action {
+  def index = AuthAction(authentication, true) { request =>
     Ok(views.html.Index())
   }
 

app/controllers/AuthController.scala

@@ -0,0 +1,67 @@
+package controllers
+
+import javax.inject.{Inject, Singleton}
+
+import akka.actor.ActorSystem
+import controllers.auth.{AuthAction, AuthenticationModule}
+import forms.LoginForm
+import play.api.mvc.{Action, Controller}
+
+@Singleton
+class AuthController @Inject()(system: ActorSystem, authentication: AuthenticationModule) extends Controller {
+
+  import AuthController._
+
+  private val badFormMsg = "invalid login form data"
+
+  def index = Action { implicit request =>
+    if (authentication.isEnabled) {
+      request.session.get(AuthAction.SESSION_USER).map { user =>
+        request.session.get(AuthAction.REDIRECT_URL) match {
+          case Some(url) =>
+            Redirect(url, play.api.http.Status.SEE_OTHER)
+          case None =>
+            Redirect(routes.Application.index())
+        }
+      }.getOrElse {
+        Ok(views.html.auth.login())
+      }
+    } else {
+      Redirect(routes.Application.index())
+    }
+  }
+
+  def login = Action { implicit request =>
+    LoginForm.form.bindFromRequest.fold(
+      formWithErrors => {
+        log.error(badFormMsg)
+        BadRequest(badFormMsg)
+      },
+      creds => {
+        authentication.authentication(creds.user, creds.password) match {
+          case Some(username) =>
+            val resp =
+              request.session.get(AuthAction.REDIRECT_URL) match {
+                case Some(url) => Redirect(url, play.api.http.Status.SEE_OTHER)
+                case None => Redirect(routes.Application.index())
+              }
+            resp.withSession(AuthAction.SESSION_USER -> username)
+          case None =>
+            Redirect(routes.AuthController.index).flashing(LOGIN_MSG -> "wrong user and/or password")
+        }
+      }
+    )
+  }
+
+  def logout = Action {
+    request =>
+      Redirect("/login").withNewSession
+  }
+
+}
+
+object AuthController {
+  private val log = org.slf4j.LoggerFactory.getLogger(classOf[AuthController])
+
+  final val LOGIN_MSG = "login-msg"
+}

app/controllers/AuthSupport.scala

@@ -0,0 +1,11 @@
+package controllers
+
+import controllers.auth.{AuthAction, AuthenticationModule}
+import play.api.mvc.Controller
+
+trait AuthSupport { self: Controller =>
+
+  def AuthAction(authentication: AuthenticationModule, redirect: Boolean = false): AuthAction =
+    new AuthAction(authentication, redirect)
+
+}

app/controllers/BaseController.scala

@@ -1,31 +1,31 @@
 package controllers
 
-import elastic.ElasticClient
+import controllers.auth.AuthenticationModule
 import exceptions.MissingRequiredParamException
-import models.CerebroRequest
+import models.{CerebroRequest, CerebroResponse}
 import play.api.Logger
 import play.api.libs.json.Json
-import play.api.mvc.{Action, Controller, Result}
+import play.api.mvc.{Controller, Result}
 
 import scala.concurrent.Future
 import scala.util.control.NonFatal
 
-trait BaseController extends Controller {
+trait BaseController extends Controller with AuthSupport {
 
-  val client: ElasticClient = ElasticClient
+  val authentication: AuthenticationModule
 
   protected val logger = Logger("elastic")
 
-  type RequestProcessor = (CerebroRequest, ElasticClient) => Future[Result]
+  type RequestProcessor = (CerebroRequest) => Future[Result]
 
-  final def process(processor: RequestProcessor) = Action.async(parse.json) { request =>
+  final def process(processor: RequestProcessor) = AuthAction(authentication).async(parse.json) { request =>
     try {
-      processor(CerebroRequest(request.body), client)
+      processor(CerebroRequest(request))
     } catch {
       case e: MissingRequiredParamException =>
-        Future.successful(Status(400)(Json.obj("error" -> e.getMessage))) // FIXME: proper error handling
+        Future.successful(CerebroResponse(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
+        Future.successful(CerebroResponse(500, Json.obj("error" -> "Error"))) // FIXME: proper error handling
     }
   }
 

app/controllers/CatController.scala

@@ -1,16 +1,20 @@
 package controllers
 
-import models.analysis.{IndexAnalyzers, IndexFields, OpenIndices, Tokens}
-import models.ElasticServer
+import javax.inject.Inject
+
+import controllers.auth.AuthenticationModule
+import elastic.ElasticClient
+import models.{CerebroResponse, ElasticServer}
 
 import scala.concurrent.ExecutionContext.Implicits.global
 
-class CatController extends BaseController {
+class CatController @Inject()(val authentication: AuthenticationModule,
+                              client: ElasticClient) extends BaseController {
 
-  def get = process { (request, client) =>
+  def get = process { request =>
     val api = request.get("api")
-    client.catRequest(api, ElasticServer(request.host, request.authentication)).map { response =>
-      Status(response.status)(response.body)
+    client.catRequest(api, request.target).map { response =>
+      CerebroResponse(response.status, response.body)
     }
   }
 

app/controllers/ClusterChangesController.scala

@@ -1,25 +1,30 @@
 package controllers
 
-import models.ElasticServer
+import javax.inject.Inject
+
+import controllers.auth.AuthenticationModule
+import elastic.ElasticClient
+import models.{CerebroResponse, ElasticServer}
 import models.commons.{Indices, Nodes}
 import play.api.libs.json.Json
 
-import scala.concurrent.Future
 import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
 
-class ClusterChangesController extends BaseController {
+class ClusterChangesController @Inject()(val authentication: AuthenticationModule,
+                                         client: ElasticClient) extends BaseController {
 
-  def get = process { (request, client) =>
+  def get = process { request =>
     Future.sequence(Seq(
-      client.getIndices(ElasticServer(request.host, request.authentication)),
-      client.getNodes(ElasticServer(request.host, request.authentication)),
-      client.main(ElasticServer(request.host, request.authentication))
+      client.getIndices(request.target),
+      client.getNodes(request.target),
+      client.main(request.target)
     )).map { responses =>
       Json.obj(
         "indices" -> Indices(responses(0).body),
         "nodes" -> Nodes(responses(1).body),
         "cluster_name" -> (responses(2).body \ "cluster_name").as[String]
       )
-    }.map(Ok(_))
+    }.map(CerebroResponse(200, _))
   }
 }