Merge pull request #37 from scalableminds/debug-slow-seek

Update sbt, clean up code style, type annotations

.gitignore

@@ -15,6 +15,7 @@ lib_managed/
 src_managed/
 project/boot/
 project/plugins/project/
+.bsp
 
 # Scala-IDE specific
 .scala_dependencies

build.sbt

@@ -1,13 +1,12 @@
-import sbtbuildinfo.BuildInfoKeys.{buildInfoKeys, buildInfoOptions, buildInfoPackage}
-import sbtbuildinfo.{BuildInfoKey, BuildInfoOption}
+import sbt._
 
 name := "fossildb"
 
 def getVersionFromGit: String = {
-  def run(cmd: String): String = (new java.io.BufferedReader(new java.io.InputStreamReader(java.lang.Runtime.getRuntime().exec(cmd).getInputStream()))).readLine()
+  def run(cmd: String): String = new java.io.BufferedReader(new java.io.InputStreamReader(java.lang.Runtime.getRuntime.exec(cmd).getInputStream)).readLine()
   def getBranch = run("git rev-parse --abbrev-ref HEAD")
 
-  if (sys.env.get("CI").isDefined && getBranch == "master") {
+  if (sys.env.contains("CI") && getBranch == "master") {
     val oldVersion = run("git describe --tags --abbrev=0").split('.').toList.map(_.toInt)
     (oldVersion.init :+ (oldVersion.last + 1)).mkString(".")
   } else {
@@ -17,7 +16,7 @@ def getVersionFromGit: String = {
 
 version := getVersionFromGit
 
-scalaVersion := "2.12.4"
+scalaVersion := "2.12.15"
 
 libraryDependencies ++= Seq(
   "ch.qos.logback" % "logback-classic" % "1.2.3",
@@ -30,31 +29,31 @@ libraryDependencies ++= Seq(
   "com.github.scopt" %% "scopt" % "3.7.0"
 )
 
-managedSourceDirectories in Compile += target.value / "protobuf-generated"
+Compile / managedSourceDirectories += target.value / "protobuf-generated"
 
-PB.targets in Compile := Seq(
+Compile / PB.targets := Seq(
   scalapb.gen() -> (target.value / "protobuf-generated")
 )
 
-mainClass in Compile := Some("com.scalableminds.fossildb.FossilDB")
+Compile / mainClass := Some("com.scalableminds.fossildb.FossilDB")
 
-assemblyMergeStrategy in assembly := {
+assembly / assemblyMergeStrategy := {
   case x if x.endsWith("io.netty.versions.properties") => MergeStrategy.first
   case x =>
-    val oldStrategy = (assemblyMergeStrategy in assembly).value
+    val oldStrategy = (assembly / assemblyMergeStrategy).value
     oldStrategy(x)
 }
 
-assemblyJarName in assembly := "fossildb.jar"
+assembly / assemblyJarName := "fossildb.jar"
 
 
 lazy val buildInfoSettings = Seq(
   buildInfoKeys := Seq[BuildInfoKey](version,
     "commitHash" -> new java.lang.Object() {
-      override def toString(): String = {
+      override def toString: String = {
         try {
-          val extracted = new java.io.InputStreamReader(java.lang.Runtime.getRuntime().exec("git rev-parse HEAD").getInputStream())
-          (new java.io.BufferedReader(extracted)).readLine()
+          val extracted = new java.io.InputStreamReader(java.lang.Runtime.getRuntime.exec("git rev-parse HEAD").getInputStream)
+          new java.io.BufferedReader(extracted).readLine()
         } catch {
           case t: Throwable => "get git hash failed"
         }
@@ -69,4 +68,4 @@ lazy val root = (project in file(".")).
   enablePlugins(BuildInfoPlugin).
   settings(
     buildInfoSettings
-  )
+  )

project/build.properties

@@ -1,2 +1 @@
-sbt.version = 0.13.15
-
+sbt.version = 1.6.2

project/buildinfo.sbt

@@ -1 +1 @@
-addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.7.0")
+addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.9.0")

src/main/scala/com/scalableminds/fossildb/FossilDB.scala

@@ -8,19 +8,19 @@ import fossildb.BuildInfo
 
 import scala.concurrent.ExecutionContext
 
-object ConfigDefaults {val port = 7155; val dataDir = "data"; val backupDir = "backup"; val columnFamilies = List(); val rocksOptionsFile = None}
+object ConfigDefaults {val port: Int = 7155; val dataDir: String = "data"; val backupDir: String = "backup"; val columnFamilies: List[String] = List(); val rocksOptionsFile: Option[String] = None}
 case class Config(port: Int = ConfigDefaults.port, dataDir: String = ConfigDefaults.dataDir,
                   backupDir: String = ConfigDefaults.backupDir, columnFamilies: List[String] = ConfigDefaults.columnFamilies,
                   rocksOptionsFile: Option[String] = ConfigDefaults.rocksOptionsFile)
 
 object FossilDB extends LazyLogging {
-  def main(args: Array[String]) = {
+  def main(args: Array[String]): Unit = {
 
     if (args.contains("--version"))
       println(BuildInfo.version)
     else {
       parseArguments(args) match {
-        case Some(config) => {
+        case Some(config) =>
           logger.info("Starting FossilDB")
           logger.info("BuildInfo: (" + BuildInfo + ")")
           logger.info("Config: " + config)
@@ -31,14 +31,12 @@ object FossilDB extends LazyLogging {
 
           server.start()
           server.blockUntilShutdown()
-
-      }
         case None => ()
       }
     }
   }
 
-  def parseArguments(args: Array[String]) = {
+  private def parseArguments(args: Array[String]) = {
     val parser = new scopt.OptionParser[Config]("fossildb") {
 
       opt[Int]('p', "port").valueName("<num>").action( (x, c) =>

src/main/scala/com/scalableminds/fossildb/FossilDBGrpcImpl.scala

@@ -1,14 +1,11 @@
-/*
- * Copyright (C) 2011-2017 scalable minds UG (haftungsbeschränkt) & Co. KG. <http://scm.io>
- */
 package com.scalableminds.fossildb
 
 import java.io.{PrintWriter, StringWriter}
 
 import com.google.protobuf.ByteString
 import com.scalableminds.fossildb.db.StoreManager
 import com.scalableminds.fossildb.proto.fossildbapi._
-import com.trueaccord.scalapb.GeneratedMessage
+import scalapb.GeneratedMessage
 import com.typesafe.scalalogging.LazyLogging
 
 import scala.concurrent.Future
@@ -17,102 +14,100 @@ class FossilDBGrpcImpl(storeManager: StoreManager)
   extends FossilDBGrpc.FossilDB
     with LazyLogging {
 
-  override def health(req: HealthRequest) = withExceptionHandler(req) {
-    HealthReply(true)
-  } { errorMsg => HealthReply(false, errorMsg) }
+  override def health(req: HealthRequest): Future[HealthReply] = withExceptionHandler(req) {
+    HealthReply(success = true)
+  } { errorMsg => HealthReply(success = false, errorMsg) }
 
-  override def get(req: GetRequest) = withExceptionHandler(req) {
+  override def get(req: GetRequest): Future[GetReply] = withExceptionHandler(req) {
     val store = storeManager.getStore(req.collection)
     val versionedKeyValuePairOpt = store.get(req.key, req.version)
     versionedKeyValuePairOpt match {
-      case Some(pair) => GetReply(true, None, ByteString.copyFrom(pair.value), pair.version)
-      case None => {
-        if (!(req.mayBeEmpty.getOrElse(false))) throw new NoSuchElementException
-        GetReply(false, Some("No such element"), ByteString.EMPTY, 0)
-      }
+      case Some(pair) => GetReply(success = true, None, ByteString.copyFrom(pair.value), pair.version)
+      case None =>
+        if (!req.mayBeEmpty.getOrElse(false)) throw new NoSuchElementException
+        GetReply(success = false, Some("No such element"), ByteString.EMPTY, 0)
     }
-  } { errorMsg => GetReply(false, errorMsg, ByteString.EMPTY, 0) }
+  } { errorMsg => GetReply(success = false, errorMsg, ByteString.EMPTY, 0) }
 
-  override def put(req: PutRequest) = withExceptionHandler(req) {
+  override def put(req: PutRequest): Future[PutReply] = withExceptionHandler(req) {
     val store = storeManager.getStore(req.collection)
     val version = req.version.getOrElse(store.get(req.key, None).map(_.version + 1).getOrElse(0L))
     require(version >= 0, "Version numbers must be non-negative")
     store.put(req.key, version, req.value.toByteArray)
-    PutReply(true)
-  } { errorMsg => PutReply(false, errorMsg) }
+    PutReply(success = true)
+  } { errorMsg => PutReply(success = false, errorMsg) }
 
-  override def delete(req: DeleteRequest) = withExceptionHandler(req) {
+  override def delete(req: DeleteRequest): Future[DeleteReply] = withExceptionHandler(req) {
     val store = storeManager.getStore(req.collection)
     store.delete(req.key, req.version)
-    DeleteReply(true)
-  } { errorMsg => DeleteReply(false, errorMsg) }
+    DeleteReply(success = true)
+  } { errorMsg => DeleteReply(success = false, errorMsg) }
 
-  override def getMultipleVersions(req: GetMultipleVersionsRequest) = withExceptionHandler(req) {
+  override def getMultipleVersions(req: GetMultipleVersionsRequest): Future[GetMultipleVersionsReply] = withExceptionHandler(req) {
     val store = storeManager.getStore(req.collection)
     val (values, versions) = store.getMultipleVersions(req.key, req.oldestVersion, req.newestVersion)
-    GetMultipleVersionsReply(true, None, values.map(ByteString.copyFrom(_)), versions)
-  } { errorMsg => GetMultipleVersionsReply(false, errorMsg) }
+    GetMultipleVersionsReply(success = true, None, values.map(ByteString.copyFrom), versions)
+  } { errorMsg => GetMultipleVersionsReply(success = false, errorMsg) }
 
-  override def getMultipleKeys(req: GetMultipleKeysRequest) = withExceptionHandler(req) {
+  override def getMultipleKeys(req: GetMultipleKeysRequest): Future[GetMultipleKeysReply] = withExceptionHandler(req) {
     val store = storeManager.getStore(req.collection)
     val (keys, values, versions) = store.getMultipleKeys(req.key, req.prefix, req.version, req.limit)
-    GetMultipleKeysReply(true, None, keys, values.map(ByteString.copyFrom(_)), versions)
-  } { errorMsg => GetMultipleKeysReply(false, errorMsg) }
+    GetMultipleKeysReply(success = true, None, keys, values.map(ByteString.copyFrom), versions)
+  } { errorMsg => GetMultipleKeysReply(success = false, errorMsg) }
 
-  override def deleteMultipleVersions(req: DeleteMultipleVersionsRequest) = withExceptionHandler(req) {
+  override def deleteMultipleVersions(req: DeleteMultipleVersionsRequest): Future[DeleteMultipleVersionsReply] = withExceptionHandler(req) {
     val store = storeManager.getStore(req.collection)
     store.deleteMultipleVersions(req.key, req.oldestVersion, req.newestVersion)
-    DeleteMultipleVersionsReply(true)
-  } { errorMsg => DeleteMultipleVersionsReply(false, errorMsg) }
+    DeleteMultipleVersionsReply(success = true)
+  } { errorMsg => DeleteMultipleVersionsReply(success = false, errorMsg) }
 
-  override def listKeys(req: ListKeysRequest) = withExceptionHandler(req) {
+  override def listKeys(req: ListKeysRequest): Future[ListKeysReply] = withExceptionHandler(req) {
     val store = storeManager.getStore(req.collection)
     val keys = store.listKeys(req.limit, req.startAfterKey)
-    ListKeysReply(true, None, keys)
-  } { errorMsg => ListKeysReply(false, errorMsg) }
+    ListKeysReply(success = true, None, keys)
+  } { errorMsg => ListKeysReply(success = false, errorMsg) }
 
-  override def listVersions(req: ListVersionsRequest) = withExceptionHandler(req) {
+  override def listVersions(req: ListVersionsRequest): Future[ListVersionsReply] = withExceptionHandler(req) {
     val store = storeManager.getStore(req.collection)
     val versions = store.listVersions(req.key, req.limit, req.offset)
-    ListVersionsReply(true, None, versions)
-  } { errorMsg => ListVersionsReply(false, errorMsg) }
+    ListVersionsReply(success = true, None, versions)
+  } { errorMsg => ListVersionsReply(success = false, errorMsg) }
 
-  override def backup(req: BackupRequest) = withExceptionHandler(req) {
+  override def backup(req: BackupRequest): Future[BackupReply] = withExceptionHandler(req) {
     val backupInfoOpt = storeManager.backup
     backupInfoOpt match {
-      case Some(backupInfo) => BackupReply(true, None, backupInfo.id, backupInfo.timestamp, backupInfo.size)
+      case Some(backupInfo) => BackupReply(success = true, None, backupInfo.id, backupInfo.timestamp, backupInfo.size)
       case _ => throw new Exception("Backup did not return valid BackupInfo")
     }
-  } { errorMsg => BackupReply(false, errorMsg, 0, 0, 0) }
+  } { errorMsg => BackupReply(success = false, errorMsg, 0, 0, 0) }
 
-  override def restoreFromBackup(req: RestoreFromBackupRequest) = withExceptionHandler(req) {
-    storeManager.restoreFromBackup
-    RestoreFromBackupReply(true)
-  } { errorMsg => RestoreFromBackupReply(false, errorMsg) }
+  override def restoreFromBackup(req: RestoreFromBackupRequest): Future[RestoreFromBackupReply] = withExceptionHandler(req) {
+    storeManager.restoreFromBackup()
+    RestoreFromBackupReply(success = true)
+  } { errorMsg => RestoreFromBackupReply(success = false, errorMsg) }
 
-  override def compactAllData(req: CompactAllDataRequest) = withExceptionHandler(req) {
+  override def compactAllData(req: CompactAllDataRequest): Future[CompactAllDataReply] = withExceptionHandler(req) {
     storeManager.compactAllData()
-    CompactAllDataReply(true)
-  } { errorMsg => CompactAllDataReply(false, errorMsg) }
+    CompactAllDataReply(success = true)
+  } { errorMsg => CompactAllDataReply(success = false, errorMsg) }
 
-  override def exportDB(req: ExportDBRequest) = withExceptionHandler(req) {
+  override def exportDB(req: ExportDBRequest): Future[ExportDBReply] = withExceptionHandler(req) {
     storeManager.exportDB(req.newDataDir, req.optionsFile)
-    ExportDBReply(true)
-  } { errorMsg => ExportDBReply(false, errorMsg) }
+    ExportDBReply(success = true)
+  } { errorMsg => ExportDBReply(success = false, errorMsg) }
 
   private def withExceptionHandler[T, R <: GeneratedMessage](request: R)(tryBlock: => T)(onErrorBlock: Option[String] => T): Future[T] = {
     try {
       logger.debug("received " + requestToString(request))
       Future.successful(tryBlock)
     } catch {
-      case e: Exception => {
+      case e: Exception =>
         log(e, request)
         Future.successful(onErrorBlock(Some(e.toString)))
-      }
     }
   }
 
-  private def log[R <: GeneratedMessage](e: Exception, request: R) = {
+  private def log[R <: GeneratedMessage](e: Exception, request: R): Unit = {
     logger.warn(getStackTraceAsString(e) + "\nrequest that caused this error: " + requestToString(request) + "\n")
   }
 

src/main/scala/com/scalableminds/fossildb/FossilDBServer.scala

@@ -1,6 +1,3 @@
-/*
- * Copyright (C) 2011-2017 scalable minds UG (haftungsbeschränkt) & Co. KG. <http://scm.io>
- */
 package com.scalableminds.fossildb
 
 import com.scalableminds.fossildb.db.StoreManager
@@ -22,7 +19,7 @@ class FossilDBServer(storeManager: StoreManager, port: Int, executionContext: Ex
     healthStatusManager = new HealthStatusManager()
     server = NettyServerBuilder.forPort(port).maxMessageSize(Int.MaxValue)
       .addService(FossilDBGrpc.bindService(new FossilDBGrpcImpl(storeManager), executionContext))
-      .addService(healthStatusManager.getHealthService())
+      .addService(healthStatusManager.getHealthService)
       .build.start
     healthStatusManager.setStatus("", HealthCheckResponse.ServingStatus.SERVING)
     logger.info("Server started, listening on " + port)
@@ -48,6 +45,3 @@ class FossilDBServer(storeManager: StoreManager, port: Int, executionContext: Ex
   }
 
 }
-
-
-