Seperate flyway from sqlDatabases

Author: mlachkar

modules/data/src/main/scala/scaladex/data/Main.scala

@@ -54,14 +54,15 @@ object Main extends LazyLogging {
 
     val dataPaths = DataPaths.from(config.filesystem)
     val localStorage = FilesystemStorage(config.filesystem)
+    val datasource = DoobieUtils.getHikariDataSource(config.database)
 
     def usingDatabase(f: SqlDatabase => Future[Unit]): Unit = {
       implicit val cs = IO.contextShift(system.dispatcher)
       val transactor: Resource[IO, HikariTransactor[IO]] =
-        DoobieUtils.transactor(config.database)
+        DoobieUtils.transactor(datasource)
       transactor
         .use { xa =>
-          val database = new SqlDatabase(config.database, xa)
+          val database = new SqlDatabase(datasource, xa)
           IO.fromFuture(IO(f(database)))
         }
         .unsafeRunSync()

modules/data/src/main/scala/scaladex/data/init/Init.scala

@@ -1,5 +1,4 @@
 package scaladex.data.init
-
 import scala.concurrent.ExecutionContext
 import scala.concurrent.Future
 

modules/infra/src/main/scala/scaladex/infra/SqlDatabase.scala

@@ -8,6 +8,7 @@ import scala.concurrent.Future
 
 import cats.effect.IO
 import com.typesafe.scalalogging.LazyLogging
+import com.zaxxer.hikari.HikariDataSource
 import doobie.implicits._
 import scaladex.core.model.Artifact
 import scaladex.core.model.ArtifactDependency
@@ -19,7 +20,6 @@ import scaladex.core.model.ProjectDependency
 import scaladex.core.model.ReleaseDependency
 import scaladex.core.model.UserState
 import scaladex.core.service.SchedulerDatabase
-import scaladex.infra.config.PostgreSQLConfig
 import scaladex.infra.sql.ArtifactDependencyTable
 import scaladex.infra.sql.ArtifactTable
 import scaladex.infra.sql.DoobieUtils
@@ -31,9 +31,8 @@ import scaladex.infra.sql.ReleaseDependenciesTable
 import scaladex.infra.sql.ReleaseTable
 import scaladex.infra.sql.UserSessionsTable
 
-class SqlDatabase(conf: PostgreSQLConfig, xa: doobie.Transactor[IO]) extends SchedulerDatabase with LazyLogging {
-
-  private val flyway = DoobieUtils.flyway(conf)
+class SqlDatabase(datasource: HikariDataSource, xa: doobie.Transactor[IO]) extends SchedulerDatabase with LazyLogging {
+  private val flyway = DoobieUtils.flyway(datasource)
   def migrate: IO[Unit] = IO(flyway.migrate())
   def dropTables: IO[Unit] = IO(flyway.clean())
 

modules/infra/src/main/scala/scaladex/infra/sql/DoobieUtils.scala

@@ -39,24 +39,25 @@ object DoobieUtils {
 
   private implicit val cs: ContextShift[IO] =
     IO.contextShift(ExecutionContext.global)
+
   def flyway(conf: PostgreSQLConfig): Flyway = {
     val datasource = getHikariDataSource(conf)
+    flyway(datasource)
+  }
+  def flyway(datasource: HikariDataSource): Flyway =
     Flyway
       .configure()
       .dataSource(datasource)
       .locations("migrations", "scaladex/infra/migrations")
       .load()
-  }
 
-  def transactor(conf: PostgreSQLConfig): Resource[IO, HikariTransactor[IO]] = {
-    val datasource = getHikariDataSource(conf)
+  def transactor(datasource: HikariDataSource): Resource[IO, HikariTransactor[IO]] =
     for {
       ce <- ExecutionContexts.fixedThreadPool[IO](32) // our connect EC
       be <- Blocker[IO] // our blocking EC
     } yield Transactor.fromDataSource[IO](datasource, ce, be)
-  }
 
-  private def getHikariDataSource(conf: PostgreSQLConfig): HikariDataSource = {
+  def getHikariDataSource(conf: PostgreSQLConfig): HikariDataSource = {
     val config: HikariConfig = new HikariConfig()
     config.setDriverClassName(conf.driver)
     config.setJdbcUrl(conf.url)

modules/infra/src/test/scala/scaladex/infra/BaseDatabaseSuite.scala

@@ -7,13 +7,14 @@ import scala.concurrent.duration.Duration
 
 import cats.effect.ContextShift
 import cats.effect.IO
+import com.zaxxer.hikari.HikariDataSource
 import doobie.scalatest.IOChecker
 import doobie.util.transactor.Transactor
 import org.scalatest.Assertions
 import org.scalatest.BeforeAndAfterEach
 import org.scalatest.Suite
-import scaladex.infra.SqlDatabase
 import scaladex.infra.config.PostgreSQLConfig
+import scaladex.infra.sql.DoobieUtils
 
 trait BaseDatabaseSuite extends IOChecker with BeforeAndAfterEach {
   self: Assertions with Suite =>
@@ -24,7 +25,6 @@ trait BaseDatabaseSuite extends IOChecker with BeforeAndAfterEach {
   private val config: PostgreSQLConfig = PostgreSQLConfig
     .load()
     .get
-    .asInstanceOf[PostgreSQLConfig]
 
   override val transactor: Transactor.Aux[IO, Unit] =
     Transactor
@@ -35,7 +35,7 @@ trait BaseDatabaseSuite extends IOChecker with BeforeAndAfterEach {
         config.pass.decode
       )
 
-  lazy val database = new SqlDatabase(config, transactor)
+  lazy val database = new SqlDatabase(BaseDatabaseSuite.datasource, transactor)
 
   override def beforeEach(): Unit =
     Await.result(cleanTables(), Duration.Inf)
@@ -48,3 +48,10 @@ trait BaseDatabaseSuite extends IOChecker with BeforeAndAfterEach {
     reset.unsafeToFuture()
   }
 }
+object BaseDatabaseSuite {
+  private val config: PostgreSQLConfig = PostgreSQLConfig
+    .load()
+    .get
+
+  val datasource: HikariDataSource = DoobieUtils.getHikariDataSource(config)
+}

modules/server/src/it/scala/scaladex/RelevanceTest.scala

@@ -14,11 +14,9 @@ import cats.effect.ContextShift
 import scala.concurrent.ExecutionContext
 import scaladex.core.model.Project
 import scaladex.core.model.search.SearchParams
-import scaladex.infra.ElasticsearchEngine
+import scaladex.infra.{ElasticsearchEngine, FilesystemStorage, FlywayMigration, SqlDatabase}
 import scaladex.infra.sql.DoobieUtils
 import scaladex.server.service.SearchSynchronizer
-import scaladex.infra.SqlDatabase
-import scaladex.infra.FilesystemStorage
 import scaladex.core.model.search.PageParams
 import scaladex.server.service.ProjectDependenciesUpdater
 
@@ -31,18 +29,20 @@ class RelevanceTest extends TestKit(ActorSystem("SbtActorTest")) with AsyncFunSu
 
   override def beforeAll(): Unit = {
     implicit val cs: ContextShift[IO] = IO.contextShift(ExecutionContext.global)
-    val transactor = DoobieUtils.transactor(config.database)
+    val datasource = DoobieUtils.getHikariDataSource(config.database)
+    val transactor = DoobieUtils.transactor(datasource)
+    val flyway = FlywayMigration(datasource)
     transactor
       .use { xa =>
-        val database = new SqlDatabase(config.database, xa)
+        val database = new SqlDatabase(xa)
         val filesystem = FilesystemStorage(config.filesystem)
 
         val searchSync = new SearchSynchronizer(database, searchEngine)
         val projectDependenciesUpdater = new ProjectDependenciesUpdater(database)
 
         IO.fromFuture(IO {
           for {
-            _ <- Init.run(database, filesystem)
+            _ <- Init.run(database, filesystem, flyway)
             _ <- searchEngine.init(true)
             _ <- projectDependenciesUpdater.updateAll()
             _ <- searchSync.syncAll()

modules/server/src/main/scala/scaladex/server/Server.scala

@@ -53,18 +53,19 @@ object Server extends LazyLogging {
       // because of the sbtResolver mode
       val searchEngine = ElasticsearchEngine.open(config.elasticsearch)
 
-      val resources =
+      val resources = {
+        val datasource = DoobieUtils.getHikariDataSource(config.database)
         for {
-          webPool <- DoobieUtils.transactor(config.database)
-          schedulerPool <- DoobieUtils.transactor(config.database)
+          webPool <- DoobieUtils.transactor(datasource)
+          schedulerPool <- DoobieUtils.transactor(datasource)
           publishPool <- ExecutionContexts.fixedThreadPool[IO](8)
-        } yield (webPool, schedulerPool, publishPool)
-
+        } yield (webPool, schedulerPool, publishPool, datasource)
+      }
       resources
         .use {
-          case (webPool, schedulerPool, publishPool) =>
-            val webDatabase = new SqlDatabase(config.database, webPool)
-            val schedulerDatabase = new SqlDatabase(config.database, schedulerPool)
+          case (webPool, schedulerPool, publishPool, datasourceForFlyway) =>
+            val webDatabase = new SqlDatabase(datasourceForFlyway, webPool)
+            val schedulerDatabase = new SqlDatabase(datasourceForFlyway, schedulerPool)
             val githubService = config.github.token.map(new GithubClient(_))
             val paths = DataPaths.from(config.filesystem)
             val filesystem = FilesystemStorage(config.filesystem)