mongoDB session storage

build.sbt

@@ -45,6 +45,7 @@ lazy val server = project.in(file("server")) settings(
   version := Version,
   scalaVersion := ScalaVersion,
   libraryDependencies ++= Seq(
+    "org.mongodb" %% "casbah" % "3.1.1",
     "com.lihaoyi" %% "autowire" % autowireVersion,
     "com.lihaoyi" %% "upickle" % upickleVersion,
     "com.lihaoyi" %% "scalatags" % scalatagsVersion,

server/src/main/scala/server/Launcher.scala

 package server
 
+import java.net.URI
 import javax.servlet.ServletContext
 
+import com.mongodb.casbah.MongoClient
+import com.mongodb.{MongoCredential, ServerAddress}
 import org.eclipse.jetty.server.Server
 import org.eclipse.jetty.webapp.WebAppContext
 import org.openmole.gate.server.Servlet
 import org.scalatra.LifeCycle
 import org.scalatra.servlet.ScalatraListener
+import server.Launcher.MongoDB
 
 object Launcher extends App {
-
+  case class MongoDB(host: String, port: Int, db: String, dataSet: String)
+
+  val mongoDBArguments = "mongoDBArguments"
+  val option = args.headOption
+  val mongoURI = new URI(option.getOrElse("mongodb://localhost:27017/openmole?login"))
+  println(mongoURI)
+  val mongoDB = {
+    val host = mongoURI.getHost
+    println(host)
+    val port = mongoURI.getPort
+    println(port)
+    println("path=" + mongoURI.getPath)
+    val db = mongoURI.getPath.drop(1)
+    println("query=" + mongoURI.getQuery)
+    val dataSet = mongoURI.getQuery
+    //if (mongoURI.getHost== null || mongoURI.getHost.isEmpty) None
+    //else Some(MongoDB(host, port, db, dataSet))
+    MongoDB(host, port, db, dataSet)
+  }
   val server = new Server(8080)
   val context = new WebAppContext()
 
+  context.setAttribute(mongoDBArguments, mongoDB)
+
   val webapp = getClass.getClassLoader.getResource("webapp").toExternalForm
 
   context setContextPath "/"
@@ -26,9 +50,9 @@ object Launcher extends App {
 
 }
 
-
 class GateBootstrap extends LifeCycle {
   override def init(context: ServletContext) {
-    context.mount(new Servlet, "/*")
+    val mongoDB = context.get(Launcher.mongoDBArguments).get.asInstanceOf[MongoDB]
+    context.mount(new Servlet(mongoDB), "/*")
   }
 }
\ No newline at end of file

server/src/main/scala/server/Servlet.scala

 package org.openmole.gate.server
 
+import com.mongodb.{MongoCredential, ServerAddress}
+import com.mongodb.casbah.Imports.{MongoCollection, MongoDBObject}
+import com.mongodb.casbah.MongoClient
 import org.openmole.gate.server.Data.User
 import org.scalatra._
 import org.scalatra.auth.{ScentryConfig, ScentrySupport}
 import org.scalatra.auth.strategy.{BasicAuthStrategy, BasicAuthSupport}
 import server.DBStrategy
+import server.Launcher.MongoDB
 
 import scala.concurrent.duration._
 import scala.concurrent.Await
@@ -18,24 +22,54 @@ object AutowireServer extends autowire.Server[String, upickle.default.Reader, up
   def write[Result: upickle.default.Writer](r: Result) = upickle.default.write(r)
 }
 
-class Servlet extends ScalatraServlet with AuthenticationSupport {
+class Servlet(mongoDB: MongoDB) extends ScalatraServlet with AuthenticationSupport {
 
   val basePath = "shared"
 
+  val head = tags.head(
+    tags.meta(tags.httpEquiv := "Content-Type", tags.content := "text/html; charset=UTF-8"),
+    tags.link(tags.rel := "stylesheet", tags.`type` := "text/css", href := "css/bootstrap.min.css"),
+    tags.script(tags.`type` := "text/javascript", tags.src := "js/gate.js")
+  )
+
   get("/") {
-    val user: User = auth("DB").get
     contentType = "text/html"
-    tags.html(
-      tags.head(
-        tags.meta(tags.httpEquiv := "Content-Type", tags.content := "text/html; charset=UTF-8"),
-        tags.link(tags.rel := "stylesheet", tags.`type` := "text/css", href := "css/bootstrap.min.css"),
-        tags.script(tags.`type` := "text/javascript", tags.src := "js/gate.js")
-      ),
-      tags.body(
-        div("authenticated: " + user.login),
-        script("client.Gate.run();")
-      )
-    )
+    auth("DB") match {
+      case Some(user) =>
+        val userSession = MongoDBObject(user.login -> session.getId)
+        println(mongoDB.host + " => " + mongoDB.port)
+        val server = new ServerAddress(mongoDB.host, mongoDB.port)
+        val credentials = MongoCredential.createCredential("accountUser", "products", "password".toCharArray)
+        val mongoClient = MongoClient(server, List(credentials))
+        println(mongoDB.db + " ? " + mongoDB.dataSet)
+        val mongoColl = mongoClient(mongoDB.db)(mongoDB.dataSet)
+        mongoColl.findOne(userSession) match {
+          case Some(x) =>
+            tags.html(
+              head,
+              tags.body(
+                div("already authenticated: " + user.login),
+                script("client.Gate.run();")
+              )
+            )
+          case None =>
+            mongoColl += userSession
+            tags.html(
+              head,
+              tags.body(
+                div("authenticated: " + user.login),
+                script("client.Gate.run();")
+              )
+            )
+        }
+      case None =>
+        tags.html(
+          head,
+          tags.body(
+            div("Failed to authenticate")
+          )
+        )
+    }
   }
 
   post(s"/$basePath/*") {