DbUpgrader fixed

Don't generate PID file

Author: jendakol

.gitignore

@@ -16,4 +16,5 @@ dist
 /.settings
 node_modules
 front/package-lock.json
-*.log
+*.log
+filecache*

app/AppModule.scala

@@ -1,3 +1,4 @@
+import java.io.IOException
 import java.util.concurrent.Executors
 
 import cats.effect.Effect
@@ -6,6 +7,7 @@ import com.google.inject.TypeLiteral
 import com.typesafe.scalalogging.StrictLogging
 import io.sentry.Sentry
 import lib.App._
+import lib.AppException.MultipleFailuresException
 import lib._
 import lib.db.{Dao, DbScheme, DbUpgrader}
 import lib.server.CloudConnector
@@ -26,6 +28,7 @@ import utils.AllowedWsApiOrigins
 import scala.collection.JavaConverters._
 import scala.concurrent.ExecutionContext
 import scala.concurrent.duration._
+import scala.util.control.NonFatal
 
 class AppModule(environment: Environment, configuration: Configuration)
     extends ScalaModule
@@ -54,12 +57,13 @@ class AppModule(environment: Environment, configuration: Configuration)
 
   DB.autoCommit { implicit session =>
     DbScheme.create
-    DbUpgrader.upgrade
   }
 
   override def configure(): Unit = {
     bindConfig(config.root(), "")(binder())
 
+    val rootMonitor = Monitor.noOp() // TODO
+
     implicit val scheduler: Scheduler = Scheduler(
       executor = Executors.newScheduledThreadPool(4),
       ec = ExecutionContext.fromExecutorService(Executors.newCachedThreadPool())
@@ -70,15 +74,27 @@ class AppModule(environment: Environment, configuration: Configuration)
 
     val blockingScheduler = Scheduler.io()
 
-    val rootMonitor = Monitor.noOp() // TODO
+    val dao = new Dao(blockingScheduler)
+
+    // upgrade DB
+    DB.autoCommit { implicit session =>
+      val upgrader = new DbUpgrader(dao)
+      upgrader.upgrade.value.runSyncUnsafe(30.seconds) match {
+        case Right(_) => // ok
+        case Left(err @ MultipleFailuresException(causes)) =>
+          logger.error(s"Multiple failures while upgrading the DB:\n${causes.mkString("\n")}")
+          throw err
+        case Left(err) =>
+          throw err
+      }
+    }
 
     bind[AllowedWsApiOrigins].toInstance(AllowedWsApiOrigins(config.getStringList("allowedWsApiOrigins").asScala))
 
     val deviceId = DeviceId(config.getString("deviceId"))
     bind[DeviceId].toInstance(deviceId)
 
     val cloudConnector = CloudConnector.fromConfig(config.getConfig("cloudConnector"), blockingScheduler)
-    val dao = new Dao(blockingScheduler)
     val settings = new Settings(dao)
     val stateManager = new StateManager(deviceId, cloudConnector, dao, settings)
 
@@ -118,9 +134,20 @@ class AppModule(environment: Environment, configuration: Configuration)
 
     // startup:
 
-    stateManager.appInit().value.toIO.unsafeRunSync() match {
-      case Right(_) => settings.initializing(false)
-      case Left(err) => throw err
+    try {
+      stateManager.appInit().value.runSyncUnsafe(5.minutes) match {
+        case Right(_) => settings.initializing(false)
+        case Left(err) => throw err
+      }
+    } catch {
+      case e: IOException if e.getMessage.startsWith("Failed to connect") =>
+        settings.session(None).value.runSyncUnsafe(2.seconds)
+        logger.info("Could not initialize app because server is unavailable", e)
+        settings.initializing(false)
+
+      case NonFatal(e) =>
+        logger.error("Could not initialize app", e)
+        throw e
     }
   }
 

app/lib/db/DbScheme.scala

@@ -1,6 +1,6 @@
 package lib.db
 
-import lib.App
+import lib.{App, AppVersion}
 import scalikejdbc._
 
 object DbScheme {
@@ -43,9 +43,11 @@ object DbScheme {
          |
        """.stripMargin.executeUpdate().apply()
 
-    sql"""
-         |insert ignore into settings values ('db_version', ${currentVersionStr});
+    if (App.version > AppVersion(0, 1, 3)) {
+      sql"""
+           |insert ignore into settings values ('db_version', ${currentVersionStr});
        """.stripMargin.executeUpdate().apply()
+    }
   }
 
   def truncateAll(implicit session: DBSession): Unit = {

app/lib/db/DbUpgrader.scala

@@ -1,41 +1,60 @@
 package lib.db
 
+import cats.data.EitherT
 import com.typesafe.scalalogging.StrictLogging
-import lib.AppVersion
+import lib.App._
+import lib.AppException.DbException
+import lib.db.DbUpgrader._
+import lib.{App, AppException, AppVersion}
+import monix.eval.Task
+import monix.execution.Scheduler
 import scalikejdbc._
 
 import scala.collection.immutable.TreeMap
 
-object DbUpgrader extends StrictLogging {
+class DbUpgrader(dao: Dao)(implicit sch: Scheduler) extends StrictLogging {
+
+  def upgrade(implicit session: DBSession): Result[Unit] = {
+    dao
+      .getSetting("db_version")
+      .map(_.flatMap(AppVersion(_).toOption).getOrElse {
+        logger.debug("Didn't found DB version, fallback to 0.1.3")
+        AppVersion(0, 1, 3) // last version without this
+      })
+      .flatMap { currentVersion =>
+        logger.debug(s"Current DB version: $currentVersion")
+
+        val upgrades = VersionsChanges.filterKeys(_ > currentVersion)
+
+        upgrades
+          .map {
+            case (targetVersion, query) =>
+              val versionStr = targetVersion.toString
+              App.leaveBreadcrumb("Upgrading DB", Map("version" -> versionStr))
+
+              logger.debug(s"Upgrading DB to version $versionStr")
+
+              EitherT {
+                Task(query.apply())
+                  .map(_ => Right(()))
+                  .onErrorHandle { e =>
+                    Left(DbException(s"Error while upgrading the DB scheme to version $targetVersion", e): AppException)
+                  }
+              }.flatMap { _ =>
+                dao
+                  .setSetting("db_version", versionStr)
+                  .map(_ => logger.info(s"DB upgraded to version $versionStr"))
+              }
+          }
+          .toList
+          .sequentially
+          .map(_ => ())
+      }
+  }
+}
+
+object DbUpgrader {
   private final val VersionsChanges = TreeMap[AppVersion, SQLUpdate](
     AppVersion(0, 1, 4) -> sql""" alter table settings add constraint prim_key PRIMARY KEY (key)""".update()
   )
-
-  def upgrade(implicit session: DBSession): Unit = {
-    val currentVersion: AppVersion = {
-      sql""" select value from settings where key='db_version' """
-        .single()
-        .map(_.string("value"))
-        .single()
-        .apply
-        .flatMap(AppVersion(_).toOption)
-        .getOrElse {
-          logger.warn("Didn't found DB version, fallback to 0.1.3")
-          AppVersion(0, 1, 3) // last version without this
-        }
-    }
-
-    logger.debug(s"Current DB version: $currentVersion")
-
-    val upgrades = VersionsChanges.filterKeys(_ > currentVersion)
-
-    upgrades.foreach {
-      case (version, query) =>
-        logger.debug(s"Upgrading DB to version $version")
-        query.apply()
-        val versionStr = version.toString
-        sql""" update settings set value=${versionStr} where key='db_version' """.update().apply()
-        logger.debug(s"DB upraded to version $version")
-    }
-  }
 }

conf/reference.conf

@@ -35,6 +35,10 @@ play.filters {
   }
 }
 
+play.server {
+  pidfile.path = "/dev/null"
+}
+
 play.http.secret.key = "%APPLICATION_SECRET%"
 
 play.i18n.langs = ["cs"]