Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): DB cluster snapshots (#4097)
Davidecdc9ccfdd59
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.javaindex 7bdab592a5..d00df757f1 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java@@ -14,9 +14,12 @@ import software.amazon.awssdk.services.rds.model.ConnectionPoolConfigurationInfoimport software.amazon.awssdk.services.rds.model.CreateDbProxyResponse;import software.amazon.awssdk.services.rds.model.CreateDbSubnetGroupResponse;import software.amazon.awssdk.services.rds.model.CreateOptionGroupResponse;+import software.amazon.awssdk.services.rds.model.DBCluster;+import software.amazon.awssdk.services.rds.model.DBClusterSnapshot;import software.amazon.awssdk.services.rds.model.DBInstance;import software.amazon.awssdk.services.rds.model.DBProxyTarget;import software.amazon.awssdk.services.rds.model.DBSnapshot;+import software.amazon.awssdk.services.rds.model.DbClusterSnapshotNotFoundException;import software.amazon.awssdk.services.rds.model.DbSnapshotAlreadyExistsException;import software.amazon.awssdk.services.rds.model.DbSnapshotNotFoundException;import software.amazon.awssdk.services.rds.model.InvalidDbInstanceStateException;@@ -480,6 +483,80 @@ class RdsControlPlaneTest {}}+ @Test+ void sdkCreatesCopiesRestoresAndDeletesClusterSnapshots() {+ String clusterName = TestFixtures.uniqueName("rds-csnap-cluster");+ String snapshotName = TestFixtures.uniqueName("rds-csnap");+ String copyName = snapshotName + "-copy";+ String restoredName = clusterName + "-restored";+ try {+ rds.createDBCluster(b -> b+ .dbClusterIdentifier(clusterName)+ .engine("aurora-postgresql")+ .engineVersion("16.3")+ .masterUsername("admin")+ .masterUserPassword("csnap-secret")+ .databaseName("app"));++ DBClusterSnapshot snapshot = rds.createDBClusterSnapshot(b -> b+ .dbClusterSnapshotIdentifier(snapshotName)+ .dbClusterIdentifier(clusterName)+ .tags(Tag.builder().key("owner").value("platform").build()))+ .dbClusterSnapshot();+ assertThat(snapshot.status()).isEqualTo("available");+ assertThat(snapshot.snapshotType()).isEqualTo("manual");+ assertThat(snapshot.percentProgress()).isEqualTo(100);+ assertThat(snapshot.engine()).isEqualTo("aurora-postgresql");+ assertThat(snapshot.dbClusterSnapshotArn()).contains(":cluster-snapshot:" + snapshotName);++ assertThat(rds.describeDBClusterSnapshots(b -> b.dbClusterIdentifier(clusterName)).dbClusterSnapshots())+ .extracting(DBClusterSnapshot::dbClusterSnapshotIdentifier)+ .containsExactly(snapshotName);++ DBClusterSnapshot copy = rds.copyDBClusterSnapshot(b -> b+ .sourceDBClusterSnapshotIdentifier(snapshot.dbClusterSnapshotArn())+ .targetDBClusterSnapshotIdentifier(copyName)+ .copyTags(true))+ .dbClusterSnapshot();+ assertThat(copy.sourceDBClusterSnapshotArn()).isEqualTo(snapshot.dbClusterSnapshotArn());+ assertThat(copy.tagList()).extracting(Tag::key).containsExactly("owner");++ rds.modifyDBClusterSnapshotAttribute(b -> b+ .dbClusterSnapshotIdentifier(copyName)+ .attributeName("restore")+ .valuesToAdd("all"));+ assertThat(rds.describeDBClusterSnapshotAttributes(b -> b.dbClusterSnapshotIdentifier(copyName))+ .dbClusterSnapshotAttributesResult().dbClusterSnapshotAttributes())+ .singleElement()+ .satisfies(attribute -> assertThat(attribute.attributeValues()).containsExactly("all"));++ assertThat(rds.deleteDBClusterSnapshot(b -> b.dbClusterSnapshotIdentifier(snapshotName))+ .dbClusterSnapshot().status()).isEqualTo("deleted");+ assertThatThrownBy(() -> rds.describeDBClusterSnapshots(b -> b.dbClusterSnapshotIdentifier(snapshotName)))+ .isInstanceOf(DbClusterSnapshotNotFoundException.class);++ DBCluster restored = rds.restoreDBClusterFromSnapshot(b -> b+ .dbClusterIdentifier(restoredName)+ .snapshotIdentifier(copy.dbClusterSnapshotArn())+ .engine("aurora-postgresql"))+ .dbCluster();+ assertThat(restored.dbClusterIdentifier()).isEqualTo(restoredName);+ assertThat(restored.masterUsername()).isEqualTo("admin");+ assertThat(restored.databaseName()).isEqualTo("app");+ } finally {+ for (String name : List.of(snapshotName, copyName)) {+ try {+ rds.deleteDBClusterSnapshot(b -> b.dbClusterSnapshotIdentifier(name));+ } catch (Exception ignored) {}+ }+ for (String name : List.of(restoredName, clusterName)) {+ try {+ rds.deleteDBCluster(b -> b.dbClusterIdentifier(name).skipFinalSnapshot(true));+ } catch (Exception ignored) {}+ }+ }+ }+private static CreateDbProxyResponse createIamProxy(RdsClient client, String name, List<String> vpcSubnetIds) {return client.createDBProxy(b -> b.dbProxyName(name)diff --git a/docs/services/rds.md b/docs/services/rds.mdindex b563366766..5586205440 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -73,7 +73,13 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `DescribeDBProxyTargetGroups` | List a proxy's target groups || `ModifyDBProxyTargetGroup` | Update target-group connection-pool configuration || `DescribeDBProxyTargets` | List a proxy target group's registered targets |-| `DescribeDBClusterSnapshots` | Return an empty cluster-snapshot list (snapshots are not modeled) |+| `DescribeDBClusterSnapshots` | List cluster snapshots, filtered by `DBClusterSnapshotIdentifier`, `DBClusterIdentifier` and `SnapshotType` |+| `CreateDBClusterSnapshot` | Take a manual snapshot of an available cluster, with its data and `Tags` |+| `DeleteDBClusterSnapshot` | Delete an available cluster snapshot and its data; the response carries `Status` `deleted` |+| `CopyDBClusterSnapshot` | Copy an available cluster snapshot (by identifier or same-region ARN) to a new manual one with its data; `CopyTags` and `Tags`; the copy reports `SourceDBClusterSnapshotArn` |+| `RestoreDBClusterFromSnapshot` | Create a cluster from a cluster snapshot's settings and data; `Engine` must match the snapshot's |+| `DescribeDBClusterSnapshotAttributes` | Return the `restore` attribute of a cluster snapshot |+| `ModifyDBClusterSnapshotAttribute` | Add or remove `restore` values (account ids or `all`) on a cluster snapshot || `DescribeGlobalClusters` | List the account's global clusters with their primary and secondary members; see [Global clusters](#global-clusters) || `CreateGlobalCluster` | Create an Aurora global database, empty or with an existing Aurora cluster as its primary || `ModifyGlobalCluster` | Rename a global cluster, set deletion protection, or upgrade its engine version (members follow) |@@ -123,9 +129,11 @@ checked against the instance's other window. Modifications apply immediately —identifier or ARN, and modified. Copies retain the source data and can copy source tags or addrequest tags. Snapshots are region-scoped like DB instances and clusters: `DBSnapshotArn` reflectsthe request's signed region, and a snapshot is only visible to `Describe`/`Tag` calls signed- for that same region. Aurora cluster snapshots and RDS reserved instances aren't modeled at- all (`DescribeDBClusterSnapshots` always returns an empty list, and there's no- reserved-instance API), so tagging doesn't apply to either.+ for that same region. Cluster snapshots follow the same lifecycle: `CreateDBClusterSnapshot`+ dumps the cluster's database, `RestoreDBClusterFromSnapshot` loads it into a new cluster, and+ `Copy`, `Delete` and the `restore` attribute behave as they do for instance snapshots, under+ `arn:aws:rds:<region>:<account>:cluster-snapshot:<name>`. RDS reserved instances aren't+ modeled (there's no reserved-instance API), so tagging doesn't apply to them.## Configurationdiff --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 61b3887dbb..c6931627a9 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@@ -8,6 +8,7 @@ import io.github.hectorvent.floci.core.common.AwsQueryResponse;import io.github.hectorvent.floci.core.common.XmlBuilder;import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;import io.github.hectorvent.floci.services.rds.model.DbCluster;+import io.github.hectorvent.floci.services.rds.model.DbClusterSnapshot;import io.github.hectorvent.floci.services.rds.model.DbClusterParameterGroup;import io.github.hectorvent.floci.services.rds.model.DbEndpoint;import io.github.hectorvent.floci.services.docdb.DocDbQueryHandler;@@ -132,7 +133,13 @@ public class RdsQueryHandler {case "DescribeDBProxyTargetGroups" -> handleDescribeDbProxyTargetGroups(params, region);case "ModifyDBProxyTargetGroup" -> handleModifyDbProxyTargetGroup(params, region);case "DescribeDBProxyTargets" -> handleDescribeDbProxyTargets(params, region);- case "DescribeDBClusterSnapshots" -> handleDescribeDbClusterSnapshots(params);+ case "DescribeDBClusterSnapshots" -> handleDescribeDbClusterSnapshots(params, region);+ case "CreateDBClusterSnapshot" -> handleCreateDbClusterSnapshot(params, region);+ case "DeleteDBClusterSnapshot" -> handleDeleteDbClusterSnapshot(params, region);+ case "CopyDBClusterSnapshot" -> handleCopyDbClusterSnapshot(params, region);+ case "RestoreDBClusterFromSnapshot" -> handleRestoreDbClusterFromSnapshot(params, region);+ case "DescribeDBClusterSnapshotAttributes" -> handleDescribeDbClusterSnapshotAttributes(params, region);+ case "ModifyDBClusterSnapshotAttribute" -> handleModifyDbClusterSnapshotAttribute(params, region);case "DescribeGlobalClusters" -> handleDescribeGlobalClusters(params);case "CreateGlobalCluster" -> handleCreateGlobalCluster(params, region);case "ModifyGlobalCluster" -> handleModifyGlobalCluster(params);@@ -2000,12 +2007,92 @@ public class RdsQueryHandler {return xml.end(elementName).build();}- private Response handleDescribeDbClusterSnapshots(MultivaluedMap<String, String> params) {- // DB cluster snapshots are not modeled; return the RDS Query API's wire-accurate- // empty result (empty <DBClusterSnapshots> wrapper, no <Marker>) so SDK clients- // complete the read instead of failing with UnsupportedOperation.- String result = new XmlBuilder().start("DBClusterSnapshots").end("DBClusterSnapshots").build();- return Response.ok(AwsQueryResponse.envelope("DescribeDBClusterSnapshots", AwsNamespaces.RDS, result)).build();+ private Response handleDescribeDbClusterSnapshots(MultivaluedMap<String, String> params, String region) {+ XmlBuilder xml = new XmlBuilder().start("DBClusterSnapshots");+ for (DbClusterSnapshot s : service.describeDbClusterSnapshots(+ params.getFirst("DBClusterSnapshotIdentifier"), params.getFirst("DBClusterIdentifier"),+ params.getFirst("SnapshotType"), region)) {+ xml.raw(dbClusterSnapshotXml(s));+ }+ xml.end("DBClusterSnapshots");+ return Response.ok(AwsQueryResponse.envelope("DescribeDBClusterSnapshots", AwsNamespaces.RDS, xml.build())).build();+ }++ private Response handleCreateDbClusterSnapshot(MultivaluedMap<String, String> params, String region) {+ String snapshotId = params.getFirst("DBClusterSnapshotIdentifier");+ String clusterId = params.getFirst("DBClusterIdentifier");+ Response missing = firstMissingParam(+ "DBClusterSnapshotIdentifier", snapshotId,+ "DBClusterIdentifier", clusterId);+ if (missing != null) {+ return missing;+ }+ DbClusterSnapshot snapshot = service.createDbClusterSnapshot(snapshotId, clusterId, parseTags(params), region);+ return Response.ok(AwsQueryResponse.envelope("CreateDBClusterSnapshot", AwsNamespaces.RDS,+ dbClusterSnapshotXml(snapshot))).build();+ }++ private Response handleDeleteDbClusterSnapshot(MultivaluedMap<String, String> params, String region) {+ String snapshotId = params.getFirst("DBClusterSnapshotIdentifier");+ Response missing = firstMissingParam("DBClusterSnapshotIdentifier", snapshotId);+ if (missing != null) {+ return missing;+ }+ DbClusterSnapshot snapshot = service.deleteDbClusterSnapshot(snapshotId, region);+ return Response.ok(AwsQueryResponse.envelope("DeleteDBClusterSnapshot", AwsNamespaces.RDS,+ dbClusterSnapshotXml(snapshot))).build();+ }++ private Response handleCopyDbClusterSnapshot(MultivaluedMap<String, String> params, String region) {+ String sourceId = params.getFirst("SourceDBClusterSnapshotIdentifier");+ String targetId = params.getFirst("TargetDBClusterSnapshotIdentifier");+ Response missing = firstMissingParam(+ "SourceDBClusterSnapshotIdentifier", sourceId,+ "TargetDBClusterSnapshotIdentifier", targetId);+ if (missing != null) {+ return missing;+ }+ boolean copyTags = "true".equalsIgnoreCase(params.getFirst("CopyTags"));+ DbClusterSnapshot copy = service.copyDbClusterSnapshot(sourceId, targetId, copyTags, parseTags(params), region);+ return Response.ok(AwsQueryResponse.envelope("CopyDBClusterSnapshot", AwsNamespaces.RDS,+ dbClusterSnapshotXml(copy))).build();+ }++ private Response handleRestoreDbClusterFromSnapshot(MultivaluedMap<String, String> params, String region) {+ String clusterId = params.getFirst("DBClusterIdentifier");+ String snapshotId = params.getFirst("SnapshotIdentifier");+ String engine = params.getFirst("Engine");+ Response missing = firstMissingParam(+ "DBClusterIdentifier", clusterId,+ "SnapshotIdentifier", snapshotId,+ "Engine", engine);+ if (missing != null) {+ return missing;+ }+ DbCluster cluster = service.restoreDbClusterFromSnapshot(clusterId, snapshotId, engine,+ params.getFirst("EngineVersion"), optionalInt(params.getFirst("Port")),+ params.getFirst("DatabaseName"), params.getFirst("DBSubnetGroupName"),+ params.getFirst("DBClusterParameterGroupName"),+ params.getFirst("AvailabilityZones.member.1"),+ optionalBoolean(params.getFirst("EnableIAMDatabaseAuthentication")),+ params.getFirst("EngineMode"), parseTags(params), region);+ return Response.ok(AwsQueryResponse.envelope("RestoreDBClusterFromSnapshot", AwsNamespaces.RDS,+ dbClusterXml(cluster))).build();+ }++ private Response handleDescribeDbClusterSnapshotAttributes(MultivaluedMap<String, String> params, String region) {+ DbClusterSnapshot snapshot = service.describeDbClusterSnapshotAttributes(+ params.getFirst("DBClusterSnapshotIdentifier"), region);+ return Response.ok(AwsQueryResponse.envelope("DescribeDBClusterSnapshotAttributes", AwsNamespaces.RDS,+ dbClusterSnapshotAttributesResultXml(snapshot))).build();+ }++ private Response handleModifyDbClusterSnapshotAttribute(MultivaluedMap<String, String> params, String region) {+ DbClusterSnapshot snapshot = service.modifyDbClusterSnapshotAttribute(+ params.getFirst("DBClusterSnapshotIdentifier"), params.getFirst("AttributeName"),+ memberList(params, "ValuesToAdd"), memberList(params, "ValuesToRemove"), region);+ return Response.ok(AwsQueryResponse.envelope("ModifyDBClusterSnapshotAttribute", AwsNamespaces.RDS,+ dbClusterSnapshotAttributesResultXml(snapshot))).build();}// ── XML builders ──────────────────────────────────────────────────────────@@ -2050,6 +2137,52 @@ public class RdsQueryHandler {return xml.end("DBSnapshot").build();}+ private String dbClusterSnapshotXml(DbClusterSnapshot s) {+ XmlBuilder xml = new XmlBuilder().start("DBClusterSnapshot");+ xml.start("AvailabilityZones");+ for (String zone : s.getAvailabilityZones()) {+ xml.elem("AvailabilityZone", zone);+ }+ xml.end("AvailabilityZones");+ xml.elem("DBClusterSnapshotIdentifier", s.getDbClusterSnapshotIdentifier())+ .elem("DBClusterIdentifier", s.getDbClusterIdentifier())+ .elem("SnapshotCreateTime", s.getSnapshotCreateTime() != null ? s.getSnapshotCreateTime().toString() : "")+ .elem("Engine", s.getEngineIdentifier() != null ? s.getEngineIdentifier() : "")+ .elem("EngineMode", s.getEngineMode() != null ? s.getEngineMode() : "provisioned")+ .elem("AllocatedStorage", s.getAllocatedStorage())+ .elem("Status", s.getStatus())+ .elem("Port", s.getPort());+ if (s.getVpcId() != null) xml.elem("VpcId", s.getVpcId());+ xml.elem("ClusterCreateTime", s.getClusterCreateTime() != null ? s.getClusterCreateTime().toString() : "")+ .elem("MasterUsername", s.getMasterUsername())+ .elem("EngineVersion", s.getEngineVersion());+ if (s.getLicenseModel() != null) xml.elem("LicenseModel", s.getLicenseModel());+ xml.elem("SnapshotType", s.getSnapshotType())+ .elem("PercentProgress", s.getPercentProgress())+ .elem("StorageEncrypted", s.isStorageEncrypted());+ if (s.getKmsKeyId() != null) xml.elem("KmsKeyId", s.getKmsKeyId());+ xml.elem("DBClusterSnapshotArn", s.getDbClusterSnapshotArn());+ if (s.getSourceDbClusterSnapshotArn() != null) xml.elem("SourceDBClusterSnapshotArn", s.getSourceDbClusterSnapshotArn());+ xml.elem("IAMDatabaseAuthenticationEnabled", s.isIamDatabaseAuthenticationEnabled());+ if (s.getDbClusterResourceId() != null) xml.elem("DbClusterResourceId", s.getDbClusterResourceId());+ xml.start("TagList");+ writeTags(xml, s.getTags());+ xml.end("TagList");+ return xml.end("DBClusterSnapshot").build();+ }++ private String dbClusterSnapshotAttributesResultXml(DbClusterSnapshot s) {+ XmlBuilder xml = new XmlBuilder().start("DBClusterSnapshotAttributesResult")+ .elem("DBClusterSnapshotIdentifier", s.getDbClusterSnapshotIdentifier());+ xml.start("DBClusterSnapshotAttributes").start("DBClusterSnapshotAttribute")+ .elem("AttributeName", "restore");+ xml.start("AttributeValues");+ s.getRestoreAccountIds().forEach(id -> xml.elem("AttributeValue", id));+ xml.end("AttributeValues");+ xml.end("DBClusterSnapshotAttribute").end("DBClusterSnapshotAttributes");+ return xml.end("DBClusterSnapshotAttributesResult").build();+ }+private String dbSnapshotAttributesResultXml(io.github.hectorvent.floci.services.rds.model.DbSnapshot s) {XmlBuilder xml = new XmlBuilder().start("DBSnapshotAttributesResult").elem("DBSnapshotIdentifier", s.getDbSnapshotIdentifier());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 94176c3efb..3be88b658d 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@@ -28,6 +28,7 @@ import io.github.hectorvent.floci.services.rds.container.RdsContainerManager;import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;import io.github.hectorvent.floci.services.rds.model.DbCluster;import io.github.hectorvent.floci.services.rds.model.DbClusterParameterGroup;+import io.github.hectorvent.floci.services.rds.model.DbClusterSnapshot;import io.github.hectorvent.floci.services.rds.model.DbEndpoint;import io.github.hectorvent.floci.services.rds.model.DbInstance;import io.github.hectorvent.floci.services.kms.KmsService;@@ -70,6 +71,7 @@ import java.util.Objects;import java.util.Optional;import java.util.Set;import java.util.concurrent.ConcurrentHashMap;+import java.util.function.Predicate;import java.util.regex.Matcher;import java.util.regex.Pattern;@@ -155,6 +157,7 @@ public class RdsService implements Resettable, ResourceProvider {private final StorageBackend<String, DbProxy> proxies;private final StorageBackend<String, DbProxyTargetGroup> proxyTargetGroups;private final StorageBackend<String, DbSnapshot> snapshots;+ private final StorageBackend<String, DbClusterSnapshot> clusterSnapshots;private final StorageBackend<String, GlobalCluster> globalClusters;private final StorageBackend<String, String> snapshotData;private StorageBackend<String, RdsEvent> events = new InMemoryStorage<>();@@ -239,6 +242,8 @@ public class RdsService implements Resettable, ResourceProvider {new TypeReference<Map<String, GlobalCluster>>() {});this.snapshots = storageFactory.create("rds", "rds-snapshots.json",new TypeReference<Map<String, DbSnapshot>>() {});+ this.clusterSnapshots = storageFactory.create("rds", "rds-cluster-snapshots.json",+ new TypeReference<Map<String, DbClusterSnapshot>>() {});this.snapshotData = storageFactory.create("rds", "rds-snapshot-data.json",new TypeReference<Map<String, String>>() {});this.events = storageFactory.create("rds", "rds-events.json",@@ -376,6 +381,7 @@ public class RdsService implements Resettable, ResourceProvider {this.taggingService = taggingService;this.globalClusters = new io.github.hectorvent.floci.core.storage.InMemoryStorage<>();this.snapshots = new io.github.hectorvent.floci.core.storage.InMemoryStorage<>();+ this.clusterSnapshots = new InMemoryStorage<>();this.snapshotData = new io.github.hectorvent.floci.core.storage.InMemoryStorage<>();}@@ -1470,6 +1476,350 @@ public class RdsService implements Resettable, ResourceProvider {return snapshot;}+ // ── DB cluster snapshots ───────────────────────────────────────────────────++ /**+ * Takes a manual snapshot of an available cluster: its description plus a dump of its+ * database, so RestoreDBClusterFromSnapshot can bring the data back into a new cluster.+ */+ public DbClusterSnapshot createDbClusterSnapshot(String snapshotId, String clusterId, Map<String, String> tags) {+ return createDbClusterSnapshot(snapshotId, clusterId, tags, regionResolver.getDefaultRegion());+ }++ public synchronized DbClusterSnapshot createDbClusterSnapshot(String snapshotId, String clusterId,+ Map<String, String> tags, String region) {+ String effectiveRegion = effectiveRegion(region);+ String accountId = currentAccountId();+ if (snapshotId == null || snapshotId.isBlank()) {+ throw new AwsException("InvalidParameterValue", "DBClusterSnapshotIdentifier is required.", 400);+ }+ if (findClusterSnapshotForScope(accountId, effectiveRegion, snapshotId) != null) {+ throw new AwsException("DBClusterSnapshotAlreadyExistsFault",+ "DB cluster snapshot " + snapshotId + " already exists.", 400);+ }+ DbCluster cluster = getDbCluster(clusterId, effectiveRegion);+ if (cluster.getStatus() != null && cluster.getStatus() != DbInstanceStatus.AVAILABLE) {+ throw new AwsException("InvalidDBClusterStateFault",+ "DB cluster " + clusterId + " is not available.", 400);+ }+ if (cluster.getEngine() != DatabaseEngine.POSTGRES) {+ throw new AwsException("InvalidDBClusterStateFault",+ "Operation CreateDBClusterSnapshot is not supported for engine " + cluster.getEngine() + ".", 400);+ }++ DbClusterSnapshot snapshot = clusterSnapshotOf(cluster, snapshotId, effectiveRegion);+ snapshot.setTags(tags != null ? new LinkedHashMap<>(tags) : new LinkedHashMap<>());++ String sqlDump = "";+ if (!config.services().rds().mock()) {+ try {+ sqlDump = containerManager.createPostgresSnapshot(cluster.getContainerId(), cluster.getMasterUsername());+ } catch (Exception e) {+ LOG.warnv(e, "Failed to create snapshot {0} of DB cluster {1}", snapshotId, clusterId);+ throw new AwsException("InvalidDBClusterStateFault", "Failed to create snapshot: " + e.getMessage(), 400);+ }+ }+ snapshotData.put(clusterSnapshotDataKey(effectiveRegion, snapshotId), sqlDump);+ putClusterSnapshotForScope(accountId, effectiveRegion, snapshotId, snapshot);+ LOG.infov("Created DB cluster snapshot {0} of cluster {1}", snapshotId, clusterId);+ return snapshot;+ }++ public Collection<DbClusterSnapshot> describeDbClusterSnapshots(String snapshotId, String clusterId, String snapshotType) {+ return describeDbClusterSnapshots(snapshotId, clusterId, snapshotType, regionResolver.getDefaultRegion());+ }++ public Collection<DbClusterSnapshot> describeDbClusterSnapshots(String snapshotId, String clusterId,+ String snapshotType, String region) {+ String effectiveRegion = effectiveRegion(region);+ String accountId = currentAccountId();+ List<DbClusterSnapshot> matching;+ if (snapshotId != null && !snapshotId.isBlank()) {+ matching = List.of(requireClusterSnapshot(accountId, effectiveRegion, snapshotId));+ } else {+ matching = clusterSnapshots.scan(k -> true).stream()+ .filter(s -> hasRdsResourceIdentity(s.getDbClusterSnapshotArn(), accountId, effectiveRegion,+ "cluster-snapshot", s.getDbClusterSnapshotIdentifier()))+ .toList();+ }+ return matching.stream()+ .filter(s -> clusterId == null || clusterId.isBlank() || clusterId.equals(s.getDbClusterIdentifier()))+ .filter(s -> snapshotType == null || snapshotType.isBlank() || snapshotType.equals(s.getSnapshotType()))+ .toList();+ }++ /** Deletes an available cluster snapshot and its data, answering with the snapshot at status "deleted". */+ public DbClusterSnapshot deleteDbClusterSnapshot(String snapshotId) {+ return deleteDbClusterSnapshot(snapshotId, regionResolver.getDefaultRegion());+ }++ public synchronized DbClusterSnapshot deleteDbClusterSnapshot(String snapshotId, String region) {+ String effectiveRegion = effectiveRegion(region);+ String accountId = currentAccountId();+ DbClusterSnapshot snapshot = requireClusterSnapshot(accountId, effectiveRegion, snapshotId);+ requireClusterSnapshotAvailable(snapshot, "delete");+ snapshotData.delete(clusterSnapshotDataKey(effectiveRegion, snapshotId));+ deleteClusterSnapshotForScope(accountId, effectiveRegion, snapshotId);+ snapshot.setStatus("deleted");+ LOG.infov("Deleted DB cluster snapshot {0}", snapshotId);+ return snapshot;+ }++ /** Copies an available cluster snapshot to a new manual one, recording the source ARN. */+ public DbClusterSnapshot copyDbClusterSnapshot(String sourceSnapshotId, String targetSnapshotId,+ boolean copyTags, Map<String, String> tags) {+ return copyDbClusterSnapshot(sourceSnapshotId, targetSnapshotId, copyTags, tags, regionResolver.getDefaultRegion());+ }++ public synchronized DbClusterSnapshot copyDbClusterSnapshot(String sourceSnapshotId, String targetSnapshotId,+ boolean copyTags, Map<String, String> tags, String region) {+ String effectiveRegion = effectiveRegion(region);+ String accountId = currentAccountId();+ String sourceId = clusterSnapshotIdentifierFromArnOrName(sourceSnapshotId, effectiveRegion);+ DbClusterSnapshot source = requireClusterSnapshot(accountId, effectiveRegion, sourceId);+ requireClusterSnapshotAvailable(source, "copy");+ if (targetSnapshotId == null || targetSnapshotId.isBlank()) {+ throw new AwsException("InvalidParameterValue", "TargetDBClusterSnapshotIdentifier is required.", 400);+ }+ if (findClusterSnapshotForScope(accountId, effectiveRegion, targetSnapshotId) != null) {+ throw new AwsException("DBClusterSnapshotAlreadyExistsFault",+ "DB cluster snapshot " + targetSnapshotId + " already exists.", 400);+ }+ DbClusterSnapshot copy = copyOfClusterSnapshot(source, targetSnapshotId, effectiveRegion);+ copy.setSourceDbClusterSnapshotArn(source.getDbClusterSnapshotArn());+ Map<String, String> copiedTags = new LinkedHashMap<>();+ if (copyTags) {+ copiedTags.putAll(source.getTags());+ }+ if (tags != null) {+ copiedTags.putAll(tags);+ }+ copy.setTags(copiedTags);+ String sqlDump = snapshotData.get(clusterSnapshotDataKey(effectiveRegion, sourceId)).orElse("");+ snapshotData.put(clusterSnapshotDataKey(effectiveRegion, targetSnapshotId), sqlDump);+ putClusterSnapshotForScope(accountId, effectiveRegion, targetSnapshotId, copy);+ LOG.infov("Copied DB cluster snapshot {0} to {1}", sourceId, targetSnapshotId);+ return copy;+ }++ public DbClusterSnapshot describeDbClusterSnapshotAttributes(String snapshotId, String region) {+ return requireClusterSnapshot(currentAccountId(), effectiveRegion(region), snapshotId);+ }++ /** The "restore" attribute, as ModifyDBSnapshotAttribute keeps it for instance snapshots. */+ public synchronized DbClusterSnapshot modifyDbClusterSnapshotAttribute(String snapshotId, String attributeName,+ List<String> valuesToAdd,+ List<String> valuesToRemove, String region) {+ String effectiveRegion = effectiveRegion(region);+ String accountId = currentAccountId();+ DbClusterSnapshot snapshot = requireClusterSnapshot(accountId, effectiveRegion, snapshotId);+ if (!"restore".equals(attributeName)) {+ throw new AwsException("InvalidParameterValue", "AttributeName must be restore.", 400);+ }+ requireClusterSnapshotAvailable(snapshot, "share");+ List<String> updated = new ArrayList<>(snapshot.getRestoreAccountIds());+ if (valuesToAdd != null) {+ valuesToAdd.stream().filter(v -> !updated.contains(v)).forEach(updated::add);+ }+ if (valuesToRemove != null) {+ updated.removeAll(valuesToRemove);+ }+ snapshot.setRestoreAccountIds(updated);+ putClusterSnapshotForScope(accountId, effectiveRegion, snapshotId, snapshot);+ return snapshot;+ }++ /**+ * Creates a new cluster from a cluster snapshot: the snapshot's engine, credentials and+ * database, the request's overrides where AWS allows them, and then the snapshot's data+ * restored into the new cluster's database.+ */+ public DbCluster restoreDbClusterFromSnapshot(String clusterId, String snapshotId, String engine,+ String engineVersion, Integer port, String databaseName,+ String dbSubnetGroupName, String parameterGroupName,+ String availabilityZone, Boolean iamEnabled, String engineMode,+ Map<String, String> tags, String region) {+ String effectiveRegion = effectiveRegion(region);+ String accountId = currentAccountId();+ // SnapshotIdentifier takes the snapshot's name or its ARN (API reference).+ String resolvedSnapshotId = clusterSnapshotIdentifierFromArnOrName(snapshotId, effectiveRegion);+ DbClusterSnapshot snapshot = requireClusterSnapshot(accountId, effectiveRegion, resolvedSnapshotId);+ requireClusterSnapshotAvailable(snapshot, "restore from");+ if (engine == null || engine.isBlank()) {+ throw new AwsException("InvalidParameterValue", "Engine is required.", 400);+ }+ if (resolveEngine(engine) != snapshot.getEngine()) {+ throw new AwsException("InvalidParameterValue",+ "The snapshot's engine is " + snapshot.getEngineIdentifier() + "; cannot restore it as " + engine + ".", 400);+ }+ String sqlDump = snapshotData.get(clusterSnapshotDataKey(effectiveRegion, resolvedSnapshotId))+ .orElseThrow(() -> new AwsException("DBClusterSnapshotNotFoundFault",+ "DB cluster snapshot data for " + resolvedSnapshotId + " not found.", 404));++ DbCluster cluster = createDbCluster(clusterId, engine,+ engineVersion != null && !engineVersion.isBlank() ? engineVersion : snapshot.getEngineVersion(),+ snapshot.getMasterUsername(), snapshot.getMasterPassword(),+ databaseName != null && !databaseName.isBlank() ? databaseName : snapshot.getDatabaseName(),+ iamEnabled != null ? iamEnabled : snapshot.isIamDatabaseAuthenticationEnabled(),+ parameterGroupName, dbSubnetGroupName, availabilityZone, false, effectiveRegion,+ null, null, null, false, null,+ engineMode != null && !engineMode.isBlank() ? engineMode : snapshot.getEngineMode(),+ snapshot.isStorageEncrypted());+ if (tags != null && !tags.isEmpty()) {+ cluster.getTags().putAll(tags);+ putClusterForScope(accountId, effectiveRegion, clusterId, cluster);+ }+ if (!config.services().rds().mock()) {+ try {+ containerManager.restorePostgresSnapshot(cluster.getContainerId(), cluster.getMasterUsername(), sqlDump);+ } catch (Exception e) {+ try {+ deleteDbCluster(clusterId, effectiveRegion);+ } catch (Exception cleanupError) {+ e.addSuppressed(cleanupError);+ }+ AwsException awsEx = new AwsException("InvalidDBClusterSnapshotStateFault",+ "Failed to restore snapshot: " + e.getMessage(), 400);+ awsEx.initCause(e);+ throw awsEx;+ }+ }+ return cluster;+ }++ private DbClusterSnapshot clusterSnapshotOf(DbCluster cluster, String snapshotId, String region) {+ DbClusterSnapshot snapshot = new DbClusterSnapshot();+ snapshot.setDbClusterSnapshotIdentifier(snapshotId);+ snapshot.setDbClusterSnapshotArn(regionResolver.buildArn("rds", region, "cluster-snapshot:" + snapshotId));+ snapshot.setDbClusterIdentifier(cluster.getDbClusterIdentifier());+ snapshot.setSnapshotCreateTime(Instant.now());+ snapshot.setClusterCreateTime(cluster.getCreatedAt());+ snapshot.setEngine(cluster.getEngine());+ snapshot.setEngineIdentifier(cluster.getEngineIdentifier() != null+ ? cluster.getEngineIdentifier() : cluster.getEngine().name().toLowerCase(Locale.ROOT));+ snapshot.setEngineVersion(cluster.getEngineVersion());+ snapshot.setEngineMode(cluster.getEngineMode());+ // Aurora reports 1 GiB for a cluster snapshot: storage is not provisioned per cluster.+ snapshot.setAllocatedStorage(1);+ snapshot.setStatus("available");+ snapshot.setPercentProgress(100);+ snapshot.setPort(cluster.getEndpoint() != null ? cluster.getEndpoint().port() : cluster.getProxyPort());+ snapshot.setVpcId(cluster.getVpcId());+ if (cluster.getAvailabilityZone() != null) {+ snapshot.setAvailabilityZones(new ArrayList<>(List.of(cluster.getAvailabilityZone())));+ }+ snapshot.setMasterUsername(cluster.getMasterUsername());+ snapshot.setMasterPassword(cluster.getMasterPassword());+ snapshot.setDatabaseName(cluster.getDatabaseName());+ snapshot.setLicenseModel("postgresql-license");+ snapshot.setStorageEncrypted(cluster.isStorageEncrypted());+ snapshot.setIamDatabaseAuthenticationEnabled(cluster.isIamDatabaseAuthenticationEnabled());+ snapshot.setDbClusterResourceId(cluster.getDbClusterResourceId());+ return snapshot;+ }++ private DbClusterSnapshot copyOfClusterSnapshot(DbClusterSnapshot source, String targetId, String region) {+ DbClusterSnapshot copy = new DbClusterSnapshot();+ copy.setDbClusterSnapshotIdentifier(targetId);+ copy.setDbClusterSnapshotArn(regionResolver.buildArn("rds", region, "cluster-snapshot:" + targetId));+ copy.setDbClusterIdentifier(source.getDbClusterIdentifier());+ copy.setSnapshotCreateTime(Instant.now());+ copy.setClusterCreateTime(source.getClusterCreateTime());+ copy.setEngine(source.getEngine());+ copy.setEngineIdentifier(source.getEngineIdentifier());+ copy.setEngineVersion(source.getEngineVersion());+ copy.setEngineMode(source.getEngineMode());+ copy.setAllocatedStorage(source.getAllocatedStorage());+ copy.setStatus("available");+ copy.setPercentProgress(100);+ copy.setPort(source.getPort());+ copy.setVpcId(source.getVpcId());+ copy.setAvailabilityZones(new ArrayList<>(source.getAvailabilityZones()));+ copy.setMasterUsername(source.getMasterUsername());+ copy.setMasterPassword(source.getMasterPassword());+ copy.setDatabaseName(source.getDatabaseName());+ copy.setLicenseModel(source.getLicenseModel());+ copy.setStorageEncrypted(source.isStorageEncrypted());+ copy.setKmsKeyId(source.getKmsKeyId());+ copy.setIamDatabaseAuthenticationEnabled(source.isIamDatabaseAuthenticationEnabled());+ copy.setDbClusterResourceId(source.getDbClusterResourceId());+ return copy;+ }++ private DbClusterSnapshot requireClusterSnapshot(String accountId, String region, String snapshotId) {+ if (snapshotId == null || snapshotId.isBlank()) {+ throw new AwsException("InvalidParameterValue", "DBClusterSnapshotIdentifier is required.", 400);+ }+ return Optional.ofNullable(findClusterSnapshotForScope(accountId, region, snapshotId))+ .orElseThrow(() -> new AwsException("DBClusterSnapshotNotFoundFault",+ "DBClusterSnapshot " + snapshotId + " not found.", 404));+ }++ private static void requireClusterSnapshotAvailable(DbClusterSnapshot snapshot, String operation) {+ if (!"available".equals(snapshot.getStatus())) {+ throw new AwsException("InvalidDBClusterSnapshotStateFault",+ "Cannot " + operation + " DB cluster snapshot " + snapshot.getDbClusterSnapshotIdentifier()+ + " while its status is " + snapshot.getStatus() + ".", 400);+ }+ }++ private String clusterSnapshotIdentifierFromArnOrName(String source, String region) {+ if (source == null || source.isBlank()) {+ throw new AwsException("InvalidParameterValue", "A DB cluster snapshot identifier is required.", 400);+ }+ if (!source.startsWith("arn:")) {+ return source;+ }+ AwsArnUtils.Arn arn;+ try {+ arn = AwsArnUtils.parse(source);+ } catch (IllegalArgumentException malformed) {+ throw new AwsException("InvalidParameterValue", "Invalid snapshot identifier: " + source, 400);+ }+ String resource = arn.resource();+ if (!"rds".equals(arn.service()) || !resource.startsWith("cluster-snapshot:")) {+ throw new AwsException("InvalidParameterValue", "Invalid snapshot identifier: " + source, 400);+ }+ if (!region.equals(arn.region())) {+ throw new AwsException("InvalidParameterValue",+ "Cross-region snapshot copy is not supported: " + source, 400);+ }+ return resource.substring("cluster-snapshot:".length());+ }++ /** Cluster snapshot dumps share the snapshot data store with instance snapshots under their own prefix. */+ private String clusterSnapshotDataKey(String region, String snapshotId) {+ return dbResourceKey(region, "cluster-snapshot:" + snapshotId);+ }++ private synchronized DbClusterSnapshot findClusterSnapshotForScope(String accountId, String region, String snapshotId) {+ String key = dbResourceKey(region, snapshotId);+ Predicate<DbClusterSnapshot> owner = snapshot -> hasRdsResourceIdentity(+ snapshot.getDbClusterSnapshotArn(), accountId, region, "cluster-snapshot", snapshotId);+ if (clusterSnapshots instanceof AccountAwareStorageBackend<DbClusterSnapshot> aware) {+ return aware.getForAccount(accountId, key).filter(owner).orElse(null);+ }+ return clusterSnapshots.get(key).filter(owner).orElse(null);+ }++ private void putClusterSnapshotForScope(String accountId, String region, String snapshotId, DbClusterSnapshot snapshot) {+ String key = dbResourceKey(region, snapshotId);+ if (clusterSnapshots instanceof AccountAwareStorageBackend<DbClusterSnapshot> aware) {+ aware.putForAccount(accountId, key, snapshot);+ } else {+ clusterSnapshots.put(key, snapshot);+ }+ }++ private void deleteClusterSnapshotForScope(String accountId, String region, String snapshotId) {+ String key = dbResourceKey(region, snapshotId);+ if (clusterSnapshots instanceof AccountAwareStorageBackend<DbClusterSnapshot> aware) {+ aware.deleteForAccount(accountId, key);+ } else {+ clusterSnapshots.delete(key);+ }+ }+public Map<String, String> listTagsForResource(String resourceName) {return listTagsForResource(resourceName, resourceRegionOrDefault(resourceName));}@@ -1575,6 +1925,13 @@ public class RdsService implements Resettable, ResourceProvider {currentAccountId(), effectiveRegion, resourceId, group);});}+ case "cluster-snapshot" -> {+ DbClusterSnapshot snapshot = requireClusterSnapshot(currentAccountId(), effectiveRegion, resourceId);+ yield new TagHandle(snapshot.getTags(), updated -> {+ snapshot.setTags(updated);+ putClusterSnapshotForScope(currentAccountId(), effectiveRegion, resourceId, snapshot);+ });+ }case "snapshot" -> {DbSnapshot snapshot = Optional.ofNullable(findSnapshotForScope(currentAccountId(), effectiveRegion, resourceId))diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/DbClusterSnapshot.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbClusterSnapshot.javanew file mode 100644index 0000000000..4ccd8eb2ce--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbClusterSnapshot.java@@ -0,0 +1,125 @@+package io.github.hectorvent.floci.services.rds.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/**+ * A manual DB cluster snapshot, the {@code DBClusterSnapshot} structure of the RDS API. The+ * cluster's data is kept beside it in the snapshot data store, keyed by the snapshot id.+ */+@RegisterForReflection+public class DbClusterSnapshot {+ private String dbClusterSnapshotIdentifier;+ private String dbClusterSnapshotArn;+ private String dbClusterIdentifier;+ private Instant snapshotCreateTime;+ private Instant clusterCreateTime;+ private DatabaseEngine engine;+ private String engineIdentifier;+ private String engineVersion;+ private String engineMode;+ private int allocatedStorage;+ private String status;+ private int port;+ private String vpcId;+ private List<String> availabilityZones = new ArrayList<>();+ private String masterUsername;+ private String masterPassword;+ private String databaseName;+ private String licenseModel;+ private String snapshotType = "manual";+ private int percentProgress;+ private boolean storageEncrypted;+ private String kmsKeyId;+ private String sourceDbClusterSnapshotArn;+ private boolean iamDatabaseAuthenticationEnabled;+ private String dbClusterResourceId;+ private Map<String, String> tags = new LinkedHashMap<>();+ private List<String> restoreAccountIds = new ArrayList<>();++ public String getDbClusterSnapshotIdentifier() { return dbClusterSnapshotIdentifier; }+ public void setDbClusterSnapshotIdentifier(String v) { this.dbClusterSnapshotIdentifier = v; }++ public String getDbClusterSnapshotArn() { return dbClusterSnapshotArn; }+ public void setDbClusterSnapshotArn(String v) { this.dbClusterSnapshotArn = v; }++ public String getDbClusterIdentifier() { return dbClusterIdentifier; }+ public void setDbClusterIdentifier(String v) { this.dbClusterIdentifier = v; }++ public Instant getSnapshotCreateTime() { return snapshotCreateTime; }+ public void setSnapshotCreateTime(Instant v) { this.snapshotCreateTime = v; }++ public Instant getClusterCreateTime() { return clusterCreateTime; }+ public void setClusterCreateTime(Instant v) { this.clusterCreateTime = v; }++ public DatabaseEngine getEngine() { return engine; }+ public void setEngine(DatabaseEngine v) { this.engine = v; }++ public String getEngineIdentifier() { return engineIdentifier; }+ public void setEngineIdentifier(String v) { this.engineIdentifier = v; }++ public String getEngineVersion() { return engineVersion; }+ public void setEngineVersion(String v) { this.engineVersion = v; }++ public String getEngineMode() { return engineMode; }+ public void setEngineMode(String v) { this.engineMode = v; }++ public int getAllocatedStorage() { return allocatedStorage; }+ public void setAllocatedStorage(int v) { this.allocatedStorage = v; }++ public String getStatus() { return status; }+ public void setStatus(String v) { this.status = v; }++ public int getPort() { return port; }+ public void setPort(int v) { this.port = v; }++ public String getVpcId() { return vpcId; }+ public void setVpcId(String v) { this.vpcId = v; }++ public List<String> getAvailabilityZones() { return availabilityZones; }+ public void setAvailabilityZones(List<String> v) { this.availabilityZones = v; }++ public String getMasterUsername() { return masterUsername; }+ public void setMasterUsername(String v) { this.masterUsername = v; }++ public String getMasterPassword() { return masterPassword; }+ public void setMasterPassword(String v) { this.masterPassword = v; }++ public String getDatabaseName() { return databaseName; }+ public void setDatabaseName(String v) { this.databaseName = v; }++ public String getLicenseModel() { return licenseModel; }+ public void setLicenseModel(String v) { this.licenseModel = v; }++ public String getSnapshotType() { return snapshotType; }+ public void setSnapshotType(String v) { this.snapshotType = v; }++ public int getPercentProgress() { return percentProgress; }+ public void setPercentProgress(int v) { this.percentProgress = v; }++ public boolean isStorageEncrypted() { return storageEncrypted; }+ public void setStorageEncrypted(boolean v) { this.storageEncrypted = v; }++ public String getKmsKeyId() { return kmsKeyId; }+ public void setKmsKeyId(String v) { this.kmsKeyId = v; }++ public String getSourceDbClusterSnapshotArn() { return sourceDbClusterSnapshotArn; }+ public void setSourceDbClusterSnapshotArn(String v) { this.sourceDbClusterSnapshotArn = v; }++ public boolean isIamDatabaseAuthenticationEnabled() { return iamDatabaseAuthenticationEnabled; }+ public void setIamDatabaseAuthenticationEnabled(boolean v) { this.iamDatabaseAuthenticationEnabled = v; }++ public String getDbClusterResourceId() { return dbClusterResourceId; }+ public void setDbClusterResourceId(String v) { this.dbClusterResourceId = v; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> v) { this.tags = v; }++ public List<String> getRestoreAccountIds() { return restoreAccountIds; }+ public void setRestoreAccountIds(List<String> v) { this.restoreAccountIds = v; }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsClusterSnapshotLifecycleIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsClusterSnapshotLifecycleIntegrationTest.javanew file mode 100644index 0000000000..289351873e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsClusterSnapshotLifecycleIntegrationTest.java@@ -0,0 +1,207 @@+package io.github.hectorvent.floci.services.rds;++import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.model.Frame;+import com.github.dockerjava.api.model.StreamType;+import com.github.dockerjava.core.command.ExecStartResultCallback;+import io.github.hectorvent.floci.services.rds.model.DbCluster;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.specification.RequestSpecification;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Tag;+import org.junit.jupiter.api.Test;++import java.io.ByteArrayOutputStream;+import java.io.Closeable;+import java.io.IOException;+import java.nio.charset.StandardCharsets;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.TimeUnit;++import static io.restassured.RestAssured.given;+import static io.restassured.http.ContentType.URLENC;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.junit.jupiter.api.Assumptions.assumeTrue;++/**+ * The cluster snapshot lifecycle against real Postgres containers: a row written before the+ * snapshot comes back from a cluster restored from a copy of that snapshot, the source snapshot+ * can be deleted without touching the copy, and each refusal carries the AWS error.+ */+@QuarkusTest+@Tag("docker")+class RdsClusterSnapshotLifecycleIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260921/us-east-1/rds/aws4_request, "+ + "SignedHeaders=content-type;host, Signature=test";++ @Inject+ DockerClient dockerClient;++ @Inject+ RdsService rdsService;++ @BeforeEach+ void checkDocker() {+ try {+ dockerClient.pingCmd().exec();+ } catch (Exception e) {+ assumeTrue(false, "Docker is not available: " + e.getMessage());+ }+ }++ private static RequestSpecification query(String action) {+ return given().header("Authorization", AUTH)+ .contentType(URLENC)+ .formParam("Action", action)+ .formParam("Version", "2014-10-31");+ }++ @Test+ void clusterSnapshotRoundTripsTheClustersDataIntoARestoredCluster() throws Exception {+ String suffix = Long.toString(System.nanoTime(), 36);+ String cluster = "csnap-src-" + suffix;+ String snapshot = "csnap-" + suffix;+ String copy = "csnap-copy-" + suffix;+ String restored = "csnap-restored-" + suffix;++ query("CreateDBCluster")+ .formParam("DBClusterIdentifier", cluster)+ .formParam("Engine", "aurora-postgresql")+ .formParam("EngineVersion", "16.3")+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .formParam("DatabaseName", "appdb")+ .when().post("/").then().statusCode(200);+ waitForCluster(cluster);+ DbCluster source = rdsService.getDbCluster(cluster);+ psql(source.getContainerId(), "CREATE TABLE marker(v text); INSERT INTO marker VALUES ('cluster-row');");++ query("CreateDBClusterSnapshot")+ .formParam("DBClusterSnapshotIdentifier", snapshot)+ .formParam("DBClusterIdentifier", cluster)+ .formParam("Tags.Tag.1.Key", "owner")+ .formParam("Tags.Tag.1.Value", "platform")+ .when().post("/").then().statusCode(200)+ .body(containsString("<CreateDBClusterSnapshotResult>"))+ .body(containsString("<Engine>aurora-postgresql</Engine>"))+ .body(containsString("<Status>available</Status>"))+ .body(containsString("<SnapshotType>manual</SnapshotType>"))+ .body(containsString("<PercentProgress>100</PercentProgress>"))+ .body(containsString(":cluster-snapshot:" + snapshot + "</DBClusterSnapshotArn>"));++ query("DescribeDBClusterSnapshots")+ .formParam("DBClusterIdentifier", cluster)+ .when().post("/").then().statusCode(200)+ .body(containsString("<DBClusterSnapshotIdentifier>" + snapshot + "</DBClusterSnapshotIdentifier>"));++ String sourceArn = "arn:aws:rds:us-east-1:000000000000:cluster-snapshot:" + snapshot;+ query("CopyDBClusterSnapshot")+ .formParam("SourceDBClusterSnapshotIdentifier", sourceArn)+ .formParam("TargetDBClusterSnapshotIdentifier", copy)+ .formParam("CopyTags", "true")+ .when().post("/").then().statusCode(200)+ .body(containsString("<SourceDBClusterSnapshotArn>" + sourceArn + "</SourceDBClusterSnapshotArn>"))+ .body(containsString("<Value>platform</Value>"));++ query("ModifyDBClusterSnapshotAttribute")+ .formParam("DBClusterSnapshotIdentifier", copy)+ .formParam("AttributeName", "restore")+ .formParam("ValuesToAdd.member.1", "all")+ .when().post("/").then().statusCode(200)+ .body(containsString("<AttributeValue>all</AttributeValue>"));++ query("DeleteDBClusterSnapshot")+ .formParam("DBClusterSnapshotIdentifier", snapshot)+ .when().post("/").then().statusCode(200)+ .body(containsString("<Status>deleted</Status>"));+ query("DescribeDBClusterSnapshots")+ .formParam("DBClusterSnapshotIdentifier", snapshot)+ .when().post("/").then().statusCode(404)+ .body(containsString("<Code>DBClusterSnapshotNotFoundFault</Code>"));++ // Restore by ARN, the form aws_rds_cluster's snapshot_identifier is commonly given.+ query("RestoreDBClusterFromSnapshot")+ .formParam("DBClusterIdentifier", restored)+ .formParam("SnapshotIdentifier", "arn:aws:rds:us-east-1:000000000000:cluster-snapshot:" + copy)+ .formParam("Engine", "aurora-postgresql")+ .when().post("/").then().statusCode(200)+ .body(containsString("<RestoreDBClusterFromSnapshotResult>"))+ .body(containsString("<DBClusterIdentifier>" + restored + "</DBClusterIdentifier>"));+ waitForCluster(restored);+ DbCluster restoredCluster = rdsService.getDbCluster(restored);+ assertTrue(psql(restoredCluster.getContainerId(), "SELECT v FROM marker;").contains("cluster-row"),+ "the row written before the cluster snapshot must come back from the copy");++ query("DeleteDBClusterSnapshot").formParam("DBClusterSnapshotIdentifier", copy)+ .when().post("/").then().statusCode(200);+ query("DeleteDBCluster").formParam("DBClusterIdentifier", restored).formParam("SkipFinalSnapshot", "true")+ .when().post("/").then().statusCode(200);+ query("DeleteDBCluster").formParam("DBClusterIdentifier", cluster).formParam("SkipFinalSnapshot", "true")+ .when().post("/").then().statusCode(200);+ }++ private void waitForCluster(String clusterId) throws Exception {+ for (int i = 0; i < 60; i++) {+ String status = query("DescribeDBClusters")+ .formParam("DBClusterIdentifier", clusterId)+ .when().post("/").then()+ .extract().xmlPath().getString(+ "DescribeDBClustersResponse.DescribeDBClustersResult.DBClusters.DBCluster.Status");+ if ("available".equals(status)) {+ return;+ }+ Thread.sleep(1000);+ }+ throw new RuntimeException("DB cluster " + clusterId + " did not become available.");+ }++ private String psql(String containerId, String sql) throws Exception {+ String[] command = {"psql", "-U", "admin", "-d", "appdb", "-tAc", sql};+ String execId = dockerClient.execCreateCmd(containerId)+ .withCmd(command)+ .withAttachStdout(true)+ .withAttachStderr(true)+ .exec()+ .getId();+ ByteArrayOutputStream output = new ByteArrayOutputStream();+ ByteArrayOutputStream errors = new ByteArrayOutputStream();+ CountDownLatch latch = new CountDownLatch(1);+ Closeable callback = dockerClient.execStartCmd(execId).exec(new ExecStartResultCallback() {+ @Override+ public void onNext(Frame frame) {+ try {+ if (frame.getStreamType() == StreamType.STDOUT) {+ output.write(frame.getPayload());+ } else if (frame.getStreamType() == StreamType.STDERR) {+ errors.write(frame.getPayload());+ }+ } catch (IOException e) {+ throw new IllegalStateException("Failed to capture psql output", e);+ }+ }++ @Override+ public void onComplete() {+ latch.countDown();+ }++ @Override+ public void onError(Throwable throwable) {+ latch.countDown();+ }+ });+ try {+ assertTrue(latch.await(30, TimeUnit.SECONDS), "Timed out running psql");+ long exitCode = dockerClient.inspectExecCmd(execId).exec().getExitCodeLong();+ assertTrue(exitCode == 0, "psql failed with exit code " + exitCode + ": " + errors.toString(StandardCharsets.UTF_8));+ return output.toString(StandardCharsets.UTF_8);+ } finally {+ callback.close();+ }+ }+}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 692d47fb28..173fb73317 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@@ -4,6 +4,7 @@ import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;import io.github.hectorvent.floci.services.rds.model.DbCluster;+import io.github.hectorvent.floci.services.rds.model.DbClusterSnapshot;import io.github.hectorvent.floci.services.rds.model.DbClusterParameterGroup;import io.github.hectorvent.floci.services.docdb.DocDbQueryHandler;import io.github.hectorvent.floci.services.neptune.NeptuneQueryHandler;@@ -1951,6 +1952,55 @@ class RdsQueryHandlerTest {verify(service, never()).startDbCluster(any(), any());}+ @Test+ void clusterSnapshotActions_dispatchAndRenderTheClusterSnapshot() {+ DbClusterSnapshot snapshot = new DbClusterSnapshot();+ snapshot.setDbClusterSnapshotIdentifier("csnap");+ snapshot.setDbClusterIdentifier("aurora");+ snapshot.setEngineIdentifier("aurora-postgresql");+ snapshot.setStatus("available");+ snapshot.setPercentProgress(100);+ snapshot.setDbClusterSnapshotArn("arn:aws:rds:us-east-1:000000000000:cluster-snapshot:csnap");+ snapshot.setAvailabilityZones(List.of("us-east-1a"));+ snapshot.setRestoreAccountIds(List.of("all"));+ when(service.createDbClusterSnapshot(eq("csnap"), eq("aurora"), eq(Map.of()), isNull())).thenReturn(snapshot);+ MultivaluedMap<String, String> create = params();+ create.add("DBClusterSnapshotIdentifier", "csnap");+ create.add("DBClusterIdentifier", "aurora");+ Response created = handler.handle("CreateDBClusterSnapshot", create);+ assertEquals(200, created.getStatus());+ String body = (String) created.getEntity();+ assertTrue(body.contains("<CreateDBClusterSnapshotResult>"));+ assertTrue(body.contains("<DBClusterSnapshot>"));+ assertTrue(body.contains("<AvailabilityZone>us-east-1a</AvailabilityZone>"));+ assertTrue(body.contains("<SnapshotType>manual</SnapshotType>"));+ assertTrue(body.contains("<PercentProgress>100</PercentProgress>"));+ assertTrue(body.contains("<DBClusterSnapshotArn>arn:aws:rds:us-east-1:000000000000:cluster-snapshot:csnap</DBClusterSnapshotArn>"));++ when(service.describeDbClusterSnapshots(isNull(), eq("aurora"), isNull(), isNull())).thenReturn(List.of(snapshot));+ MultivaluedMap<String, String> describe = params();+ describe.add("DBClusterIdentifier", "aurora");+ String listBody = (String) handler.handle("DescribeDBClusterSnapshots", describe).getEntity();+ assertTrue(listBody.contains("<DBClusterSnapshots><DBClusterSnapshot>"));++ when(service.describeDbClusterSnapshotAttributes(eq("csnap"), isNull())).thenReturn(snapshot);+ MultivaluedMap<String, String> attrs = params();+ attrs.add("DBClusterSnapshotIdentifier", "csnap");+ String attrBody = (String) handler.handle("DescribeDBClusterSnapshotAttributes", attrs).getEntity();+ assertTrue(attrBody.contains("<DBClusterSnapshotAttributesResult>"));+ assertTrue(attrBody.contains("<AttributeName>restore</AttributeName>"));+ assertTrue(attrBody.contains("<AttributeValue>all</AttributeValue>"));++ assertEquals(400, handler.handle("CreateDBClusterSnapshot", params()).getStatus());+ assertEquals(400, handler.handle("DeleteDBClusterSnapshot", params()).getStatus());+ MultivaluedMap<String, String> restore = params();+ restore.add("DBClusterIdentifier", "restored");+ restore.add("SnapshotIdentifier", "csnap");+ Response missingEngine = handler.handle("RestoreDBClusterFromSnapshot", restore);+ assertEquals(400, missingEngine.getStatus());+ assertTrue(((String) missingEngine.getEntity()).contains("Engine is required."));+ }+@Testvoid describeDbSnapshotAttributes_returnsRestoreAttribute() {io.github.hectorvent.floci.services.rds.model.DbSnapshot snapshot = new io.github.hectorvent.floci.services.rds.model.DbSnapshot();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 d41be5756d..af23f175ad 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@@ -14,6 +14,7 @@ import io.github.hectorvent.floci.services.ec2.model.Vpc;import io.github.hectorvent.floci.services.ec2.model.VpcIpv6CidrBlockAssociation;import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;import io.github.hectorvent.floci.services.rds.model.DbCluster;+import io.github.hectorvent.floci.services.rds.model.DbClusterSnapshot;import io.github.hectorvent.floci.services.rds.model.DbClusterParameterGroup;import io.github.hectorvent.floci.services.rds.container.RdsContainerHandle;import io.github.hectorvent.floci.services.rds.container.RdsContainerManager;@@ -3096,6 +3097,102 @@ class RdsServiceTest {rdsService.listTagsForResource(snapshot.getDbSnapshotArn()));}+ private DbClusterSnapshot clusterSnapshotOfNewCluster(String snapshotId) {+ rdsService.createDbCluster("aurora-cluster", "aurora-postgresql", "16.3",+ "admin", "password", "dbname", false, null);+ when(containerManager.createPostgresSnapshot(any(), eq("admin"))).thenReturn("CLUSTER_DUMP");+ return rdsService.createDbClusterSnapshot(snapshotId, "aurora-cluster", Map.of("owner", "platform"));+ }++ @Test+ void createDbClusterSnapshotRecordsTheClusterAndItsData() {+ DbClusterSnapshot snapshot = clusterSnapshotOfNewCluster("csnap");++ assertEquals("csnap", snapshot.getDbClusterSnapshotIdentifier());+ assertEquals("aurora-cluster", snapshot.getDbClusterIdentifier());+ assertEquals("available", snapshot.getStatus());+ assertEquals("manual", snapshot.getSnapshotType());+ assertEquals(100, snapshot.getPercentProgress());+ assertEquals("aurora-postgresql", snapshot.getEngineIdentifier());+ assertEquals("16.3", snapshot.getEngineVersion());+ assertEquals("admin", snapshot.getMasterUsername());+ assertEquals("dbname", snapshot.getDatabaseName());+ assertEquals("arn:aws:rds:us-east-1:123456789012:cluster-snapshot:csnap", snapshot.getDbClusterSnapshotArn());+ assertEquals(Map.of("owner", "platform"), snapshot.getTags());+ assertEquals(Map.of("owner", "platform"), rdsService.listTagsForResource(snapshot.getDbClusterSnapshotArn()));+ verify(containerManager).createPostgresSnapshot(any(), eq("admin"));++ assertEquals(1, rdsService.describeDbClusterSnapshots(null, null, null).size());+ assertEquals(1, rdsService.describeDbClusterSnapshots(null, "aurora-cluster", "manual").size());+ assertTrue(rdsService.describeDbClusterSnapshots(null, "other-cluster", null).isEmpty());+ assertTrue(rdsService.describeDbClusterSnapshots(null, null, "automated").isEmpty());++ assertEquals("DBClusterSnapshotAlreadyExistsFault", assertThrows(AwsException.class,+ () -> rdsService.createDbClusterSnapshot("csnap", "aurora-cluster", null)).getErrorCode());+ assertEquals("DBClusterNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.createDbClusterSnapshot("other", "absent-cluster", null)).getErrorCode());+ assertEquals("DBClusterSnapshotNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.describeDbClusterSnapshots("absent", null, null)).getErrorCode());+ }++ @Test+ void clusterSnapshotCanBeCopiedRestoredAndDeleted() {+ DbClusterSnapshot source = clusterSnapshotOfNewCluster("csnap");++ DbClusterSnapshot copy =+ rdsService.copyDbClusterSnapshot(source.getDbClusterSnapshotArn(), "csnap-copy", true, Map.of("stage", "test"));+ assertEquals("csnap-copy", copy.getDbClusterSnapshotIdentifier());+ assertEquals(source.getDbClusterSnapshotArn(), copy.getSourceDbClusterSnapshotArn());+ assertEquals(Map.of("owner", "platform", "stage", "test"), copy.getTags());+ assertEquals("DBClusterSnapshotAlreadyExistsFault", assertThrows(AwsException.class,+ () -> rdsService.copyDbClusterSnapshot("csnap", "csnap-copy", false, null)).getErrorCode());++ // SnapshotIdentifier takes the ARN as well as the name, as aws_rds_cluster commonly passes it.+ DbCluster restored = rdsService.restoreDbClusterFromSnapshot("restored-cluster", copy.getDbClusterSnapshotArn(),+ "aurora-postgresql", null, null, null, null, null, null, null, null, Map.of("env", "restore"), "us-east-1");+ assertEquals("restored-cluster", restored.getDbClusterIdentifier());+ assertEquals("admin", restored.getMasterUsername());+ assertEquals("dbname", restored.getDatabaseName());+ assertEquals("16.3", restored.getEngineVersion());+ assertEquals("restore", restored.getTags().get("env"));+ verify(containerManager).restorePostgresSnapshot(any(), eq("admin"), eq("CLUSTER_DUMP"));++ assertEquals("InvalidParameterValue", assertThrows(AwsException.class,+ () -> rdsService.restoreDbClusterFromSnapshot("mysql-cluster", "csnap", "aurora-mysql",+ null, null, null, null, null, null, null, null, null, "us-east-1")).getErrorCode());+ assertEquals("DBClusterSnapshotNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.restoreDbClusterFromSnapshot("other-cluster",+ "arn:aws:rds:us-east-1:123456789012:cluster-snapshot:absent", "aurora-postgresql",+ null, null, null, null, null, null, null, null, null, "us-east-1")).getErrorCode());++ DbClusterSnapshot deleted = rdsService.deleteDbClusterSnapshot("csnap");+ assertEquals("deleted", deleted.getStatus());+ assertEquals("DBClusterSnapshotNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.deleteDbClusterSnapshot("csnap")).getErrorCode());+ assertEquals(1, rdsService.describeDbClusterSnapshots(null, null, null).size());++ source.setStatus("creating");+ copy.setStatus("copying");+ assertEquals("InvalidDBClusterSnapshotStateFault", assertThrows(AwsException.class,+ () -> rdsService.deleteDbClusterSnapshot("csnap-copy")).getErrorCode());+ }++ @Test+ void clusterSnapshotRestoreAttributeIsSharedLikeAnInstanceSnapshots() {+ clusterSnapshotOfNewCluster("csnap");++ DbClusterSnapshot shared = rdsService.modifyDbClusterSnapshotAttribute(+ "csnap", "restore", List.of("111122223333", "all"), null, "us-east-1");+ assertEquals(List.of("111122223333", "all"), shared.getRestoreAccountIds());+ DbClusterSnapshot narrowed = rdsService.modifyDbClusterSnapshotAttribute(+ "csnap", "restore", null, List.of("all"), "us-east-1");+ assertEquals(List.of("111122223333"), narrowed.getRestoreAccountIds());+ assertEquals(List.of("111122223333"),+ rdsService.describeDbClusterSnapshotAttributes("csnap", "us-east-1").getRestoreAccountIds());+ assertEquals("InvalidParameterValue", assertThrows(AwsException.class,+ () -> rdsService.modifyDbClusterSnapshotAttribute("csnap", "engine", List.of("x"), null, "us-east-1")).getErrorCode());+ }+@Testvoid dbSnapshotTagsRoundTripAndMutateByArn() {rdsService.createDbInstance("mydb", "postgres", "13",