Light, fluffy, and always free - The AWS Local Emulator alternative
fix(storage): load each backend once and close WAL writers on shutdown (#3469)
Niels Kootstra1b83ef323ee5
diff --git a/src/main/java/io/github/hectorvent/floci/core/storage/StorageFactory.java b/src/main/java/io/github/hectorvent/floci/core/storage/StorageFactory.javaindex fb7ca5405b..a8750030b3 100644--- a/src/main/java/io/github/hectorvent/floci/core/storage/StorageFactory.java+++ b/src/main/java/io/github/hectorvent/floci/core/storage/StorageFactory.java@@ -11,9 +11,12 @@ import org.jboss.logging.Logger;import java.nio.file.Path;import java.util.ArrayList;+import java.util.Collections;import java.util.HashMap;+import java.util.IdentityHashMap;import java.util.List;import java.util.Map;+import java.util.Set;/*** Factory that creates {@link AccountAwareStorageBackend} instances based on configuration.@@ -34,6 +37,10 @@ public class StorageFactory {private final Map<Path, StorageBackend<?, ?>> backendsByPath = new HashMap<>();private final List<HybridStorage<?, ?>> hybridBackends = new ArrayList<>();private final List<WalStorage<?, ?>> walBackends = new ArrayList<>();+ // Backends whose initial load has completed. create() loads each backend exactly once and+ // loadAll() only picks up backends that were never loaded, so neither path replays a store+ // that is already live or opens a second WAL writer on top of the first.+ private final Set<StorageBackend<?, ?>> loadedBackends = Collections.newSetFromMap(new IdentityHashMap<>());@InjectInstance<RequestContext> requestContextInstance;@@ -93,20 +100,30 @@ public class StorageFactory {default -> throw new IllegalArgumentException("Unknown storage mode: " + mode);};- inner.load();-AccountAwareStorageBackend<V> backend = new AccountAwareStorageBackend<>(inner, requestContextInstance, config.defaultAccountId());+ // create() owns the initial load. Most services are lazily instantiated and only reach+ // this point after the lifecycle's loadAll() has already run, so a backend that is not+ // loaded here would serve an empty store and (for WAL) never open its writer (#71).+ loadOnce(backend);allBackends.add(backend);backendsByPath.put(filePath, backend);return backend;}- /** Load all storage backends from disk. */+ /** Load every managed backend that has not been loaded yet. Safe to call repeatedly. */public synchronized void loadAll() {for (StorageBackend<?, ?> backend : allBackends) {- backend.load();+ loadOnce(backend);+ }+ }++ private void loadOnce(StorageBackend<?, ?> backend) {+ if (loadedBackends.contains(backend)) {+ return;}+ backend.load();+ loadedBackends.add(backend);}/** Flush all storage backends to disk. */@@ -124,15 +141,19 @@ public class StorageFactory {flushAll();}- /** Shutdown all managed backends (stop schedulers, close connections). */+ /**+ * Shutdown all managed backends (stop schedulers, close connections). The final flush runs+ * first: a WAL flush compacts and reopens the writer, so flushing after shutdown would leave+ * every WAL backend with an open writer that nothing closes.+ */public synchronized void shutdownAll() {+ flushAll();for (HybridStorage<?, ?> hybrid : hybridBackends) {hybrid.shutdown();}for (WalStorage<?, ?> wal : walBackends) {wal.shutdown();}- flushAll();}private String resolveMode(String serviceName) {diff --git a/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryLifecycleTest.java b/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryLifecycleTest.javanew file mode 100644index 0000000000..59afd7364a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/storage/StorageFactoryLifecycleTest.java@@ -0,0 +1,128 @@+package io.github.hectorvent.floci.core.storage;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.ServiceConfigAccess;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;++import java.io.IOException;+import java.nio.file.Files;+import java.nio.file.Path;+import java.util.Map;+import java.util.Optional;++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++/**+ * Lifecycle contract of {@link StorageFactory}: {@code create()} owns the initial load of each+ * backend, {@code loadAll()} never reloads a live backend, and {@code shutdownAll()} performs the+ * final flush and then leaves no open WAL writer behind.+ */+class StorageFactoryLifecycleTest {++ private static final TypeReference<Map<String, String>> TYPE = new TypeReference<>() {};++ @TempDir+ Path tempDir;++ @Test+ void loadAllDoesNotReplayABackendThatCreateAlreadyLoaded() {+ StorageFactory factory = newFactory("hybrid");+ AccountAwareStorageBackend<String> backend = factory.create("svc", "svc.json", TYPE);+ backend.put("seed", "v1");+ factory.flushAll();+ backend.put("unflushed", "v2");++ // Boot calls loadAll() once; a second call must be just as harmless. A reload of the+ // hybrid store would clear it and drop the write that has not been flushed yet.+ factory.loadAll();+ factory.loadAll();++ assertEquals(Optional.of("v1"), backend.get("seed"));+ assertEquals(Optional.of("v2"), backend.get("unflushed"));+ factory.shutdownAll();+ }++ @Test+ void createLoadsPersistedStateForBackendsRegisteredAfterLoadAll() {+ StorageFactory first = newFactory("wal");+ first.create("svc", "svc.json", TYPE).put("persisted", "v1");+ first.shutdownAll();++ // Lazily instantiated services register their backend after the lifecycle's loadAll().+ StorageFactory second = newFactory("wal");+ second.loadAll();+ AccountAwareStorageBackend<String> late = second.create("svc", "svc.json", TYPE);+ assertEquals(Optional.of("v1"), late.get("persisted"));+ late.put("written-late", "v2");+ second.shutdownAll();++ StorageFactory third = newFactory("wal");+ AccountAwareStorageBackend<String> reloaded = third.create("svc", "svc.json", TYPE);+ assertEquals(Optional.of("v1"), reloaded.get("persisted"));+ assertEquals(Optional.of("v2"), reloaded.get("written-late"));+ third.shutdownAll();+ }++ @Test+ void shutdownFlushesAndLeavesNoOpenWalWriter() throws IOException {+ StorageFactory factory = newFactory("wal");+ AccountAwareStorageBackend<String> backend = factory.create("svc", "svc.json", TYPE);+ backend.put("before", "v1");+ factory.loadAll();+ factory.flushAll();+ factory.loadAll();++ factory.shutdownAll();++ assertTrue(Files.readString(tempDir.resolve("svc-snapshot.json")).contains("before"),+ "final shutdown must flush the store into the snapshot");+ long walSizeAfterShutdown = walSize();+ backend.put("after", "v2");+ assertEquals(walSizeAfterShutdown, walSize(), "no WAL writer may be open after shutdown");+ }++ @Test+ void shutdownIsSafeAfterACompletedFlushAndCanBeRepeated() throws IOException {+ StorageFactory factory = newFactory("wal");+ AccountAwareStorageBackend<String> backend = factory.create("svc", "svc.json", TYPE);+ backend.put("before", "v1");+ factory.flushAll();++ factory.shutdownAll();+ assertDoesNotThrow(factory::shutdownAll);++ long walSizeAfterShutdown = walSize();+ backend.put("after", "v2");+ assertEquals(walSizeAfterShutdown, walSize(), "no WAL writer may be open after shutdown");++ StorageFactory reloaded = newFactory("wal");+ AccountAwareStorageBackend<String> again = reloaded.create("svc", "svc.json", TYPE);+ assertEquals(Optional.of("v1"), again.get("before"));+ assertEquals(Optional.empty(), again.get("after"));+ reloaded.shutdownAll();+ }++ private long walSize() throws IOException {+ Path wal = tempDir.resolve("svc.wal");+ return Files.exists(wal) ? Files.size(wal) : 0L;+ }++ private StorageFactory newFactory(String mode) {+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.defaultAccountId()).thenReturn("000000000000");+ when(config.storage().persistentPath()).thenReturn(tempDir.toString());+ when(config.storage().wal().compactionIntervalMs()).thenReturn(60_000L);+ ServiceConfigAccess serviceConfigAccess = mock(ServiceConfigAccess.class);+ when(serviceConfigAccess.storageMode(anyString())).thenReturn(mode);+ when(serviceConfigAccess.storageFlushInterval(anyString())).thenReturn(60_000L);+ return new StorageFactory(config, serviceConfigAccess);+ }+}