Mongo Java Server Support

Author: sfxcode

CHANGES.md

@@ -4,6 +4,7 @@
 
 ### 2.0.1
 * Mongo Java Server Support
+* LocalServer, ServerConfig added
 
 ### 2.0.0
 * mongo package no longer extends MongoImplcits => Use MongoImplcits trait if needed

README.md

@@ -17,6 +17,7 @@ Support MongoDB 2.6 to 4.2.
 * Implicit conversions for Document, Bson, ObjectID ...
 * Reactive Streams Support
 * Json loading from File, Conversion to plain Json
+* Local Server Support [mongo-java-server](https://github.com/bwaldvogel/mongo-java-server)
 * ...
 
 ## Documentation

build.sbt

@@ -55,13 +55,15 @@ libraryDependencies += "joda-time" % "joda-time" % "2.10.5" % Test
 
 libraryDependencies += "org.json4s" %% "json4s-native" % "3.6.7" % Test
 
+libraryDependencies += "org.mongodb.scala" %% "mongo-scala-driver" % "4.0.2"
+
 libraryDependencies += "org.xerial.snappy" % "snappy-java" % "1.1.7.3" % Provided
 
 libraryDependencies += "com.github.luben" % "zstd-jni" % "1.4.4-9" % Provided
 
 libraryDependencies += "de.bwaldvogel" % "mongo-java-server" % "1.28.0" % Provided
 
-libraryDependencies += "org.mongodb.scala" %% "mongo-scala-driver" % "4.0.2"
+libraryDependencies += "de.bwaldvogel" % "mongo-java-server-h2-backend" % "1.28.0" % Provided
 
 libraryDependencies += "com.github.pathikrit" %% "better-files" % "3.8.0"
 

src/main/scala/com/sfxcode/nosql/mongo/database/MongoConfig.scala

@@ -75,7 +75,40 @@ case class MongoConfig(
   }
 }
 
