implement scheduled backup for the SQLite DB

Author: andreaTP

server/pom.xml

@@ -26,6 +26,10 @@
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-hibernate-orm-panache</artifactId>
     </dependency>
+    <dependency>
+      <groupId>io.quarkus</groupId>
+      <artifactId>quarkus-scheduler</artifactId>
+    </dependency>
     <dependency>
       <groupId>io.quarkiverse.jdbc</groupId>
       <artifactId>quarkus-jdbc-sqlite4j</artifactId>

server/power-server.db

@@ -1,43 +1,84 @@
 package net.laprun.sustainability.power.persistence;
 
-import java.sql.Connection;
-import java.sql.DriverManager;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
 import java.sql.SQLException;
-import java.sql.Statement;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
+import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.enterprise.event.Observes;
+import jakarta.inject.Inject;
+import jakarta.persistence.EntityManager;
 
 import org.eclipse.microprofile.config.inject.ConfigProperty;
+import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
+import org.hibernate.internal.SessionImpl;
+import org.jboss.logging.Logger;
 
-import io.quarkus.logging.Log;
 import io.quarkus.runtime.ShutdownEvent;
+import io.quarkus.scheduler.Scheduled;
 
+@ApplicationScoped
 public class SQLiteFilePersister {
     @ConfigProperty(name = "quarkus.datasource.jdbc.url")
     String jdbcUrl;
 
-    @ConfigProperty(name = "power-server.db.location")
-    String fileName;
+    private static final Logger LOGGER = Logger.getLogger(SQLiteFilePersister.class.getName());
 
-    //    public void onStartup(@Observes StartupEvent event) {
-    //        Log.info("Restoring data from " + fileName);
-    //        try (
-    //                Connection connection = DriverManager.getConnection(jdbcUrl);
-    //                Statement statement = connection.createStatement()) {
-    //            statement.executeUpdate("restore from " + fileName);
-    //        } catch (SQLException e) {
-    //            e.printStackTrace(System.err);
-    //        }
-    //    }
+    @Inject
+    EntityManager entityManager;
 
+    private final AtomicBoolean executing = new AtomicBoolean(false);
+
+    // Execute a backup every 10 seconds
+    @Scheduled(delay = 10, delayUnit = TimeUnit.SECONDS, every = "10s")
+    void scheduled() {
+        backup();
+    }
+
+    // Execute a backup during shutdown
     public void onShutdown(@Observes ShutdownEvent event) {
-        Log.info("Saving data to " + fileName);
-        try (
-                Connection connection = DriverManager.getConnection(jdbcUrl);
-                Statement statement = connection.createStatement()) {
-            statement.executeUpdate("backup to " + fileName);
-        } catch (SQLException e) {
-            e.printStackTrace(System.err);
+        backup();
+    }
+
+    void backup() {
+        if (executing.compareAndSet(false, true)) {
+            try {
+                int prefixLength = "jdbc:sqlite:".length();
+                int queryParamsIdx = jdbcUrl.indexOf('?');
+                int length = (queryParamsIdx != -1) ? queryParamsIdx : jdbcUrl.length();
+                String dbFile = jdbcUrl.substring(prefixLength, length);
+
+                var originalDbFilePath = Paths.get(dbFile);
+                LOGGER.info("Starting DB backup for file: " + dbFile);
+                var backupDbFilePath = originalDbFilePath.toAbsolutePath().getParent()
+                        .resolve(originalDbFilePath.getFileName() + "_backup");
+
+                JdbcConnectionAccess access = entityManager
+                        .unwrap(SessionImpl.class)
+                        .getJdbcConnectionAccess();
+                try (var conn = access.obtainConnection();
+                        var stmt = conn.createStatement()) {
+                    // Execute the backup
+                    stmt.executeUpdate("backup to " + backupDbFilePath);
+                    // Atomically substitute the DB file with its backup
+                    Files.move(backupDbFilePath, originalDbFilePath, StandardCopyOption.ATOMIC_MOVE,
+                            StandardCopyOption.REPLACE_EXISTING);
+                } catch (SQLException e) {
+                    throw new RuntimeException("Failed to backup the database", e);
+                } catch (IOException e) {
+                    throw new RuntimeException("Failed to create backup files or folders", e);
+                }
+                LOGGER.info("Backup of " + dbFile + " completed.");
+            } finally {
+                executing.set(false);
+            }
+        } else {
+            LOGGER.info("Backup in progress.");
         }
     }
+
 }

server/src/main/java/net/laprun/sustainability/power/persistence/SQLiteFilePersister.java

@@ -1,6 +1,7 @@
 quarkus.http.port=20432
 quarkus.datasource.jdbc.url=jdbc:sqlite:power-server.db
 quarkus.datasource.db-kind=sqlite
+quarkus.datasource.jdbc.min-size=1
 
-quarkus.hibernate-orm.database.generation=create
-power-server.db.location=${PWD}/power-server.sqlite
+# Only use this property once to create the initial database
+# quarkus.hibernate-orm.database.generation=create