Step 6: restore AvailabilityAnalyzer state from MariaDB on restart

AttributeAvailability.restore(state, since) sets state and
consecutiveFailures silently (no domain events emitted). For DOWN
state, since becomes downtimeStart so a subsequent recovery correctly
closes the existing tabDowntime Interval row.

AvailabilityAnalyzer.seed(attributeId, state, since) creates (or
finds) the per-attribute state machine and calls restore on it.

MariaDbSink.loadCurrentStates() queries tabCurrent State and returns
a map of CurrentState records (attributeId, state, since).

Main calls loadCurrentStates() + seed() after the engine is built but
before engine.start(), so no live events race with the restore.
Recovery failure is non-fatal: the server starts fresh with a warning.

Covered by 4 new tests in AvailabilityAnalyzerTest (seed DOWN/STALE/UP
paths and continued failure accumulation after restore).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Ingvord

src/main/java/wpn/hdri/ss/Main.java

@@ -80,10 +80,20 @@ public static void main(String[] args) throws Exception {
             logger.warn("Failed attributes will not be monitored: {}", factory.getFailedAttributes());
         }
 
-        // Register attribute names for human-readable DB records
         if (mariaDbSink != null) {
             final MariaDbSink sink = mariaDbSink;
+
+            // Register attribute names for human-readable DB records
             engine.getAttributes().forEach(attr -> sink.registerAttribute(attr.id, attr.fullName));
+
+            // Restore persisted availability state before the engine starts collecting
+            try {
+                sink.loadCurrentStates().forEach((id, cs) ->
+                        analyzer.seed(id, cs.state(), cs.since()));
+                logger.info("Availability state restored from MariaDB");
+            } catch (Exception e) {
+                logger.warn("Could not restore state from MariaDB, starting fresh: {}", e.getMessage());
+            }
         }
 
         // --- HTTP server ---

src/main/java/wpn/hdri/ss/engine2/AttributeAvailability.java

@@ -47,6 +47,17 @@ AvailabilityState state() {
         return state;
     }
 
+    /**
+     * Restores persisted state on startup without emitting any domain events.
+     * For DOWN state, {@code since} becomes the downtimeStart so a subsequent
+     * recovery correctly closes the existing interval.
+     */
+    void restore(AvailabilityState restoredState, Instant since) {
+        this.state = restoredState;
+        this.consecutiveFailures = restoredState == AvailabilityState.UP ? 0 : downAfter;
+        this.downtimeStart = restoredState == AvailabilityState.DOWN ? since : null;
+    }
+
     private void handleSuccess(Instant ts) {
         consecutiveFailures = 0;
         if (state == AvailabilityState.UP) return;

src/main/java/wpn/hdri/ss/engine2/AvailabilityAnalyzer.java

@@ -1,9 +1,11 @@
 package wpn.hdri.ss.engine2;
 
+import wpn.hdri.ss.event.AvailabilityState;
 import wpn.hdri.ss.event.DomainEvent;
 import wpn.hdri.ss.event.EventSink;
 import wpn.hdri.ss.event.TechnicalEvent;
 
+import java.time.Instant;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
@@ -35,6 +37,16 @@ public void onEvent(TechnicalEvent event) {
                 .process(event);
     }
 
+    /**
+     * Seeds a single attribute's state machine from persisted storage.
+     * Must be called before {@code engine.start()} so no live events race with the restore.
+     */
+    public void seed(int attributeId, AvailabilityState state, Instant since) {
+        states.computeIfAbsent(attributeId,
+                        id -> new AttributeAvailability(id, staleAfter, downAfter, domainSink))
+                .restore(state, since);
+    }
+
     @Override
     public String name() {
         return "AvailabilityAnalyzer";

src/main/java/wpn/hdri/ss/writer/MariaDbSink.java

@@ -5,8 +5,11 @@
 import wpn.hdri.ss.configuration.MariaDbConfiguration;
 import wpn.hdri.ss.event.*;
 
+import static wpn.hdri.ss.event.AvailabilityState.*;
+
 import java.sql.*;
 import java.time.Instant;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
@@ -63,6 +66,29 @@ public MariaDbSink(MariaDbConfiguration config) {
         this.config = config;
     }
 
+    /**
+     * Reads all rows from {@code tabCurrent State} and returns them keyed by attribute_id.
+     * Used at startup to restore {@link wpn.hdri.ss.engine2.AvailabilityAnalyzer} state.
+     */
+    public Map<Integer, CurrentState> loadCurrentStates() throws SQLException {
+        Map<Integer, CurrentState> result = new HashMap<>();
+        String sql = "SELECT attribute_id, state, since FROM `tabCurrent State`";
+        try (PreparedStatement ps = connection().prepareStatement(sql);
+             ResultSet rs = ps.executeQuery()) {
+            while (rs.next()) {
+                int id = rs.getInt("attribute_id");
+                AvailabilityState state = AvailabilityState.valueOf(rs.getString("state"));
+                Instant since = rs.getTimestamp("since").toInstant();
+                result.put(id, new CurrentState(id, state, since));
+            }
+        }
+        logger.info("Loaded {} persisted attribute state(s) from tabCurrent State", result.size());
+        return result;
+    }
+
+    /** Snapshot of a persisted attribute availability state. */
+    public record CurrentState(int attributeId, AvailabilityState state, Instant since) {}
+
     /** Called after engine start so attribute names appear in DB records. */
     public void registerAttribute(int id, String fullName) {
         attributeNames.put(id, fullName);

src/test/java/wpn/hdri/ss/engine2/AvailabilityAnalyzerTest.java

@@ -145,6 +145,46 @@ public void multipleAttributesTrackedIndependently() {
         assertEquals(3, aEvents);
     }
 
+    // --- recovery tests ---
+
+    @Test
+    public void seedDownStateClosesDowntimeOnRecovery() {
+        Instant downtimeStart = Instant.now().minusSeconds(300);
+        analyzer.seed(ATTR_ID, AvailabilityState.DOWN, downtimeStart);
+
+        succeed();
+
+        assertEquals(2, emitted.size());
+        assertTransition(emitted.get(0), AvailabilityState.DOWN, AvailabilityState.UP);
+        DowntimeClosed closed = (DowntimeClosed) emitted.get(1);
+        assertEquals(downtimeStart, closed.openedAt());
+    }
+
+    @Test
+    public void seedStaleStateTransitionsToUpOnRecovery() {
+        analyzer.seed(ATTR_ID, AvailabilityState.STALE, Instant.now().minusSeconds(60));
+
+        succeed();
+
+        assertEquals(1, emitted.size());
+        assertTransition(emitted.get(0), AvailabilityState.STALE, AvailabilityState.UP);
+    }
+
+    @Test
+    public void seedUpStateEmitsNothingOnSuccess() {
+        analyzer.seed(ATTR_ID, AvailabilityState.UP, Instant.now());
+        succeed();
+        assertTrue(emitted.isEmpty());
+    }
+
+    @Test
+    public void seedDownStateContinuesAccumulatingFailures() {
+        analyzer.seed(ATTR_ID, AvailabilityState.DOWN, Instant.now().minusSeconds(60));
+        // more failures while DOWN should not emit anything new
+        fail(3);
+        assertTrue(emitted.isEmpty());
+    }
+
     // --- assertion helpers ---
 
     private static void assertTransition(DomainEvent event, AvailabilityState from, AvailabilityState to) {