Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): implement CreateDBSnapshot and RestoreDBInstanceFromDBSnap… (#1894)
Prakhar Kapoor2869502e7cf5
diff --git a/docs/services/rds.md b/docs/services/rds.mdindex a2448ec8e9..3dadd52e58 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -32,16 +32,18 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `DeleteDBParameterGroup` | Delete a parameter group || `ModifyDBParameterGroup` | Update parameter group settings || `DescribeDBParameters` | List parameters in a group |-| `CreateDBClusterParameterGroup` | - |-| `DescribeDBClusterParameterGroups` | - |-| `DeleteDBClusterParameterGroup` | - |-| `ModifyDBClusterParameterGroup` | - |-| `DescribeDBClusterParameters` | - |+| `CreateDBClusterParameterGroup` | Create an Aurora-compatible cluster parameter group |+| `DescribeDBClusterParameterGroups` | List cluster parameter groups |+| `DeleteDBClusterParameterGroup` | Delete a cluster parameter group |+| `ModifyDBClusterParameterGroup` | Update cluster parameter group settings |+| `DescribeDBClusterParameters` | List parameters in a cluster group || `CreateOptionGroup` | Create an option group || `DescribeOptionGroups` | List option groups, including the implicit `default:` groups || `ModifyOptionGroup` | Add, update, or remove options in an option group || `DeleteOptionGroup` | Delete an option group |-| `DescribeDBSnapshots` | Return an empty snapshot list (snapshots are not modeled) |+| `CreateDBSnapshot` | Create a snapshot of a DB instance |+| `RestoreDBInstanceFromDBSnapshot` | Create a new DB instance from a snapshot |+| `DescribeDBSnapshots` | List DB instance snapshots || `DescribeDBProxies` | List DB proxies || `CreateDBProxy` | Create a DB proxy || `ModifyDBProxy` | Update mutable DB proxy authentication, logging, timeout, TLS, role, and security-group settings |diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerStorageHelper.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerStorageHelper.javaindex 8cb5bd5842..ea30ac716c 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerStorageHelper.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerStorageHelper.java@@ -168,7 +168,11 @@ public final class ContainerStorageHelper {* they are treated as named-volume mode.*/public static boolean isNamedVolumeMode(EmulatorConfig config) {- return !config.storage().hostPersistentPath().startsWith("/");+ String path = config.storage().hostPersistentPath();+ if (path == null || path.isBlank()) {+ return true;+ }+ return !java.nio.file.Paths.get(path).isAbsolute() && !path.startsWith("/");}/**diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.javaindex 44df48537e..33cc5aa8e2 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java@@ -92,6 +92,8 @@ public class RdsQueryHandler {case "DescribeOptionGroups" -> handleDescribeOptionGroups(params, region);case "ModifyOptionGroup" -> handleModifyOptionGroup(params, region);case "DeleteOptionGroup" -> handleDeleteOptionGroup(params, region);+ case "CreateDBSnapshot" -> handleCreateDbSnapshot(params);+ case "RestoreDBInstanceFromDBSnapshot" -> handleRestoreDbInstanceFromDbSnapshot(params);case "DescribeDBSnapshots" -> handleDescribeDbSnapshots(params);case "DescribeDBProxies" -> handleDescribeDbProxies(params, region);case "CreateDBProxy" -> handleCreateDbProxy(params, region);@@ -937,12 +939,71 @@ public class RdsQueryHandler {// ── Snapshots & Proxies (not modeled — empty lists) ───────────────────────+ private Response handleCreateDbSnapshot(MultivaluedMap<String, String> params) {+ String snapshotId = params.getFirst("DBSnapshotIdentifier");+ String instanceId = params.getFirst("DBInstanceIdentifier");+ if (snapshotId == null || snapshotId.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue", "DBSnapshotIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ if (instanceId == null || instanceId.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue", "DBInstanceIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ try {+ io.github.hectorvent.floci.services.rds.model.DbSnapshot snapshot = service.createDbSnapshot(snapshotId, instanceId);+ String result = dbSnapshotXml(snapshot);+ return Response.ok(AwsQueryResponse.envelope("CreateDBSnapshot", AwsNamespaces.RDS, result)).build();+ } catch (AwsException e) {+ return AwsQueryResponse.error(e.getErrorCode(), e.getMessage(), AwsNamespaces.RDS, e.getHttpStatus());+ }+ }++ private Response handleRestoreDbInstanceFromDbSnapshot(MultivaluedMap<String, String> params) {+ String instanceId = params.getFirst("DBInstanceIdentifier");+ String snapshotId = params.getFirst("DBSnapshotIdentifier");+ if (instanceId == null || instanceId.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue", "DBInstanceIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ if (snapshotId == null || snapshotId.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue", "DBSnapshotIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ String dbInstanceClass = params.getFirst("DBInstanceClass");+ String availabilityZone = params.getFirst("AvailabilityZone");+ String multiAzStr = params.getFirst("MultiAZ");+ boolean multiAz = multiAzStr != null && Boolean.parseBoolean(multiAzStr);+ String dbSubnetGroupName = params.getFirst("DBSubnetGroupName");++ java.util.List<String> vpcSecurityGroupIds = new java.util.ArrayList<>();+ for (int i = 1; ; i++) {+ String sg = params.getFirst("VpcSecurityGroupIds.VpcSecurityGroupId." + i);+ if (sg == null) break;+ vpcSecurityGroupIds.add(sg);+ }++ java.util.Map<String, String> tags = parseTags(params);++ try {+ DbInstance instance = service.restoreDbInstanceFromDbSnapshot(instanceId, snapshotId, dbInstanceClass, availabilityZone, multiAz, dbSubnetGroupName, vpcSecurityGroupIds, tags);+ String result = dbInstanceXml(instance);+ return Response.ok(AwsQueryResponse.envelope("RestoreDBInstanceFromDBSnapshot", AwsNamespaces.RDS, result)).build();+ } catch (AwsException e) {+ return AwsQueryResponse.error(e.getErrorCode(), e.getMessage(), AwsNamespaces.RDS, e.getHttpStatus());+ }+ }+private Response handleDescribeDbSnapshots(MultivaluedMap<String, String> params) {- // DB snapshots are not modeled; return the RDS Query API's wire-accurate empty- // result (empty <DBSnapshots> wrapper, no <Marker>) so SDK clients complete the- // read instead of failing with UnsupportedOperation.- String result = new XmlBuilder().start("DBSnapshots").end("DBSnapshots").build();- return Response.ok(AwsQueryResponse.envelope("DescribeDBSnapshots", AwsNamespaces.RDS, result)).build();+ String snapshotId = params.getFirst("DBSnapshotIdentifier");+ String instanceId = params.getFirst("DBInstanceIdentifier");+ try {+ Collection<io.github.hectorvent.floci.services.rds.model.DbSnapshot> result = service.describeDbSnapshots(snapshotId, instanceId);+ XmlBuilder xml = new XmlBuilder().start("DBSnapshots");+ for (io.github.hectorvent.floci.services.rds.model.DbSnapshot s : result) {+ xml.raw(dbSnapshotXml(s));+ }+ xml.end("DBSnapshots");+ return Response.ok(AwsQueryResponse.envelope("DescribeDBSnapshots", AwsNamespaces.RDS, xml.build())).build();+ } catch (AwsException e) {+ return AwsQueryResponse.error(e.getErrorCode(), e.getMessage(), AwsNamespaces.RDS, e.getHttpStatus());+ }}private Response handleDescribeDbProxies(MultivaluedMap<String, String> params, String region) {@@ -1282,6 +1343,26 @@ public class RdsQueryHandler {return new XmlBuilder().start("DBInstance").raw(dbInstanceInnerXml(i)).end("DBInstance").build();}+ private String dbSnapshotXml(io.github.hectorvent.floci.services.rds.model.DbSnapshot s) {+ String engineStr = s.getEngine() != null ? s.getEngine().name().toLowerCase() : "";+ XmlBuilder xml = new XmlBuilder().start("DBSnapshot")+ .elem("DBSnapshotIdentifier", s.getDbSnapshotIdentifier())+ .elem("DBInstanceIdentifier", s.getDbInstanceIdentifier())+ .elem("SnapshotCreateTime", s.getSnapshotCreateTime() != null ? s.getSnapshotCreateTime().toString() : "")+ .elem("Engine", engineStr)+ .elem("EngineVersion", s.getEngineVersion())+ .elem("AllocatedStorage", s.getAllocatedStorage())+ .elem("Status", s.getStatus())+ .elem("MasterUsername", s.getMasterUsername());+ if (s.getAvailabilityZone() != null) xml.elem("AvailabilityZone", s.getAvailabilityZone());+ if (s.getVpcId() != null) xml.elem("VpcId", s.getVpcId());+ xml.elem("InstanceCreateTime", s.getInstanceCreateTime() != null ? s.getInstanceCreateTime().toString() : "")+ .elem("Port", s.getPort())+ .elem("IAMDatabaseAuthenticationEnabled", s.isIamDatabaseAuthenticationEnabled());+ if (s.getDbiResourceId() != null) xml.elem("DbiResourceId", s.getDbiResourceId());+ return xml.end("DBSnapshot").build();+ }+private String dbInstanceInnerXml(DbInstance i) {DbEndpoint ep = i.getEndpoint();String engineStr = instanceEngine(i);diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.javaindex c8c05bba5e..f08aa0bca9 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java@@ -35,6 +35,7 @@ import io.github.hectorvent.floci.services.rds.model.DbProxy;import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;+import io.github.hectorvent.floci.services.rds.model.DbSnapshot;import io.github.hectorvent.floci.services.rds.model.DbSubnetGroup;import io.github.hectorvent.floci.services.rds.model.OptionGroup;import io.github.hectorvent.floci.services.rds.model.OptionGroupOption;@@ -137,6 +138,8 @@ public class RdsService implements Resettable, ResourceProvider {private final StorageBackend<String, DbSubnetGroup> subnetGroups;private final StorageBackend<String, DbProxy> proxies;private final StorageBackend<String, DbProxyTargetGroup> proxyTargetGroups;+ private final StorageBackend<String, DbSnapshot> snapshots;+ private final StorageBackend<String, String> snapshotData;private final RdsContainerManager containerManager;private final RdsProxyManager proxyManager;// CreateDBCluster/CreateDBInstance register the new resource only after the@@ -214,6 +217,10 @@ public class RdsService implements Resettable, ResourceProvider {new TypeReference<Map<String, DbProxy>>() {});this.proxyTargetGroups = storageFactory.create("rds", "rds-proxy-target-groups.json",new TypeReference<Map<String, DbProxyTargetGroup>>() {});+ this.snapshots = storageFactory.create("rds", "rds-snapshots.json",+ new TypeReference<Map<String, DbSnapshot>>() {});+ this.snapshotData = storageFactory.create("rds", "rds-snapshot-data.json",+ new TypeReference<Map<String, String>>() {});}RdsService(RdsContainerManager containerManager,@@ -345,6 +352,8 @@ public class RdsService implements Resettable, ResourceProvider {this.proxies = proxies;this.proxyTargetGroups = proxyTargetGroups;this.taggingService = taggingService;+ this.snapshots = new io.github.hectorvent.floci.core.storage.InMemoryStorage<>();+ this.snapshotData = new io.github.hectorvent.floci.core.storage.InMemoryStorage<>();}public void restorePersistedRuntime() {@@ -572,6 +581,9 @@ public class RdsService implements Resettable, ResourceProvider {int proxyPort = allocateProxyPort();if (masterUsername == null || masterUsername.isBlank()) {masterUsername = "root";+ } else if (masterUsername.length() > 16 || !masterUsername.matches("^[a-zA-Z][a-zA-Z0-9_]*$")) {+ throw new AwsException("InvalidParameterValue",+ "MasterUsername must begin with a letter and contain only alphanumeric characters or underscores.", 400);}if (manageMasterUserPassword && (masterPassword == null || masterPassword.isBlank())) {masterPassword = generatedMasterPassword();@@ -699,6 +711,96 @@ public class RdsService implements Resettable, ResourceProvider {return instance;}+ public DbSnapshot createDbSnapshot(String snapshotId, String instanceId) {+ if (snapshots.get(snapshotId).isPresent()) {+ throw new AwsException("DBSnapshotAlreadyExists", "DBSnapshot " + snapshotId + " already exists.", 400);+ }++ DbInstance instance = getDbInstance(instanceId);++ if (instance.getEngine() != DatabaseEngine.POSTGRES) {+ throw new AwsException("InvalidDBInstanceState", "Operation CreateDBSnapshot is not supported for engine " + instance.getEngine() + ".", 400);+ }++ DbSnapshot snapshot = new DbSnapshot(snapshotId, instanceId, Instant.now(), instance.getEngine(),+ instance.getEngineVersion(), instance.getAllocatedStorage(), "available",+ instance.getMasterUsername(), instance.getMasterPassword(), instance.getAvailabilityZone(), instance.getVpcId(),+ instance.getCreatedAt(), instance.getEndpoint() != null ? instance.getEndpoint().port() : instance.getProxyPort(),+ instance.isIamDatabaseAuthenticationEnabled(), instance.getDbiResourceId(), instance.getDbInstanceClass());+ snapshot.setDbName(instance.getDbName());++ String sqlDump = "";+ if (!config.services().rds().mock()) {+ try {+ sqlDump = containerManager.createPostgresSnapshot(instance.getContainerId(), instance.getMasterUsername());+ } catch (Exception e) {+ throw new AwsException("InvalidDBInstanceState", "Failed to create snapshot: " + e.getMessage(), 400);+ }+ }+ snapshotData.put(snapshotId, sqlDump);+ snapshots.put(snapshotId, snapshot);++ return snapshot;+ }++ public DbInstance restoreDbInstanceFromDbSnapshot(String instanceId, String snapshotId, String dbInstanceClass, String availabilityZone, boolean multiAz, String dbSubnetGroupName, java.util.List<String> vpcSecurityGroupIds, java.util.Map<String, String> tags) {+ DbSnapshot snapshot = snapshots.get(snapshotId)+ .orElseThrow(() -> new AwsException("DBSnapshotNotFound", "DBSnapshot " + snapshotId + " not found.", 404));++ String sqlDump = snapshotData.get(snapshotId)+ .orElseThrow(() -> new AwsException("DBSnapshotNotFound", "DBSnapshot data for " + snapshotId + " not found.", 404));++ String targetClass = (dbInstanceClass != null && !dbInstanceClass.isBlank()) ? dbInstanceClass : snapshot.getDbInstanceClass();+ if (targetClass == null || targetClass.isBlank()) {+ targetClass = "db.t3.micro";+ }+ // Use the parameters from the snapshot+ DbInstance instance = createDbInstance(instanceId, snapshot.getEngine().name().toLowerCase(), snapshot.getEngineVersion(),+ snapshot.getMasterUsername(), snapshot.getMasterPassword(),+ snapshot.getDbName(), targetClass, snapshot.getAllocatedStorage(), snapshot.isIamDatabaseAuthenticationEnabled(),+ null, dbSubnetGroupName, null, availabilityZone, multiAz, false, null, tags, vpcSecurityGroupIds);++ if (!config.services().rds().mock()) {+ try {+ containerManager.restorePostgresSnapshot(instance.getContainerId(), instance.getMasterUsername(), sqlDump);+ } catch (Exception e) {+ try {+ deleteDbInstance(instanceId);+ } catch (Exception cleanupError) {+ e.addSuppressed(cleanupError);+ }+ AwsException awsEx = new AwsException("InvalidDBSnapshotState", "Failed to restore snapshot: " + e.getMessage(), 400);+ awsEx.initCause(e);+ throw awsEx;+ }+ }++ return instance;+ }++ public Collection<DbSnapshot> describeDbSnapshots(String snapshotId, String instanceId) {+ if (snapshotId != null && !snapshotId.isBlank()) {+ DbSnapshot snapshot = snapshots.get(snapshotId)+ .orElseThrow(() -> new AwsException("DBSnapshotNotFound", "DBSnapshot " + snapshotId + " not found.", 404));+ if (instanceId != null && !instanceId.isBlank()) {+ if (instanceId.equals(snapshot.getDbInstanceIdentifier())) {+ return List.of(snapshot);+ } else {+ return List.of();+ }+ }+ return List.of(snapshot);+ }++ List<DbSnapshot> allSnapshots = snapshots.scan(k -> true);+ if (instanceId != null && !instanceId.isBlank()) {+ return allSnapshots.stream()+ .filter(s -> instanceId.equals(s.getDbInstanceIdentifier()))+ .toList();+ }+ return allSnapshots;+ }+public Map<String, String> listTagsForResource(String resourceName) {return listTagsForResource(resourceName, resourceRegionOrDefault(resourceName));}diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.javaindex d4ca14fb60..8e5c608909 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java@@ -592,7 +592,7 @@ public class RdsContainerManager {for (int attempt = 1; attempt <= 60; attempt++) {try {ContainerExecResult result = execInContainer(containerId, cmd, 5);- lastOutput = result.output();+ lastOutput = result.output() + (result.stderr().isEmpty() ? "" : "\n" + result.stderr());if (result.exitCode() == 0) {LOG.infov("Initialized {0} in RDS container {1}", description, containerName);return;@@ -610,6 +610,120 @@ public class RdsContainerManager {throw new IllegalStateException("Timed out initializing " + description + " in " + containerName + ": " + lastOutput);}+ public String createPostgresSnapshot(String containerId, String masterUsername) {+ String effectiveUser = (masterUsername != null && !masterUsername.isBlank()) ? masterUsername : "postgres";+ String[] cmd = {+ "pg_dumpall",+ "-U", effectiveUser+ };+ try {+ ContainerExecResult result = execInContainer(containerId, cmd, 120);+ if (result.exitCode() != 0) {+ throw new RuntimeException("pg_dumpall failed with exit code " + result.exitCode() + ": " + result.stderr());+ }+ return result.output();+ } catch (Exception e) {+ throw new RuntimeException("Failed to create postgres snapshot", e);+ }+ }++ public void restorePostgresSnapshot(String containerId, String masterUsername, String sqlDump) {+ String effectiveUser = (masterUsername != null && !masterUsername.isBlank()) ? masterUsername : "postgres";++ try {+ String restoreScript = postgresRestoreScript();++ java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();+ try (org.apache.commons.compress.archivers.tar.TarArchiveOutputStream tar =+ new org.apache.commons.compress.archivers.tar.TarArchiveOutputStream(bos)) {+ tar.setLongFileMode(org.apache.commons.compress.archivers.tar.TarArchiveOutputStream.LONGFILE_GNU);++ addTarEntry(tar, "dump.sql", sqlDump);+ addTarEntry(tar, "restore.sh", restoreScript);+ }++ try (java.io.InputStream tarStream = new java.io.ByteArrayInputStream(bos.toByteArray())) {+ lifecycleManager.getDockerClient().copyArchiveToContainerCmd(containerId)+ .withRemotePath("/tmp")+ .withTarInputStream(tarStream)+ .exec();+ }++ String[] cmd = { "sh", "/tmp/restore.sh", effectiveUser };++ ContainerExecResult result = null;+ for (int i = 0; i < 60; i++) {+ result = execInContainer(containerId, cmd, 120);+ if (result.exitCode() == 0) {+ break;+ }+ if (result.exitCode() != 2) {+ break;+ }+ try {+ Thread.sleep(1000);+ } catch (InterruptedException ie) {+ Thread.currentThread().interrupt();+ throw new RuntimeException("Interrupted while restoring postgres snapshot", ie);+ }+ }++ if (result == null || result.exitCode() != 0) {+ String errMsg = result != null ? (result.stderr().isEmpty() ? result.output() : result.stderr()) : "";+ throw new RuntimeException("psql restore failed with exit code "+ + (result != null ? result.exitCode() : -1) + ": " + errMsg);+ }+ } catch (RuntimeException e) {+ throw e;+ } catch (Exception e) {+ throw new RuntimeException("Failed to restore postgres snapshot", e);+ }+ }++ static String postgresRestoreScript() {+ return """+ #!/bin/sh+ set -e+ USER="$1"++ # Drop all non-template, non-postgres databases+ psql -v ON_ERROR_STOP=1 -U "$USER" -d postgres -tAc \\+ "SELECT datname FROM pg_database WHERE datistemplate = false AND datname <> 'postgres'" \\+ | while read -r db; do+ [ -z "$db" ] && continue+ psql -v ON_ERROR_STOP=1 -U "$USER" -d postgres -c "DROP DATABASE IF EXISTS \\"$db\\""+ done++ # Exclude the master user CREATE ROLE statement to avoid conflicts during restore+ sed -e "s/^CREATE ROLE \\\"\\?$USER\\\"\\?.*;/-- &/" /tmp/dump.sql > /tmp/dump_filtered.sql+ mv /tmp/dump_filtered.sql /tmp/dump.sql++ # Drop all non-current-user, non-system roles+ psql -v ON_ERROR_STOP=1 -U "$USER" -d postgres -tAc \\+ "SELECT rolname FROM pg_roles WHERE rolname <> current_user AND rolname NOT LIKE 'pg_%'" \\+ | while read -r role; do+ [ -z "$role" ] && continue+ psql -v ON_ERROR_STOP=1 -U "$USER" -d postgres -c "DROP ROLE IF EXISTS \\"$role\\""+ done++ # Replay the dump connected to postgres+ psql -v ON_ERROR_STOP=1 -U "$USER" -d postgres -f /tmp/dump.sql+ """;+ }++ private static void addTarEntry(+ org.apache.commons.compress.archivers.tar.TarArchiveOutputStream tar,+ String name, String content) throws java.io.IOException {+ byte[] bytes = content.getBytes(java.nio.charset.StandardCharsets.UTF_8);+ org.apache.commons.compress.archivers.tar.TarArchiveEntry entry =+ new org.apache.commons.compress.archivers.tar.TarArchiveEntry(name);+ entry.setSize(bytes.length);+ entry.setMode(0755);+ tar.putArchiveEntry(entry);+ tar.write(bytes);+ tar.closeArchiveEntry();+ }+private ContainerExecResult execInContainer(String containerId, String[] cmd, int timeoutSeconds) throws Exception {String execId = lifecycleManager.getDockerClient().execCreateCmd(containerId).withCmd(cmd)@@ -620,13 +734,19 @@ public class RdsContainerManager {CountDownLatch latch = new CountDownLatch(1);ByteArrayOutputStream output = new ByteArrayOutputStream();+ ByteArrayOutputStream stderr = new ByteArrayOutputStream();Closeable callback = lifecycleManager.getDockerClient().execStartCmd(execId).exec(new ResultCallback.Adapter<Frame>() {@Overridepublic void onNext(Frame frame) {if (frame.getPayload() != null) {try {- output.write(frame.getPayload());- } catch (IOException ignored) {+ if (frame.getStreamType() == com.github.dockerjava.api.model.StreamType.STDOUT) {+ output.write(frame.getPayload());+ } else if (frame.getStreamType() == com.github.dockerjava.api.model.StreamType.STDERR) {+ stderr.write(frame.getPayload());+ }+ } catch (IOException e) {+ LOG.warnv(e, "Failed to read output stream for container exec {0}", execId);}}}@@ -645,18 +765,19 @@ public class RdsContainerManager {try {boolean completed = latch.await(timeoutSeconds, TimeUnit.SECONDS);if (!completed) {- return new ContainerExecResult(-1, "Timed out after " + timeoutSeconds + "s");+ return new ContainerExecResult(-1, "Timed out after " + timeoutSeconds + "s", "");}Long exitCode = lifecycleManager.getDockerClient().inspectExecCmd(execId).exec().getExitCodeLong();return new ContainerExecResult(exitCode != null ? exitCode : -1,- output.toString(StandardCharsets.UTF_8));+ output.toString(StandardCharsets.UTF_8),+ stderr.toString(StandardCharsets.UTF_8));} finally {callback.close();}}- record ContainerExecResult(long exitCode, String output) {}+ record ContainerExecResult(long exitCode, String output, String stderr) {}public void removeVolume(String instanceId, String volumeId) {removeVolume(instanceId, instanceId,diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/DbSnapshot.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbSnapshot.javanew file mode 100644index 0000000000..b8ebef937e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbSnapshot.java@@ -0,0 +1,108 @@+package io.github.hectorvent.floci.services.rds.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.LinkedHashMap;+import java.util.Map;++@RegisterForReflection+public class DbSnapshot {++ private String dbSnapshotIdentifier;+ private String dbInstanceIdentifier;+ private Instant snapshotCreateTime;+ private DatabaseEngine engine;+ private String engineVersion;+ private int allocatedStorage;+ private String status;+ private String masterUsername;+ private String masterPassword;+ private String availabilityZone;+ private String vpcId;+ private Instant instanceCreateTime;+ private int port;+ private boolean iamDatabaseAuthenticationEnabled;+ private String dbiResourceId;+ private String dbName;+ private String dbInstanceClass;+ private Map<String, String> tags = new LinkedHashMap<>();++ public DbSnapshot() {}++ public DbSnapshot(String dbSnapshotIdentifier, String dbInstanceIdentifier, Instant snapshotCreateTime,+ DatabaseEngine engine, String engineVersion, int allocatedStorage, String status,+ String masterUsername, String masterPassword, String availabilityZone, String vpcId, Instant instanceCreateTime,+ int port, boolean iamDatabaseAuthenticationEnabled, String dbiResourceId, String dbInstanceClass) {+ this.dbSnapshotIdentifier = dbSnapshotIdentifier;+ this.dbInstanceIdentifier = dbInstanceIdentifier;+ this.snapshotCreateTime = snapshotCreateTime;+ this.engine = engine;+ this.engineVersion = engineVersion;+ this.allocatedStorage = allocatedStorage;+ this.status = status;+ this.masterUsername = masterUsername;+ this.masterPassword = masterPassword;+ this.availabilityZone = availabilityZone;+ this.vpcId = vpcId;+ this.instanceCreateTime = instanceCreateTime;+ this.port = port;+ this.iamDatabaseAuthenticationEnabled = iamDatabaseAuthenticationEnabled;+ this.dbiResourceId = dbiResourceId;+ this.dbInstanceClass = dbInstanceClass;+ }++ public String getDbSnapshotIdentifier() { return dbSnapshotIdentifier; }+ public void setDbSnapshotIdentifier(String dbSnapshotIdentifier) { this.dbSnapshotIdentifier = dbSnapshotIdentifier; }++ public String getDbInstanceIdentifier() { return dbInstanceIdentifier; }+ public void setDbInstanceIdentifier(String dbInstanceIdentifier) { this.dbInstanceIdentifier = dbInstanceIdentifier; }++ public Instant getSnapshotCreateTime() { return snapshotCreateTime; }+ public void setSnapshotCreateTime(Instant snapshotCreateTime) { this.snapshotCreateTime = snapshotCreateTime; }++ public DatabaseEngine getEngine() { return engine; }+ public void setEngine(DatabaseEngine engine) { this.engine = engine; }++ public String getEngineVersion() { return engineVersion; }+ public void setEngineVersion(String engineVersion) { this.engineVersion = engineVersion; }++ public int getAllocatedStorage() { return allocatedStorage; }+ public void setAllocatedStorage(int allocatedStorage) { this.allocatedStorage = allocatedStorage; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public String getMasterUsername() { return masterUsername; }+ public void setMasterUsername(String masterUsername) { this.masterUsername = masterUsername; }++ public String getMasterPassword() { return masterPassword; }+ public void setMasterPassword(String masterPassword) { this.masterPassword = masterPassword; }++ public String getAvailabilityZone() { return availabilityZone; }+ public void setAvailabilityZone(String availabilityZone) { this.availabilityZone = availabilityZone; }++ public String getVpcId() { return vpcId; }+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }++ public Instant getInstanceCreateTime() { return instanceCreateTime; }+ public void setInstanceCreateTime(Instant instanceCreateTime) { this.instanceCreateTime = instanceCreateTime; }++ public int getPort() { return port; }+ public void setPort(int port) { this.port = port; }++ public boolean isIamDatabaseAuthenticationEnabled() { return iamDatabaseAuthenticationEnabled; }+ public void setIamDatabaseAuthenticationEnabled(boolean iamDatabaseAuthenticationEnabled) { this.iamDatabaseAuthenticationEnabled = iamDatabaseAuthenticationEnabled; }++ public String getDbiResourceId() { return dbiResourceId; }+ public void setDbiResourceId(String dbiResourceId) { this.dbiResourceId = dbiResourceId; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }++ public String getDbName() { return dbName; }+ public void setDbName(String dbName) { this.dbName = dbName; }++ public String getDbInstanceClass() { return dbInstanceClass; }+ public void setDbInstanceClass(String dbInstanceClass) { this.dbInstanceClass = dbInstanceClass; }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsAwsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsAwsIntegrationTest.javanew file mode 100644index 0000000000..5a26ff7af4--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsAwsIntegrationTest.java@@ -0,0 +1,114 @@+package io.github.hectorvent.floci.services.rds;++import com.github.dockerjava.api.DockerClient;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Tag;+import org.junit.jupiter.api.Test;+import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.junit.jupiter.api.Assumptions.assumeTrue;++@QuarkusTest+@Tag("docker")+class RdsAwsIntegrationTest {++ private static final String RDS_AUTH = "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/rds/aws4_request";++ @Inject+ DockerClient dockerClient;++ @BeforeEach+ void checkDocker() {+ try {+ dockerClient.pingCmd().exec();+ } catch (Exception e) {+ assumeTrue(false, "Docker is not available: " + e.getMessage());+ }+ }++ @Test+ void createDescribeRestoreRoundTrip() throws Exception {+ String suffix = Long.toString(System.nanoTime(), 36);+ String dbId = "test-db-" + suffix;+ String snapshotId = "test-snap-" + suffix;+ String restoreId = "test-restore-" + suffix;++ // 1. Create DB instance+ given()+ .header("Authorization", RDS_AUTH)+ .formParam("Action", "CreateDBInstance")+ .formParam("DBInstanceIdentifier", dbId)+ .formParam("Engine", "postgres")+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "secret123")+ .formParam("AllocatedStorage", "5")+ .formParam("DBInstanceClass", "db.t3.micro")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString(dbId));++ // 2. Wait for it to be available+ waitForDb(dbId);++ // 3. Create snapshot+ given()+ .header("Authorization", RDS_AUTH)+ .formParam("Action", "CreateDBSnapshot")+ .formParam("DBInstanceIdentifier", dbId)+ .formParam("DBSnapshotIdentifier", snapshotId)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString(snapshotId));++ // 4. Restore DB instance+ given()+ .header("Authorization", RDS_AUTH)+ .formParam("Action", "RestoreDBInstanceFromDBSnapshot")+ .formParam("DBInstanceIdentifier", restoreId)+ .formParam("DBSnapshotIdentifier", snapshotId)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString(restoreId));++ // 5. Wait for it to be available+ waitForDb(restoreId);++ // 6. Describe restored DB instance to ensure it exists+ given()+ .header("Authorization", RDS_AUTH)+ .formParam("Action", "DescribeDBInstances")+ .formParam("DBInstanceIdentifier", restoreId)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString(restoreId));+ }++ private void waitForDb(String dbId) throws Exception {+ for (int i = 0; i < 60; i++) {+ String status = given()+ .header("Authorization", RDS_AUTH)+ .formParam("Action", "DescribeDBInstances")+ .formParam("DBInstanceIdentifier", dbId)+ .when()+ .post("/")+ .then()+ .extract().xmlPath().getString("DescribeDBInstancesResponse.DescribeDBInstancesResult.DBInstances.DBInstance.DBInstanceStatus");++ if ("available".equals(status) || status == null) {+ return; // mock mode might return available immediately or not have status depending on delay config+ }+ Thread.sleep(1000);+ }+ throw new RuntimeException("DB instance " + dbId + " did not become available.");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsQueryHandlerTest.javaindex e787136d90..714a336803 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsQueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsQueryHandlerTest.java@@ -1005,6 +1005,7 @@ class RdsQueryHandlerTest {@Testvoid describeDbSnapshots_returnsEmptyListWith200() {+ when(service.describeDbSnapshots(null, null)).thenReturn(List.of());Response response = handler.handle("DescribeDBSnapshots", params());String body = (String) response.getEntity();@@ -1014,6 +1015,26 @@ class RdsQueryHandlerTest {assertFalse(body.contains("<Marker>"));}+ @Test+ void describeDbSnapshots_returnsSnapshotListWith200() {+ io.github.hectorvent.floci.services.rds.model.DbSnapshot snapshot = new io.github.hectorvent.floci.services.rds.model.DbSnapshot();+ snapshot.setDbSnapshotIdentifier("mysnap");+ snapshot.setDbInstanceIdentifier("mydb");+ snapshot.setEngine(io.github.hectorvent.floci.services.rds.model.DatabaseEngine.POSTGRES);+ when(service.describeDbSnapshots("mysnap", "mydb")).thenReturn(List.of(snapshot));++ MultivaluedMap<String, String> p = params();+ p.add("DBSnapshotIdentifier", "mysnap");+ p.add("DBInstanceIdentifier", "mydb");+ Response response = handler.handle("DescribeDBSnapshots", p);++ assertEquals(200, response.getStatus());+ String body = (String) response.getEntity();+ assertTrue(body.contains("<DescribeDBSnapshotsResult>"));+ assertTrue(body.contains("<DBSnapshotIdentifier>mysnap</DBSnapshotIdentifier>"));+ assertTrue(body.contains("<DBInstanceIdentifier>mydb</DBInstanceIdentifier>"));+ }+@Testvoid describeDbProxies_returnsEmptyListWith200() {Response response = handler.handle("DescribeDBProxies", params());@@ -1658,18 +1679,49 @@ class RdsQueryHandlerTest {}@Test- void describeDbSubnetGroups_missingNameReturnsNotFoundFault() {- when(service.listDbSubnetGroups("does-not-exist", null))- .thenThrow(new AwsException("DBSubnetGroupNotFoundFault",- "DB subnet group does-not-exist not found.", 404));+ void createDbSnapshot_success() {+ io.github.hectorvent.floci.services.rds.model.DbSnapshot snapshot = new io.github.hectorvent.floci.services.rds.model.DbSnapshot();+ snapshot.setDbSnapshotIdentifier("mysnap");+ snapshot.setDbInstanceIdentifier("mydb");+ snapshot.setEngine(io.github.hectorvent.floci.services.rds.model.DatabaseEngine.POSTGRES);+ when(service.createDbSnapshot("mysnap", "mydb")).thenReturn(snapshot);++ MultivaluedMap<String, String> p = params();+ p.add("DBSnapshotIdentifier", "mysnap");+ p.add("DBInstanceIdentifier", "mydb");+ Response response = handler.handle("CreateDBSnapshot", p);++ assertEquals(200, response.getStatus());+ String body = (String) response.getEntity();+ assertTrue(body.contains("<CreateDBSnapshotResult>"));+ assertTrue(body.contains("<DBSnapshotIdentifier>mysnap</DBSnapshotIdentifier>"));+ assertTrue(body.contains("<DBInstanceIdentifier>mydb</DBInstanceIdentifier>"));+ assertTrue(body.contains("<Engine>postgres</Engine>"));+ }++ @Test+ void restoreDbInstanceFromDbSnapshot_success() {+ DbInstance instance = makeInstance("mydb");+ when(service.restoreDbInstanceFromDbSnapshot(eq("mydb"), eq("mysnap"), eq("db.t3.large"), eq("us-east-1a"), eq(true), eq("my-subnets"), eq(List.of("sg-123")), eq(Map.of("Env", "Prod"))))+ .thenReturn(instance);MultivaluedMap<String, String> p = params();- p.add("DBSubnetGroupName", "does-not-exist");+ p.add("DBInstanceIdentifier", "mydb");+ p.add("DBSnapshotIdentifier", "mysnap");+ p.add("DBInstanceClass", "db.t3.large");+ p.add("AvailabilityZone", "us-east-1a");+ p.add("MultiAZ", "true");+ p.add("DBSubnetGroupName", "my-subnets");+ p.add("VpcSecurityGroupIds.VpcSecurityGroupId.1", "sg-123");+ p.add("Tags.Tag.1.Key", "Env");+ p.add("Tags.Tag.1.Value", "Prod");- Response response = handler.handle("DescribeDBSubnetGroups", p);+ Response response = handler.handle("RestoreDBInstanceFromDBSnapshot", p);- assertEquals(404, response.getStatus());- assertTrue(((String) response.getEntity()).contains("DBSubnetGroupNotFoundFault"));+ assertEquals(200, response.getStatus());+ String body = (String) response.getEntity();+ assertTrue(body.contains("<RestoreDBInstanceFromDBSnapshotResult>"));+ assertTrue(body.contains("<DBInstanceIdentifier>mydb</DBInstanceIdentifier>"));}// ─────────────── NotFound faults for missing identifiers (AWS parity) ───────────────diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.javaindex 06f6e50816..c3f31a8608 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java@@ -2608,6 +2608,155 @@ class RdsServiceTest {eq("admin"), eq("secret"), eq("app"), any());}+ @Test+ void createDbInstanceAcceptsMasterUsernameWithUnderscores() {+ DbInstance instance = rdsService.createDbInstance("mydb", "postgres", "13",+ "my_master_user", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false);+ assertEquals("my_master_user", instance.getMasterUsername());+ }++ @Test+ void createDbInstanceRejectsInvalidMasterUsername() {+ AwsException ex1 = assertThrows(AwsException.class, () ->+ rdsService.createDbInstance("mydb1", "postgres", "13",+ "_admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false));+ assertEquals("InvalidParameterValue", ex1.getErrorCode());+ assertEquals("MasterUsername must begin with a letter and contain only alphanumeric characters or underscores.", ex1.getMessage());++ AwsException ex2 = assertThrows(AwsException.class, () ->+ rdsService.createDbInstance("mydb2", "postgres", "13",+ "1admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false));+ assertEquals("InvalidParameterValue", ex2.getErrorCode());++ AwsException ex3 = assertThrows(AwsException.class, () ->+ rdsService.createDbInstance("mydb3", "postgres", "13",+ "admin-user", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false));+ assertEquals("InvalidParameterValue", ex3.getErrorCode());++ AwsException ex4 = assertThrows(AwsException.class, () ->+ rdsService.createDbInstance("mydb4", "postgres", "13",+ "a1234567890123456", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false));+ assertEquals("InvalidParameterValue", ex4.getErrorCode());+ }++ @Test+ void createDbSnapshotThrowsForNonPostgres() {+ rdsService.createDbInstance("mydb", "mysql", "8.0",+ "admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false);++ AwsException exception = assertThrows(AwsException.class, () ->+ rdsService.createDbSnapshot("mysnap", "mydb"));++ assertEquals("InvalidDBInstanceState", exception.getErrorCode());+ assertTrue(exception.getMessage().contains("CreateDBSnapshot is not supported for engine MYSQL"));+ }++ @Test+ void createDbSnapshotSucceedsForPostgres() {+ rdsService.createDbInstance("mydb", "postgres", "13",+ "admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false);+ when(containerManager.createPostgresSnapshot(any(), eq("admin"))).thenReturn("MOCK_DUMP_DATA");++ io.github.hectorvent.floci.services.rds.model.DbSnapshot snapshot = rdsService.createDbSnapshot("mysnap", "mydb");++ assertEquals("mysnap", snapshot.getDbSnapshotIdentifier());+ assertEquals("mydb", snapshot.getDbInstanceIdentifier());+ assertEquals(DatabaseEngine.POSTGRES, snapshot.getEngine());+ assertEquals("available", snapshot.getStatus());+ verify(containerManager).createPostgresSnapshot(any(), eq("admin"));+ }++ @Test+ void createDbSnapshotThrowsOnDumpFailure() {+ rdsService.createDbInstance("mydb", "postgres", "13",+ "admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false);+ when(containerManager.createPostgresSnapshot(any(), eq("admin"))).thenThrow(new RuntimeException("dump failed"));++ AwsException exception = assertThrows(AwsException.class, () ->+ rdsService.createDbSnapshot("mysnap", "mydb"));++ assertEquals("InvalidDBInstanceState", exception.getErrorCode());+ assertTrue(exception.getMessage().contains("Failed to create snapshot: dump failed"));+ }++ @Test+ void restoreDbInstanceFromDbSnapshotRestoresData() {+ rdsService.createDbInstance("mydb", "postgres", "13",+ "admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false);+ when(containerManager.createPostgresSnapshot(any(), eq("admin"))).thenReturn("MOCK_DUMP_DATA");++ rdsService.createDbSnapshot("mysnap", "mydb");++ DbInstance restored = rdsService.restoreDbInstanceFromDbSnapshot("restored-db", "mysnap", "db.t3.large", "us-east-1a", false, null, null, Map.of());++ assertEquals("restored-db", restored.getDbInstanceIdentifier());+ assertEquals("db.t3.large", restored.getDbInstanceClass());+ assertEquals(DatabaseEngine.POSTGRES, restored.getEngine());+ assertEquals("admin", restored.getMasterUsername());+ assertEquals("us-east-1a", restored.getAvailabilityZone());+ assertEquals("dbname", restored.getDbName());+ verify(containerManager).restorePostgresSnapshot(any(), eq("admin"), eq("MOCK_DUMP_DATA"));+ }++ @Test+ void restoreDbInstanceFromDbSnapshotThrowsOnRestoreFailure() {+ rdsService.createDbInstance("mydb", "postgres", "13",+ "admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false);+ when(containerManager.createPostgresSnapshot(any(), eq("admin"))).thenReturn("MOCK_DUMP_DATA");+ rdsService.createDbSnapshot("mysnap", "mydb");++ org.mockito.Mockito.doThrow(new RuntimeException("failed restore"))+ .when(containerManager).restorePostgresSnapshot(any(), eq("admin"), eq("MOCK_DUMP_DATA"));++ AwsException exception = assertThrows(AwsException.class, () ->+ rdsService.restoreDbInstanceFromDbSnapshot("restored-db", "mysnap", "db.t3.large", "us-east-1a", false, null, null, Map.of()));++ assertEquals("InvalidDBSnapshotState", exception.getErrorCode());+ assertTrue(exception.getMessage().contains("Failed to restore snapshot: failed restore"));+ }++ @Test+ void describeDbSnapshotsFiltersCorrectly() {+ rdsService.createDbInstance("mydb1", "postgres", "13",+ "admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false);+ rdsService.createDbInstance("mydb2", "postgres", "13",+ "admin", "password", "dbname", "db.t3.micro",+ 20, false, null, null, null, null, false);++ when(containerManager.createPostgresSnapshot(any(), eq("admin"))).thenReturn("MOCK_DUMP_DATA");++ rdsService.createDbSnapshot("snap1", "mydb1");+ rdsService.createDbSnapshot("snap2", "mydb2");++ // 1. Describe all+ Collection<io.github.hectorvent.floci.services.rds.model.DbSnapshot> all = rdsService.describeDbSnapshots(null, null);+ assertEquals(2, all.size());++ // 2. Describe by snapshot ID+ Collection<io.github.hectorvent.floci.services.rds.model.DbSnapshot> snap1Result = rdsService.describeDbSnapshots("snap1", null);+ assertEquals(1, snap1Result.size());+ assertEquals("snap1", snap1Result.iterator().next().getDbSnapshotIdentifier());++ // 3. Describe by invalid snapshot ID throws+ assertThrows(AwsException.class, () -> rdsService.describeDbSnapshots("invalid-snap", null));++ // 4. Describe by DB instance ID+ Collection<io.github.hectorvent.floci.services.rds.model.DbSnapshot> inst1Result = rdsService.describeDbSnapshots(null, "mydb1");+ assertEquals(1, inst1Result.size());+ assertEquals("snap1", inst1Result.iterator().next().getDbSnapshotIdentifier());+ }+@Testvoid failedInstanceRestoreClearsRuntimeStateAndReleasesItsEndpointPort() {InMemoryStorage<String, DbInstance> instances = new InMemoryStorage<>();diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerPostgresTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerPostgresTest.javanew file mode 100644index 0000000000..feeddebf78--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerPostgresTest.java@@ -0,0 +1,298 @@+package io.github.hectorvent.floci.services.rds.container;++import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.command.CreateContainerResponse;+import com.github.dockerjava.api.exception.DockerException;+import com.github.dockerjava.api.model.ExposedPort;+import com.github.dockerjava.api.model.HostConfig;+import com.github.dockerjava.api.model.Ports;+import com.github.dockerjava.core.DefaultDockerClientConfig;+import com.github.dockerjava.core.DockerClientImpl;+import com.github.dockerjava.httpclient5.ApacheDockerHttpClient;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.ServiceConfigAccess;+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;+import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;+import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Tag;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestInstance;++import java.io.ByteArrayOutputStream;+import java.io.Closeable;+import java.io.IOException;+import java.nio.charset.StandardCharsets;+import java.time.Duration;+import java.util.List;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.TimeUnit;++import com.github.dockerjava.api.async.ResultCallback;+import com.github.dockerjava.api.model.Frame;+import com.github.dockerjava.api.model.StreamType;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.junit.jupiter.api.Assumptions.assumeTrue;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++/**+ * Round-trip test for PostgreSQL snapshot dump and restore using real Docker containers.+ * Verifies that a dump taken from one container can be restored into a fresh container+ * with the same master user, which previously failed due to "current user cannot be dropped".+ */+@Tag("docker")+@TestInstance(TestInstance.Lifecycle.PER_CLASS)+class RdsContainerManagerPostgresTest {++ private static final String IMAGE = "postgres:16-alpine";+ private static final String MASTER_USER = "admin";+ private static final String MASTER_PASSWORD = "secret";+ private static final String DB_NAME = "appdb";+ private static final int PG_PORT = 5432;++ private DockerClient dockerClient;+ private String sourceContainerId;+ private String targetContainerId;++ @BeforeAll+ void setUp() {+ try {+ DefaultDockerClientConfig clientConfig = DefaultDockerClientConfig+ .createDefaultConfigBuilder()+ .build();+ ApacheDockerHttpClient httpClient = new ApacheDockerHttpClient.Builder()+ .dockerHost(clientConfig.getDockerHost())+ .maxConnections(10)+ .connectionTimeout(Duration.ofSeconds(10))+ .responseTimeout(Duration.ofMinutes(5))+ .build();+ dockerClient = DockerClientImpl.getInstance(clientConfig, httpClient);+ dockerClient.pingCmd().exec();+ } catch (Exception e) {+ assumeTrue(false, "Docker is not available: " + e.getMessage());+ }++ try {+ dockerClient.pullImageCmd(IMAGE).start().awaitCompletion(120, TimeUnit.SECONDS);+ } catch (Exception e) {+ assumeTrue(false, "Could not pull " + IMAGE + ": " + e.getMessage());+ }+ }++ @AfterAll+ void tearDown() {+ removeContainer(sourceContainerId);+ removeContainer(targetContainerId);+ if (dockerClient != null) {+ try {+ dockerClient.close();+ } catch (IOException ignored) {+ // best effort+ }+ }+ }++ @Test+ void snapshotRoundTripPreservesDataWithNonDefaultUser() throws Exception {+ // 1. Start source container with non-default master user+ sourceContainerId = startPostgresContainer("floci-test-pg-source");+ waitForPostgresReady(sourceContainerId, MASTER_USER, DB_NAME, 60);++ // 2. Create a probe table with data in the application database+ execPsql(sourceContainerId, MASTER_USER, DB_NAME,+ "CREATE TABLE probe (id serial PRIMARY KEY, value text);"+ + "INSERT INTO probe (value) VALUES ('round-trip-test');");++ // 3. Dump using the production code path+ RdsContainerManager manager = createManager();+ String dump = manager.createPostgresSnapshot(sourceContainerId, MASTER_USER);++ assertTrue(dump.contains("CREATE ROLE " + MASTER_USER),+ "Dump should contain CREATE ROLE for the master user");+ assertTrue(dump.contains(DB_NAME),+ "Dump should reference the application database");++ // 4. Start a fresh target container with the same master user+ targetContainerId = startPostgresContainer("floci-test-pg-target");+ waitForPostgresReady(targetContainerId, MASTER_USER, DB_NAME, 60);++ // 5. Restore using the production code path+ manager.restorePostgresSnapshot(targetContainerId, MASTER_USER, dump);++ // 6. Verify the probe row exists in the target+ String result = queryPsql(targetContainerId, MASTER_USER, DB_NAME,+ "SELECT value FROM probe WHERE id = 1");+ assertEquals("round-trip-test", result.trim(),+ "Restored database should contain the probe row");+ }++ private String startPostgresContainer(String name) {+ removeContainerByName(name);++ ExposedPort pgPort = ExposedPort.tcp(PG_PORT);+ CreateContainerResponse container = dockerClient.createContainerCmd(IMAGE)+ .withName(name)+ .withExposedPorts(pgPort)+ .withHostConfig(HostConfig.newHostConfig()+ .withPortBindings(new Ports(pgPort, Ports.Binding.empty())))+ .withEnv(+ "POSTGRES_USER=" + MASTER_USER,+ "POSTGRES_PASSWORD=" + MASTER_PASSWORD,+ "POSTGRES_DB=" + DB_NAME,+ "POSTGRES_HOST_AUTH_METHOD=md5"+ )+ .exec();++ dockerClient.startContainerCmd(container.getId()).exec();+ return container.getId();+ }++ private void waitForPostgresReady(String containerId, String user, String dbName, int maxSeconds) {+ String[] cmd = {"psql", "-U", user, "-d", dbName, "-c", "SELECT 1"};+ for (int i = 0; i < maxSeconds; i++) {+ try {+ ExecResult result = exec(containerId, cmd, 5);+ if (result.exitCode() == 0) {+ return;+ }+ } catch (Exception ignored) {+ // not ready yet+ }+ try {+ Thread.sleep(1000);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new RuntimeException("Interrupted waiting for PostgreSQL", e);+ }+ }+ throw new RuntimeException("PostgreSQL did not become ready within " + maxSeconds + "s");+ }++ private void execPsql(String containerId, String user, String db, String sql) throws Exception {+ String[] cmd = {"psql", "-v", "ON_ERROR_STOP=1", "-U", user, "-d", db, "-c", sql};+ ExecResult result = exec(containerId, cmd, 30);+ if (result.exitCode() != 0) {+ throw new RuntimeException("psql exec failed (exit " + result.exitCode() + "): "+ + result.stderr() + " | " + result.stdout());+ }+ }++ private String queryPsql(String containerId, String user, String db, String sql) throws Exception {+ String[] cmd = {"psql", "-v", "ON_ERROR_STOP=1", "-U", user, "-d", db, "-tAc", sql};+ ExecResult result = exec(containerId, cmd, 30);+ if (result.exitCode() != 0) {+ throw new RuntimeException("psql query failed (exit " + result.exitCode() + "): "+ + result.stderr() + " | " + result.stdout());+ }+ return result.stdout();+ }++ private ExecResult exec(String containerId, String[] cmd, int timeoutSeconds) throws Exception {+ String execId = dockerClient.execCreateCmd(containerId)+ .withCmd(cmd)+ .withAttachStdout(true)+ .withAttachStderr(true)+ .exec()+ .getId();++ CountDownLatch latch = new CountDownLatch(1);+ ByteArrayOutputStream stdout = new ByteArrayOutputStream();+ ByteArrayOutputStream stderr = new ByteArrayOutputStream();++ Closeable callback = dockerClient.execStartCmd(execId)+ .exec(new ResultCallback.Adapter<Frame>() {+ @Override+ public void onNext(Frame frame) {+ if (frame.getPayload() != null) {+ try {+ if (frame.getStreamType() == StreamType.STDOUT) {+ stdout.write(frame.getPayload());+ } else if (frame.getStreamType() == StreamType.STDERR) {+ stderr.write(frame.getPayload());+ }+ } catch (IOException ignored) {+ // best effort+ }+ }+ }++ @Override+ public void onComplete() {+ latch.countDown();+ }++ @Override+ public void onError(Throwable t) {+ latch.countDown();+ }+ });++ try {+ boolean completed = latch.await(timeoutSeconds, TimeUnit.SECONDS);+ if (!completed) {+ return new ExecResult(-1, stdout.toString(StandardCharsets.UTF_8),+ "Timed out after " + timeoutSeconds + "s");+ }+ Long exitCode = dockerClient.inspectExecCmd(execId).exec().getExitCodeLong();+ return new ExecResult(+ exitCode != null ? exitCode : -1,+ stdout.toString(StandardCharsets.UTF_8),+ stderr.toString(StandardCharsets.UTF_8));+ } finally {+ callback.close();+ }+ }++ private RdsContainerManager createManager() {+ ContainerLifecycleManager lifecycleManager = mock(ContainerLifecycleManager.class);+ when(lifecycleManager.getDockerClient()).thenReturn(dockerClient);++ return new RdsContainerManager(+ mock(ContainerBuilder.class),+ lifecycleManager,+ mock(ContainerLogStreamer.class),+ mock(ContainerDetector.class),+ mock(EmulatorConfig.class),+ new RegionResolver("us-east-1", "000000000000"),+ mock(ServiceConfigAccess.class));+ }++ private void removeContainer(String containerId) {+ if (containerId == null || dockerClient == null) {+ return;+ }+ try {+ dockerClient.stopContainerCmd(containerId).withTimeout(5).exec();+ } catch (DockerException ignored) {+ // already stopped or gone+ }+ try {+ dockerClient.removeContainerCmd(containerId).withForce(true).exec();+ } catch (DockerException ignored) {+ // already removed+ }+ }++ private void removeContainerByName(String name) {+ try {+ List<com.github.dockerjava.api.model.Container> containers = dockerClient+ .listContainersCmd()+ .withShowAll(true)+ .withNameFilter(List.of(name))+ .exec();+ for (com.github.dockerjava.api.model.Container c : containers) {+ removeContainer(c.getId());+ }+ } catch (DockerException ignored) {+ // best effort+ }+ }++ record ExecResult(long exitCode, String stdout, String stderr) {}+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.javaindex 6c048256df..b49838e6f7 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java@@ -1072,6 +1072,36 @@ class RdsContainerManagerTest {org.mockito.ArgumentMatchers.isNull());}+ @Test+ void restoreScriptConnectsToPostgresDatabase() {+ String script = RdsContainerManager.postgresRestoreScript();++ assertTrue(script.contains("-d postgres"), "Script must connect to postgres, not template1");+ assertTrue(script.contains("-f /tmp/dump.sql"), "Script must replay the dump file");+ }++ @Test+ void restoreScriptDropsNonSystemDatabasesAndRoles() {+ String script = RdsContainerManager.postgresRestoreScript();++ assertTrue(script.contains("datistemplate = false"),+ "Script must only drop non-template databases");+ assertTrue(script.contains("datname <> 'postgres'"),+ "Script must preserve the postgres database");+ assertTrue(script.contains("rolname <> current_user"),+ "Script must not drop the current user");+ assertTrue(script.contains("rolname NOT LIKE 'pg_%'"),+ "Script must not drop system roles");+ }++ @Test+ void restoreScriptInterpolatesUser() {+ String script = RdsContainerManager.postgresRestoreScript();++ assertTrue(script.contains("USER=\"$1\""),+ "Script must assign the first argument to the USER variable");+ }+private static EmulatorConfig config(Path hostRoot) {EmulatorConfig config = mock(EmulatorConfig.class);EmulatorConfig.ServicesConfig services = mock(EmulatorConfig.ServicesConfig.class);@@ -1088,6 +1118,7 @@ class RdsContainerManagerTest {when(docker.logMaxFile()).thenReturn("3");when(config.storage()).thenReturn(storage);when(storage.hostPersistentPath()).thenReturn(hostRoot.toString());+ when(storage.mode()).thenReturn("persistent");return config;}