Add Hot-Reload Google Drive sync without restart (#13)

* Hot-reload Google Drive sync without restart

* Use ResourceDatabasePopulator for schema re-migration

The manual split-by-semicolon approach skipped SQL statements preceded
by comment headers because the entire chunk started with '--' after
trim(). Spring's ResourceDatabasePopulator handles comment stripping
correctly and is the idiomatic choice for executing SQL scripts.

* Split DB reload into shutdown/reconnect for Windows file-lock safety

downloadAndReload() now shuts down H2 and evicts pool connections
before downloading the Drive file, ensuring the .mv.db file lock is
released before the move/replace. Reconnect always runs in a finally
block so the app stays functional even if the download fails.

* Apply Drive sync review fixes

- Show blocking overlay on main window during DB reload to prevent
  user interaction while H2 is shut down (pre-reload/post-reload listeners)
- Add Objects.requireNonNull for dbShutdown/dbReconnect callbacks;
  catch and log exceptions from both so a failed reconnect returns
  false instead of propagating an unhandled RuntimeException
- Defer markLocalDbDirty() to afterCommit via TransactionSynchronization
  so rolled-back transactions don't falsely flag the DB as dirty
- Adjust runMigrations() log message to note continueOnError=true;
  escalate full failure to logger.error with stack trace
- checkSyncStatus() now returns LOCAL_NEWER based on file timestamps
  (not just the in-memory dirty flag), catching post-restart drift
- markLocalDbDirty() sets the flag unconditionally (regardless of
  sign-in state) so edits made while signed out are tracked
- refreshAllPanels() logs full exception (not just getMessage())

---------

Co-authored-by: geokoko <geokoko@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: geokoko

src/main/java/com/studysync/config/DatabaseReloadService.java

@@ -0,0 +1,112 @@
+package com.studysync.config;
+
+import com.zaxxer.hikari.HikariDataSource;
+import com.zaxxer.hikari.HikariPoolMXBean;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
+import org.springframework.stereotype.Service;
+
+import javax.sql.DataSource;
+
+/**
+ * Service that shuts down and reopens the H2 database in-place, allowing the
+ * underlying file to be replaced at runtime (e.g. after a Google Drive download).
+ *
+ * <p>The reload cycle is:
+ * <ol>
+ *   <li>{@code SHUTDOWN} — H2 closes its engine (caches flushed, file lock released).</li>
+ *   <li>Soft-evict all pooled connections so HikariCP discards them.</li>
+ *   <li>A test query forces HikariCP to create a fresh connection, which makes
+ *       H2 open the (now-replaced) database file.</li>
+ *   <li>Schema migrations ({@code schema.sql}) are re-applied to ensure the
+ *       downloaded database has all required columns/indexes.</li>
+ * </ol>
+ */
+@Service
+public class DatabaseReloadService {
+
+    private static final Logger logger = LoggerFactory.getLogger(DatabaseReloadService.class);
+
+    private final DataSource dataSource;
+    private final JdbcTemplate jdbcTemplate;
+
+    public DatabaseReloadService(DataSource dataSource, JdbcTemplate jdbcTemplate) {
+        this.dataSource = dataSource;
+        this.jdbcTemplate = jdbcTemplate;
+    }
+
+    /**
+     * Shuts down the H2 engine and evicts all pooled connections, releasing the
+     * file lock so the {@code .mv.db} file can be safely replaced on any OS.
+     * Must be followed by a call to {@link #reconnect()} once the file is ready.
+     */
+    public void shutdown() {
+        logger.info("Shutting down H2 database (releasing file lock)…");
+
+        // 1. Shut down H2 — all pooled connections become invalid
+        try {
+            jdbcTemplate.execute("SHUTDOWN");
+        } catch (Exception e) {
+            // The executing connection is killed by H2's SHUTDOWN — expected
+            logger.debug("H2 SHUTDOWN completed (exception expected): {}", e.getMessage());
+        }
+
+        // 2. Tell HikariCP to discard every idle/returned connection
+        if (dataSource instanceof HikariDataSource hikari) {
+            HikariPoolMXBean pool = hikari.getHikariPoolMXBean();
+            if (pool != null) {
+                pool.softEvictConnections();
+            }
+        }
+    }
+
+    /**
+     * Reconnects to the H2 database file (which may have been replaced since
+     * {@link #shutdown()}) and re-applies schema migrations.
+     */
+    public void reconnect() {
+        logger.info("Reconnecting to H2 database…");
+
+        // Force a fresh connection — H2 opens the (possibly replaced) file
+        try {
+            jdbcTemplate.queryForObject("SELECT 1", Integer.class);
+        } catch (Exception e) {
+            logger.error("Failed to reconnect after reload: {}", e.getMessage());
+            throw new RuntimeException("Database reload failed — application may need a restart", e);
+        }
+
+        // Run idempotent schema.sql to apply any missing migrations
+        runMigrations();
+
+        logger.info("Database reconnected and ready");
+    }
+
+    /**
+     * Convenience method: shuts down H2, then immediately reconnects.
+     * Use when the file has already been replaced before this call.
+     */
+    public void reloadDatabase() {
+        shutdown();
+        reconnect();
+    }
+
+    /**
+     * Re-applies {@code schema.sql} (CREATE IF NOT EXISTS / ALTER ADD IF NOT EXISTS)
+     * so that a downloaded database from an older schema version gets upgraded.
+     */
+    private void runMigrations() {
+        try {
+            ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
+            populator.addScript(new ClassPathResource("schema.sql"));
+            populator.setContinueOnError(true); // individual failures are non-fatal
+            populator.setSeparator(";");
+            populator.execute(dataSource);
+            logger.info("Schema migrations re-applied after database reload (continueOnError=true; individual statement failures were silently ignored)");
+        } catch (Exception e) {
+            logger.error("Failed to re-apply schema.sql after reload — the database may be missing columns/tables", e);
+        }
+    }
+}

src/main/java/com/studysync/domain/service/ProjectService.java

@@ -4,9 +4,12 @@
 import com.studysync.domain.entity.ProjectSession;
 import com.studysync.domain.valueobject.ProjectStatus;
 import com.studysync.domain.service.ProjectSessionEnd;
+import com.studysync.integration.drive.GoogleDriveService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -23,8 +26,24 @@
 @Transactional
 public class ProjectService {
 
+    private final GoogleDriveService googleDriveService;
+
     @Autowired
-    public ProjectService() {
+    public ProjectService(GoogleDriveService googleDriveService) {
+        this.googleDriveService = googleDriveService;
+    }
+
+    private void markDirty() {
+        if (TransactionSynchronizationManager.isSynchronizationActive()) {
+            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+                @Override
+                public void afterCommit() {
+                    googleDriveService.markLocalDbDirty();
+                }
+            });
+        } else {
+            googleDriveService.markLocalDbDirty();
+        }
     }
 
     @Transactional(readOnly = true)
@@ -50,20 +69,23 @@ public void addProject(Project project) {
             throw new IllegalArgumentException("Project title cannot be empty");
         }
         project.save();
+        markDirty();
     }
 
     public void updateProject(Project project) {
         if (project == null) {
             throw new IllegalArgumentException("Project cannot be null");
         }
         project.save();
+        markDirty();
     }
 
     public void deleteProject(String projectId) {
         // Delete all associated sessions first
         ProjectSession.deleteByProjectId(projectId);
         // Then delete the project
         Project.deleteById(projectId);
+        markDirty();
     }
 
     @Transactional(readOnly = true)
