feat: Providing automatic system data backup via Dropbox

closes #838

Author: orange-buffalo

app/build.gradle.kts

@@ -12,6 +12,7 @@ buildscript {
 
 plugins {
     kotlin("jvm")
+    alias(libs.plugins.kotlin.serialization)
     kotlin("kapt")
     id("io.spring.dependency-management")
     alias(libs.plugins.kotlin.spring)
@@ -37,12 +38,20 @@ dependencies {
     implementation(libs.kotlinx.coroutines.core)
     implementation(libs.kotlinx.coroutines.reactive)
     implementation(libs.kotlinx.coroutines.reactor)
+    implementation(libs.kotlinx.serialization.json)
+    implementation(libs.kotlinx.dateTime)
 
     implementation(libs.jooq)
     implementation(libs.jjwt.api)
     implementation(libs.arrow.core)
     implementation(libs.springdocOpenapi.starterCommon)
 
+    implementation(libs.ktor.clientCore)
+    implementation(libs.ktor.clientCio)
+    implementation(libs.ktor.contentNegotiation)
+    implementation(libs.ktor.kotlinxJson)
+    implementation(libs.ktor.auth)
+
     kapt("org.springframework.boot:spring-boot-configuration-processor")
 
     runtimeOnly("org.flywaydb:flyway-core")

app/src/main/kotlin/io/orangebuffalo/simpleaccounting/services/integration/CoroutinesSupport.kt

@@ -6,7 +6,7 @@ import org.springframework.web.server.ServerWebExchange
 import reactor.util.context.Context
 import kotlin.coroutines.coroutineContext
 
-@Suppress("EXPERIMENTAL_API_USAGE")
+@OptIn(DelicateCoroutinesApi::class)
 private val dbContext = newFixedThreadPoolContext(20, "db-context")
 
 suspend fun <T> withDbContext(block: suspend CoroutineScope.() -> T): T = withContext(dbContext, block)

app/src/main/kotlin/io/orangebuffalo/simpleaccounting/services/integration/backups/BackupProperties.kt

@@ -0,0 +1,20 @@
+package io.orangebuffalo.simpleaccounting.services.integration.backups
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+import org.springframework.stereotype.Component
+
+@ConfigurationProperties("simpleaccounting.backup")
+@Component
+data class BackupProperties(
+    var enabled: Boolean = false,
+    var maxBackups: Int = 50,
+    var dropbox: DropboxBackupProperties = DropboxBackupProperties(),
+) {
+
+    data class DropboxBackupProperties(
+        var accessToken: String? = null,
+        var refreshToken: String? = null,
+        var clientId: String? = null,
+        var clientSecret: String? = null,
+    )
+}

app/src/main/kotlin/io/orangebuffalo/simpleaccounting/services/integration/backups/BackupProvider.kt

@@ -0,0 +1,14 @@
+package io.orangebuffalo.simpleaccounting.services.integration.backups
+
+import java.nio.file.Path
+
+/**
+ * Processes the backup files (typically, uploads to a remote storage).
+ */
+interface BackupProvider {
+
+    /**
+     * Accepts the backup file and processes it.
+     */
+    suspend fun acceptBackup(backupFile: Path)
+}

app/src/main/kotlin/io/orangebuffalo/simpleaccounting/services/integration/backups/BackupsConfig.kt

@@ -0,0 +1,27 @@
+package io.orangebuffalo.simpleaccounting.services.integration.backups
+
+import io.orangebuffalo.simpleaccounting.services.integration.backups.impl.DropboxBackupProvider
+import io.orangebuffalo.simpleaccounting.services.integration.backups.impl.NoOpBackupProvider
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration
+class BackupsConfig {
+
+    @ConditionalOnProperty("simpleaccounting.backup.dropbox.active", havingValue = "true")
+    @Configuration
+    class DropboxBackupConfig {
+        @Bean
+        fun dropboxBackupProvider(backupProperties: BackupProperties) = DropboxBackupProvider(backupProperties)
+    }
+
+    @ConditionalOnMissingBean(BackupProvider::class)
+    @Configuration
+    class NoOpBackupConfig {
+        @Bean
+        fun noOpBackupProvider() = NoOpBackupProvider()
+    }
+
+}

app/src/main/kotlin/io/orangebuffalo/simpleaccounting/services/integration/backups/SystemDataBackupService.kt

@@ -0,0 +1,61 @@
+package io.orangebuffalo.simpleaccounting.services.integration.backups
+
+import io.orangebuffalo.simpleaccounting.services.integration.withDbContext
+import kotlinx.coroutines.runBlocking
+import mu.KotlinLogging
+import org.springframework.jdbc.core.JdbcTemplate
+import org.springframework.scheduling.annotation.Scheduled
+import org.springframework.stereotype.Service
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import java.util.concurrent.TimeUnit
+
+private val logger = KotlinLogging.logger {}
+private val fileNameDateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd-HH-mm")
+
+/**
+ * Performs system data backup.
+ */
+@Service
+class SystemDataBackupService(
+    private val jdbcTemplate: JdbcTemplate,
+    private val backupProvider: BackupProvider,
+    private val backupProperties: BackupProperties,
+) {
+
+    @Scheduled(fixedDelayString = "\${simpleaccounting.backup.scheduling-delay-in-hours}", timeUnit = TimeUnit.HOURS)
+    fun executeBackup() = runBlocking {
+        if (!backupProperties.enabled) {
+            logger.info { "Backup is disabled" }
+            return@runBlocking
+        }
+
+        logger.info { "Starting system data backup" }
+
+        val backupFile = getBackupFile()
+
+        try {
+            withDbContext {
+                jdbcTemplate.execute("script drop to '${backupFile.toAbsolutePath()}' compression zip")
+            }
+            logger.debug { "Database saved to $backupFile" }
+
+            backupProvider.acceptBackup(backupFile)
+            logger.debug { "Backup file $backupFile accepted by backup provider" }
+        } finally {
+            Files.delete(backupFile)
+        }
+
+        logger.info { "System data backup completed" }
+    }
+
+    private fun getBackupFile(): Path {
+        val currentTime = LocalDateTime.now().format(fileNameDateFormatter)
+        val fileName = "simple-accounting-backup-$currentTime.zip"
+        val tempDir = Paths.get(System.getProperty("java.io.tmpdir"))
+        return tempDir.resolve(fileName)
+    }
+}

app/src/main/kotlin/io/orangebuffalo/simpleaccounting/services/integration/backups/impl/DropboxBackupProvider.kt

@@ -0,0 +1,45 @@
+package io.orangebuffalo.simpleaccounting.services.integration.backups.impl
+
+import io.orangebuffalo.simpleaccounting.services.integration.backups.BackupProperties
+import io.orangebuffalo.simpleaccounting.services.integration.backups.BackupProvider
+import io.orangebuffalo.simpleaccounting.services.integration.thirdparty.DropboxApiClient
+import io.orangebuffalo.simpleaccounting.services.integration.thirdparty.FileListFolderEntry
+import java.nio.file.Path
+import kotlin.io.path.name
+
+private const val BACKUP_FOLDER = "/backups"
+
+class DropboxBackupProvider(
+    private val backupProperties: BackupProperties
+) : BackupProvider {
+    override suspend fun acceptBackup(backupFile: Path) = withClient { client ->
+        client.uploadFile(backupFile, "$BACKUP_FOLDER/${backupFile.name}")
+        val existingBackups = client.listFolder(BACKUP_FOLDER)
+            .filterIsInstance<FileListFolderEntry>()
+            .sortedBy { it.clientModified }
+        if (existingBackups.size > backupProperties.maxBackups) {
+            val backupsToDelete = existingBackups
+                .subList(0, existingBackups.size - backupProperties.maxBackups)
+                .map { it.path }
+            client.deleteFiles(backupsToDelete)
+        }
+    }
+
+    private suspend fun withClient(block: suspend (client: DropboxApiClient) -> Unit) {
+        val accessToken = backupProperties.dropbox.accessToken
+        val refreshToken = backupProperties.dropbox.refreshToken
+        val clientId = backupProperties.dropbox.clientId
+        val clientSecret = backupProperties.dropbox.clientSecret
+        require(accessToken != null && refreshToken != null && clientId != null && clientSecret != null) {
+            "Dropbox tokens are not configured"
+        }
+        DropboxApiClient(
+            accessToken = accessToken,
+            refreshToken = refreshToken,
+            clientId = clientId,
+            clientSecret = clientSecret
+        ).use { client ->
+            block(client)
+        }
+    }
+}

app/src/main/kotlin/io/orangebuffalo/simpleaccounting/services/integration/backups/impl/NoOpBackupProvider.kt

@@ -0,0 +1,12 @@
+package io.orangebuffalo.simpleaccounting.services.integration.backups.impl
+
+import io.orangebuffalo.simpleaccounting.services.integration.backups.BackupProvider
+import mu.KotlinLogging
+
+private val logger = KotlinLogging.logger {}
+
+class NoOpBackupProvider : BackupProvider {
+    override suspend fun acceptBackup(backupFile: java.nio.file.Path) {
+        logger.info { "Backup file $backupFile is ignored by noop provider" }
+    }
+}