-object MongoConfig {
+trait ConfigHelper {
+  val conf: Config = ConfigFactory.load()
+
+  def stringConfig(configPath: String, key: String, default: String = ""): Option[String] =
+    if (conf.hasPath("%s.%s".format(configPath, key))) {
+      Some(conf.getString("%s.%s".format(configPath, key)))
+    }
+    else {
+      if (default.nonEmpty) {
+        Some(default)
+      }
+      else {
+        None
+      }
+    }
+
+  def intConfig(configPath: String, key: String, default: Int = 0): Int =
+    if (conf.hasPath("%s.%s".format(configPath, key))) {
+      conf.getInt("%s.%s".format(configPath, key))
+    }
+    else {
+      default
+    }
+
+  def booleanConfig(configPath: String, key: String, default: Boolean = false): Boolean =
+    if (conf.hasPath("%s.%s".format(configPath, key))) {
+      conf.getBoolean("%s.%s".format(configPath, key))
+    }
+    else {
+      default
+    }
+}
+
+object MongoConfig extends ConfigHelper {
   val DefaultHost                       = "127.0.0.1"
   val DefaultPort                       = 27017
   val DefaultAuthenticationDatabaseName = "admin"
@@ -94,20 +127,6 @@ object MongoConfig {
   val DefaultConfigPathPrefix = "mongo"
 
   def fromPath(configPath: String = DefaultConfigPathPrefix): MongoConfig = {
-    val conf: Config = ConfigFactory.load()
-
-    def stringConfig(key: String, default: String = ""): Option[String] =
-      if (conf.hasPath("%s.%s".format(configPath, key))) {
-        Some(conf.getString("%s.%s".format(configPath, key)))
-      }
-      else {
-        if (default.nonEmpty) {
-          Some(default)
-        }
-        else {
-          None
-        }
-      }
 
     def poolOptionsConfig(key: String, default: Int): Int =
       if (conf.hasPath("%s.pool.%s".format(configPath, key))) {
@@ -117,13 +136,7 @@ object MongoConfig {
         default
       }
 
-    val port: Int =
-      if (conf.hasPath("%s.port".format(configPath))) {
-        conf.getInt("%s.port".format(configPath))
-      }
-      else {
-        DefaultPort
-      }
+    val port: Int = intConfig(configPath, "port", DefaultPort)
 
     val compressors: List[String] =
       if (conf.hasPath("%s.compressors".format(configPath))) {
@@ -133,12 +146,12 @@ object MongoConfig {
         List()
       }
 
-    val host            = stringConfig("host", DefaultHost).get
-    val database        = stringConfig("database").get
-    val userName        = stringConfig("userName")
-    val password        = stringConfig("password")
-    val authDatabase    = stringConfig("authDatabase", DefaultAuthenticationDatabaseName).get
-    val applicationName = stringConfig("applicationName", DefaultApplicationName).get
+    val host            = stringConfig(configPath, "host", DefaultHost).get
+    val database        = stringConfig(configPath, "database").get
+    val userName        = stringConfig(configPath, "userName")
+    val password        = stringConfig(configPath, "password")
+    val authDatabase    = stringConfig(configPath, "authDatabase", DefaultAuthenticationDatabaseName).get
+    val applicationName = stringConfig(configPath, "applicationName", DefaultApplicationName).get
 
     val poolOptions = MongoPoolOptions(
       poolOptionsConfig("maxConnectionIdleTime", DefaultPoolMaxConnectionIdleTime),

src/main/scala/com/sfxcode/nosql/mongo/server/LocalServer.scala

@@ -1,15 +1,55 @@
 package com.sfxcode.nosql.mongo.server
 
+import better.files.File
+import com.sfxcode.nosql.mongo.server.ServerConfig.DefaultServerConfigPathPrefix
 import de.bwaldvogel.mongo.MongoServer
+import de.bwaldvogel.mongo.backend.h2.H2Backend
 import de.bwaldvogel.mongo.backend.memory.MemoryBackend
 
 case class LocalServer(serverConfig: ServerConfig = ServerConfig()) {
-  private val server = new MongoServer(new MemoryBackend())
+  private var h2Path = "undefined"
+
+  private val server: MongoServer = {
+    if (ServerBackend.H2 == serverConfig.backend) {
+      if (serverConfig.h2BackendConfig.isDefined && !serverConfig.h2BackendConfig.get.inMemory) {
+        if (serverConfig.h2BackendConfig.get.path.nonEmpty) {
+          h2Path = serverConfig.h2BackendConfig.get.path
+        }
+        else {
+          h2Path = File.temporaryFile().get().path.toString
+        }
+        createH2Server(h2Path)
+      }
+      else {
+        createH2InMemoryServer
+      }
+    }
+    else {
+      createInMemoryServer
+    }
+  }
 
   server.bind(serverConfig.host, serverConfig.port)
 
-  def name: String = serverConfig.name
+  def name: String = serverConfig.serverName
+
+  def h2FilePath: String = h2Path
 
   def shutdown(): Unit = server.shutdown()
 
+  private def createInMemoryServer: MongoServer =
+    new MongoServer(new MemoryBackend())
+
+  private def createH2InMemoryServer: MongoServer =
+    new MongoServer(H2Backend.inMemory())
+
+  private def createH2Server(path: String): MongoServer =
+    new MongoServer(new H2Backend(path))
+
+}
+
+object LocalServer {
+
+  def fromPath(configPath: String = DefaultServerConfigPathPrefix): LocalServer =
+    LocalServer(ServerConfig.fromPath(configPath))
 }

src/main/scala/com/sfxcode/nosql/mongo/server/ServerConfig.scala

@@ -1,10 +1,60 @@
 package com.sfxcode.nosql.mongo.server
 
-import ServerConfig._
+import com.sfxcode.nosql.mongo.database.ConfigHelper
+import com.sfxcode.nosql.mongo.server.ServerBackend.ServerBackend
 
-case class ServerConfig(name: String = "MongoLocal", host: String = DefaultHost, port: Int = DefaultPort)
+case class ServerConfig(
+    serverName: String = ServerConfig.DefaultServerName,
+    host: String = ServerConfig.DefaultHost,
+    port: Int = ServerConfig.DefaultPort,
+    backend: ServerBackend = ServerBackend.Memory,
+    h2BackendConfig: Option[H2BackendConfig] = None
+)
 
-object ServerConfig {
-  val DefaultHost = "localhost"
-  val DefaultPort = 28018
+case class H2BackendConfig(inMemory: Boolean = true, path: String = "")
+
+object ServerBackend extends Enumeration {
+  type ServerBackend = Value
+  val Memory, H2 = Value
+}
+
+object ServerConfig extends ConfigHelper {
+  val DefaultServerConfigPathPrefix = "local.mongo.server"
+
+  val DefaultServerName = "local-mongo-server"
+  val DefaultHost       = "localhost"
+  val DefaultPort       = 28018
+
+  def serverBackendFromString(backendName: String): ServerBackend.Value =
+    if (ServerBackend.H2.toString.toLowerCase.equals(backendName.toLowerCase)) {
+      ServerBackend.H2
+    }
+    else {
+      ServerBackend.Memory
+    }
+
+  def fromPath(configPath: String = DefaultServerConfigPathPrefix): ServerConfig = {
+
+    val name = stringConfig(configPath, "serverName", DefaultServerName).get
+    val host = stringConfig(configPath, "host", DefaultHost).get
+    val port = intConfig(configPath, "port", DefaultPort)
+
+    val backend = stringConfig(configPath, "backend").get
+
+    val serverBackend: ServerBackend = serverBackendFromString(backend)
+
+    val h2BackendConfig: Option[H2BackendConfig] = {
+      if (serverBackend == ServerBackend.H2 && conf.hasPath("%s.%s".format(configPath, "h2.inMemory"))) {
+        val inMemory = booleanConfig(configPath, "h2.inMemory")
+        val path     = stringConfig(configPath, "h2.path").get
+        Some(H2BackendConfig(inMemory, path))
+      }
+      else {
+        None
+      }
+    }
+
+    ServerConfig(name, host, port, serverBackend, h2BackendConfig)
+
+  }
 }

src/test/resources/application.conf

@@ -12,10 +12,21 @@ unit.test.mongo {
   compressors = ["snappy"]
 }
 
+unit.test.local.mongo.server {
+  host = "localhost"
+  port = 28028
+  serverName = "local-unit-test-server"
+  backend = "h2"
+  h2 {
+    inMemory = false
+    path = "/tmp/local-unit-test-server.mv"
+  }
+}
+
 unit.test.mongo.local {
   database = "simple-mongo-unit-test"
   host = "localhost"
-  port = 28018
+  port = 28028
   applicationName = "simple-mongo-config-test"
   pool {
     minSize = 5

src/test/scala/com/sfxcode/nosql/mongo/test/UniversityDatabase.scala

@@ -9,7 +9,8 @@ import org.bson.codecs.configuration.CodecRegistry
 import org.mongodb.scala.bson.codecs.Macros._
 
 object UniversityDatabase {
-  val LocalTestServer = LocalServer()
+  // create local test server (mongo-java-server)
+  val LocalTestServer = LocalServer.fromPath("unit.test.local.mongo.server")
 
   // create codecs for custom classes
   private val universityRegistry: CodecRegistry = fromProviders(classOf[Student], classOf[Score], classOf[Grade])