@@ -92,6 +114,7 @@ public ProjectSession startProjectSession(String projectId) {
         ProjectSession session = new ProjectSession(projectId);
         session.setStartTime(LocalDateTime.now());
         session.save();  // Model handles its own persistence
+        markDirty();
         return session;
     }
 
@@ -120,6 +143,7 @@ public void endProjectSession(ProjectSession session, ProjectSessionEnd endDetai
         project.addWorkedMinutes(existingSession.getDurationMinutes());
         project.incrementSessionCount();
         project.save();
+        markDirty();
     }
 
     public void deleteProjectSession(String sessionId) {
@@ -135,6 +159,7 @@ public void deleteProjectSession(String sessionId) {
 
         // Delete the session
         ProjectSession.deleteById(sessionId);
+        markDirty();
     }
 
     @Transactional(readOnly = true)

src/main/java/com/studysync/domain/service/StudyService.java

@@ -11,6 +11,8 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -39,6 +41,19 @@ public StudyService(GoogleDriveService googleDriveService) {
         this.googleDriveService = googleDriveService;
     }
 
+    private void markDirty() {
+        if (TransactionSynchronizationManager.isSynchronizationActive()) {
+            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+                @Override
+                public void afterCommit() {
+                    googleDriveService.markLocalDbDirty();
+                }
+            });
+        } else {
+            googleDriveService.markLocalDbDirty();
+        }
+    }
+
     @Transactional(readOnly = true)
     public List<StudySession> getStudySessions() {
         return StudySession.findAll();
@@ -111,6 +126,7 @@ public void addStudyGoal(String description, LocalDate date, String taskId) {
         }
         StudyGoal goal = new StudyGoal(null, date, description, false, null, 0, false, 0, taskId);
         goal.save();
+        markDirty();
     }
 
     public void updateStudyGoalAchievement(String goalId, boolean achieved, String reasonIfNot) {
@@ -120,6 +136,7 @@ public void updateStudyGoalAchievement(String goalId, boolean achieved, String r
             goal.setAchieved(achieved);
             goal.setReasonIfNotAchieved(reasonIfNot);
             goal.save();
+            markDirty();
         }
     }
 
