convert souls database to sqlite

Author: makeevrserg

docker-compose.yml

@@ -12,16 +12,16 @@ services:
       EULA: true
       ONLINE_MODE: false
       # Forge --------------------
-      TYPE: NEOFORGE
-      VERSION: "1.21.1"
-      NEOFORGE_VERSION: "21.1.209"
+#      TYPE: NEOFORGE
+#      VERSION: "1.21.1"
+#      NEOFORGE_VERSION: "21.1.209"
       # Paper --------------------
-      #TYPE: PAPER
-      #VERSION: 1.21.8
+      TYPE: PAPER
+      VERSION: 1.21.8
       # Custom -------------------
     #      CUSTOM_SERVER: https://api.papermc.io/v2/projects/paper/versions/1.21.1/builds/121/downloads/paper-1.21.1-121.jar
     volumes:
-      - ./build/neoforge:/data # Forge
-#      - ./build/bukkit:/data # Bukkit/Paper/Spigot
+#      - ./build/neoforge:/data # Forge
+      - ./build/bukkit:/data # Bukkit/Paper/Spigot
 #      - ./build/velocity:/data # Velocity
 #      - ./build/fabric:/data # Fabric

gradle.properties

@@ -13,7 +13,7 @@ makeevrserg.java.ktarget=21
 # Project
 makeevrserg.project.name=SoulKeeper
 makeevrserg.project.group=ru.astrainteractive.soulkeeper
-makeevrserg.project.version.string=1.2.8
+makeevrserg.project.version.string=1.2.9
 makeevrserg.project.description=Keep your items after death
 makeevrserg.project.developers=makeevrserg|Makeev Roman|[email protected]
 makeevrserg.project.url=https://github.com/Astra-Interactive/SoulKeeper

instances/bukkit/src/main/resources/plugin.yml

@@ -11,9 +11,9 @@ softdepend: [ packetevents ]
 depend: [ ]
 loadbefore: [ Towny ]
 libraries:
-  - "org.xerial:sqlite-jdbc:3.46.1.0"
+  - "org.xerial:sqlite-jdbc:3.51.1.0"
   - "mysql:mysql-connector-java:8.0.33"
-  - "com.h2database:h2:2.3.232"
+  - "com.h2database:h2:2.4.240"
 commands:
   souls:
   skreload:

modules/dao/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/SoulsDaoModule.kt

@@ -2,10 +2,12 @@ package ru.astrainteractive.soulkeeper.module.souls.di
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.retry
 import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.launch
 import org.jetbrains.exposed.sql.Database
@@ -14,12 +16,15 @@ import org.jetbrains.exposed.sql.transactions.TransactionManager
 import org.jetbrains.exposed.sql.transactions.transaction
 import ru.astrainteractive.astralibs.lifecycle.Lifecycle
 import ru.astrainteractive.klibs.mikro.core.dispatchers.KotlinDispatchers
+import ru.astrainteractive.klibs.mikro.core.logging.JUtiltLogger
+import ru.astrainteractive.klibs.mikro.core.logging.Logger
 import ru.astrainteractive.klibs.mikro.exposed.model.DatabaseConfiguration
 import ru.astrainteractive.klibs.mikro.exposed.util.connect
 import ru.astrainteractive.soulkeeper.module.souls.dao.SoulsDao
 import ru.astrainteractive.soulkeeper.module.souls.dao.SoulsDaoImpl
 import ru.astrainteractive.soulkeeper.module.souls.database.table.SoulItemsTable
 import ru.astrainteractive.soulkeeper.module.souls.database.table.SoulTable