@@ -129,7 +146,7 @@ public boolean deleteStudyGoal(String goalId) {
         }
         boolean deleted = StudyGoal.deleteById(goalId);
         if (deleted) {
-            // Deleted
+            markDirty();
         } else {
             logger.warn("Requested deletion for study goal '{}' but it did not exist", goalId);
         }
@@ -140,6 +157,7 @@ public StudySession startStudySession() {
         StudySession session = new StudySession();
         session.startSession();
         session.save();  // Model handles its own persistence
+        markDirty();
         return session;
     }
 
@@ -153,10 +171,12 @@ public void endStudySession(StudySession session, StudySessionEnd endDetails) {
 
         // Save to database
         session.save();
+        markDirty();
     }
 
     public void addDailyReflection(DailyReflection reflection) {
         reflection.save();
+        markDirty();
     }
 
     @Transactional(readOnly = true)
@@ -177,7 +197,7 @@ public List<DailyReflection> getRecentDailyReflections(int days) {
     public void deleteDailyReflection(LocalDate date) {
         boolean deleted = DailyReflection.deleteByDate(date);
         if (deleted) {
-            // Deleted
+            markDirty();
         }
     }
 
@@ -200,7 +220,7 @@ public int calculateDailyProgress() {
     public void deleteStudySession(String sessionId) {
         boolean deleted = StudySession.deleteById(sessionId);
         if (deleted) {
-            // Deleted
+            markDirty();
         }
     }
 

src/main/java/com/studysync/domain/service/TaskService.java

@@ -4,11 +4,14 @@
 import com.studysync.domain.entity.Task;
 import com.studysync.domain.valueobject.TaskPriority;
 import com.studysync.domain.valueobject.TaskStatus;
+import com.studysync.integration.drive.GoogleDriveService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 import org.springframework.validation.annotation.Validated;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotNull;
@@ -31,10 +34,25 @@ public class TaskService {
     private static final Logger logger = LoggerFactory.getLogger(TaskService.class);
 
     private final CategoryService categoryService;
+    private final GoogleDriveService googleDriveService;
 
     @Autowired
-    public TaskService(CategoryService categoryService) {
+    public TaskService(CategoryService categoryService, GoogleDriveService googleDriveService) {
         this.categoryService = categoryService;
+        this.googleDriveService = googleDriveService;
+    }
+
+    private void markDirty() {
+        if (TransactionSynchronizationManager.isSynchronizationActive()) {
+            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+                @Override
+                public void afterCommit() {
+                    googleDriveService.markLocalDbDirty();
+                }
+            });
+        } else {
+            googleDriveService.markLocalDbDirty();
+        }
     }
 
     @Transactional(readOnly = true)
@@ -66,7 +84,7 @@ public Task addTask(@Valid @NotNull Task task) {
 
         logger.info("Successfully added task '{}' with priority {} and status {}", 
                    savedTask.getTitle(), savedTask.getPriority().stars(), savedTask.getStatus());
-        
+        markDirty();
         return savedTask;
     }
 
@@ -85,6 +103,7 @@ public void removeTask(@NotNull Task task) {
         }
 
         logger.info("Removed task: {}", task.getTitle());
+        markDirty();
     }
 
     @Transactional
@@ -95,6 +114,7 @@ public Task updateTask(@NotNull Task task, @NotNull TaskUpdate update) {
 
         Task savedTask = finalTask.save();
         logger.info("Updated task: {}", savedTask.getTitle());
+        markDirty();
         return savedTask;
     }
 
@@ -110,6 +130,7 @@ public void updateTaskStatus(@NotNull Task task, @NotNull TaskStatus newStatus)
         }
 
         logger.info("Updated task status for '{}' to {}", task.getTitle(), newStatus);
+        markDirty();
     }
 
     @Transactional(readOnly = true)
@@ -168,6 +189,7 @@ public int markDelayedTasks() {
 
         if (updatedCount > 0) {
             logger.info("Marked {} tasks as DELAYED", updatedCount);
+            markDirty();
         }
 
         return updatedCount;