+import ru.astrainteractive.soulkeeper.module.souls.migration.H2ToSqliteMigration
 import java.io.File
 
 interface SoulsDaoModule {
@@ -33,20 +38,27 @@ interface SoulsDaoModule {
         dataFolder: File,
         ioScope: CoroutineScope,
         dispatchers: KotlinDispatchers
-    ) : SoulsDaoModule {
+    ) : SoulsDaoModule, Logger by JUtiltLogger("SoulsDaoModule") {
         override val databaseFlow: Flow<Database> = flow {
+            H2ToSqliteMigration(dataFolder).migrate()
             if (!dataFolder.exists()) dataFolder.mkdirs()
-            val database = dataFolder.resolve("souls_v2").absolutePath
-                .let(DatabaseConfiguration::H2)
+            val database = dataFolder.resolve("souls_v3")
+                .absolutePath
+                .let(DatabaseConfiguration::SQLite)
                 .connect()
             TransactionManager.manager.defaultIsolationLevel = java.sql.Connection.TRANSACTION_SERIALIZABLE
             transaction(database) {
                 SchemaUtils.create(SoulTable)
-                SchemaUtils.createMissingTablesAndColumns(SoulTable)
-                SchemaUtils.createMissingTablesAndColumns(SoulItemsTable)
+                SchemaUtils.create(SoulItemsTable)
             }
             emit(database)
-        }.shareIn(ioScope, SharingStarted.Eagerly, 1)
+        }
+            .retry { throwable ->
+                error(throwable) { "Could not connect to database" }
+                delay(5000L)
+                true
+            }
+            .shareIn(ioScope, SharingStarted.Eagerly, 1)
 
         override val soulsDao: SoulsDao = SoulsDaoImpl(
             databaseFlow = databaseFlow,

modules/dao/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/migration/H2ToSqliteMigration.kt

@@ -0,0 +1,69 @@
+package ru.astrainteractive.soulkeeper.module.souls.migration
+
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.flowOf
+import org.jetbrains.exposed.sql.SchemaUtils
+import org.jetbrains.exposed.sql.transactions.TransactionManager
+import org.jetbrains.exposed.sql.transactions.transaction
+import ru.astrainteractive.klibs.mikro.core.logging.JUtiltLogger
+import ru.astrainteractive.klibs.mikro.core.logging.Logger
+import ru.astrainteractive.klibs.mikro.exposed.model.DatabaseConfiguration
+import ru.astrainteractive.klibs.mikro.exposed.util.connect
+import ru.astrainteractive.soulkeeper.module.souls.dao.SoulsDaoImpl
+import ru.astrainteractive.soulkeeper.module.souls.database.model.DefaultSoul
+import ru.astrainteractive.soulkeeper.module.souls.database.table.SoulItemsTable
+import ru.astrainteractive.soulkeeper.module.souls.database.table.SoulTable
+import java.io.File
+
+class H2ToSqliteMigration(
+    val dataFolder: File
+) : Logger by JUtiltLogger("H2ToSqliteMigration") {
+
+    suspend fun migrate() = coroutineScope {
+        if (!dataFolder.resolve("souls_v2.mv.db").exists()) return@coroutineScope
+        info { "#migrate started migration of database..." }
+        val h2Database = dataFolder.resolve("souls_v2")
+            .absolutePath
+            .let(DatabaseConfiguration::H2)
+            .connect()
+        val sqliteDatabase = dataFolder.resolve("souls_v3")
+            .absolutePath
+            .let(DatabaseConfiguration::SQLite)
+            .connect()
+        transaction(sqliteDatabase) {
+            SchemaUtils.create(SoulTable)
+            SchemaUtils.create(SoulItemsTable)
+        }
+
+        val sqliteSoulsDao = SoulsDaoImpl(flowOf(sqliteDatabase))
+        val hwSoulsDao = SoulsDaoImpl(flowOf(h2Database))
+        hwSoulsDao.getSouls()
+            .onFailure {
+                error(it) { "Could not convert souls from H2 to SQLite" }
+                return@coroutineScope
+            }
+            .getOrNull()
+            .orEmpty()
+            .map { dbSoul -> async { hwSoulsDao.toItemDatabaseSoul(dbSoul) } }
+            .awaitAll()
+            .mapNotNull { soul -> soul.getOrNull() }
+            .map { soul ->
+                DefaultSoul(
+                    ownerUUID = soul.ownerUUID,
+                    ownerLastName = soul.ownerLastName,
+                    createdAt = soul.createdAt,
+                    isFree = soul.isFree,
+                    location = soul.location,
+                    exp = soul.exp,
+                    items = soul.items,
+                )
+            }
+            .forEach { soul -> sqliteSoulsDao.insertSoul(soul) }
+        info { "#migrate Migration has been completed. Closing databases..." }
+        TransactionManager.closeAndUnregister(h2Database)
+        TransactionManager.closeAndUnregister(sqliteDatabase)
+        dataFolder.resolve("souls_v2.mv.db").delete()
+    }
+}