Light, fluffy, and always free - The AWS Local Emulator alternative
fix(rds): enhance DB cluster handling by recording createOnly properties and updating rollback logic (#3636)
Matheus Andréb2b43dfb3cb3
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/RdsCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/RdsCfnProvisioner.javaindex 1d3fcea017..dbb3a2cecc 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/RdsCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/RdsCfnProvisioner.java@@ -1,6 +1,8 @@package io.github.hectorvent.floci.services.cloudformation.provisioners;import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;import io.github.hectorvent.floci.services.cloudformation.model.StackResource;@@ -17,6 +19,7 @@ import org.jboss.logging.Logger;import java.util.ArrayList;import java.util.HashMap;+import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Objects;@@ -41,6 +44,45 @@ import java.util.Set;public class RdsCfnProvisioner implements CfnResourceProvisioner {private static final Logger LOG = Logger.getLogger(RdsCfnProvisioner.class);+ private static final ObjectMapper MAPPER = new ObjectMapper();++ /**+ * The createOnlyProperties of {@code AWS::RDS::DBCluster} that nothing on the cluster on file+ * records. {@code DBClusterIdentifier} is the physical id, {@code EngineMode},+ * {@code StorageEncrypted} and {@code DatabaseName} are fields of the cluster, but Floci does not+ * emulate a KMS key, public access, a subnet group placement chosen by the template or a+ * restore source on a cluster, so a change to one of these can only be seen against what the+ * template said last time. The values the last successful provision resolved are kept on the+ * resource under {@link #DB_CLUSTER_CREATE_ONLY_ATTR}, which is how CloudFormation decides too:+ * on the template's change, not on the live entity.+ */+ static final List<String> DB_CLUSTER_RECORDED_CREATE_ONLY = List.of(+ "ClusterScalabilityType", "DBSubnetGroupName", "DBSystemId", "KmsKeyId",+ "PubliclyAccessible", "RestoreToTime", "RestoreType", "SnapshotIdentifier",+ "SourceDBClusterIdentifier", "SourceDbClusterResourceId", "SourceRegion",+ "UseLatestRestorableTime");+ /**+ * The booleans among {@link #DB_CLUSTER_RECORDED_CREATE_ONLY}, recorded as {@code true}/+ * {@code false} however the template spelled them. {@code UseLatestRestorableTime} defaults to+ * false, so an absent one is recorded as false. {@code PubliclyAccessible} has no fixed default+ * (AWS documents true without a subnet group or with the default one, false with a custom one),+ * so an absent one is recorded as absent and a template that later spells out either value is a+ * change: the cluster may have been created public.+ */+ private static final Set<String> DB_CLUSTER_BOOLEAN_CREATE_ONLY =+ Set.of("PubliclyAccessible", "UseLatestRestorableTime");+ private static final Set<String> DB_CLUSTER_DEFAULT_FALSE_CREATE_ONLY = Set.of("UseLatestRestorableTime");+ /**+ * The recorded createOnly values of a DB cluster resource, a JSON object keyed by property.+ * Internal, like the other {@code __Floci} attributes. A resource provisioned before these were+ * recorded has none, and its first update records them without replacing anything.+ */+ static final String DB_CLUSTER_CREATE_ONLY_ATTR = "__FlociDbClusterCreateOnly";+ /**+ * The record an update overwrote, kept until the update commits so a rollback puts it back+ * beside the prior cluster; an empty value means there was no record before.+ */+ static final String DB_CLUSTER_CREATE_ONLY_PRIOR_ATTR = "__FlociDbClusterCreateOnlyPrior";private final RdsService rdsService;private final CfnDynamicReferences dynamicReferences;@@ -113,23 +155,35 @@ public class RdsCfnProvisioner implements CfnResourceProvisioner {@Overridepublic UpdateCleanupResult completeUpdate(StackResource resource) {+ resource.getAttributes().remove(DB_CLUSTER_CREATE_ONLY_PRIOR_ATTR);return ReplacementCleanup.complete(resource, this::delete);}@Overridepublic void clearUpdate(StackResource resource) {+ resource.getAttributes().remove(DB_CLUSTER_CREATE_ONLY_PRIOR_ATTR);ReplacementCleanup.clear(resource);}/*** A replacement is undone through the cleanup record: the resource names the displaced cluster- * again and the replacement is deleted. Without a record the update was in place, and putting- * that back needs a snapshot this provisioner does not keep, so the engine keeps reporting it- * as not rolled back, as before.+ * again and the replacement is deleted. The createOnly record follows the cluster back, since+ * {@link ReplacementCleanup} leaves {@code __Floci} attributes alone. Without a record the+ * update was in place, and putting that back needs a snapshot this provisioner does not keep,+ * so the engine keeps reporting it as not rolled back, as before.*/@Overridepublic boolean rollbackUpdate(StackResource resource) {- return ReplacementCleanup.rollback(resource, this::delete);+ boolean replaced = ReplacementCleanup.rollback(resource, this::delete);+ String priorRecord = resource.getAttributes().remove(DB_CLUSTER_CREATE_ONLY_PRIOR_ATTR);+ if (priorRecord != null) {+ if (priorRecord.isEmpty()) {+ resource.getAttributes().remove(DB_CLUSTER_CREATE_ONLY_ATTR);+ } else {+ resource.getAttributes().put(DB_CLUSTER_CREATE_ONLY_ATTR, priorRecord);+ }+ }+ return replaced;}private void provisionDbSubnetGroup(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,@@ -292,14 +346,16 @@ public class RdsCfnProvisioner implements CfnResourceProvisioner {}/**- * A DB cluster follows CloudFormation's replacement lifecycle. {@code DBClusterIdentifier},- * {@code EngineMode} and {@code StorageEncrypted} are createOnlyProperties in the- * {@code AWS::RDS::DBCluster} schema, so a change to any of them creates the replacement under- * a distinct physical id first and leaves the displaced cluster standing: it is deleted once- * the stack update commits ({@link #completeUpdate}), or the resource is pointed back at it and- * the replacement is removed when a later resource fails the update ({@link #rollbackUpdate}).- * A cluster the template names explicitly has no distinct id to move to, which is the update- * CloudFormation refuses for a custom-named resource, so it is refused here the same way.+ * A DB cluster follows CloudFormation's replacement lifecycle. A change to any of the+ * createOnlyProperties in the {@code AWS::RDS::DBCluster} schema ({@code DBClusterIdentifier},+ * {@code EngineMode}, {@code StorageEncrypted} and {@code DatabaseName} against the cluster on+ * file, the rest against what the template said last time, see+ * {@link #DB_CLUSTER_RECORDED_CREATE_ONLY}) creates the replacement under a distinct physical+ * id first and leaves the displaced cluster standing: it is deleted once the stack update+ * commits ({@link #completeUpdate}), or the resource is pointed back at it and the replacement+ * is removed when a later resource fails the update ({@link #rollbackUpdate}). A cluster the+ * template names explicitly has no distinct id to move to, which is the update CloudFormation+ * refuses for a custom-named resource, so it is refused here the same way.*/private void provisionDbCluster(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,ProvisionContext ctx, String region) {@@ -321,16 +377,19 @@ public class RdsCfnProvisioner implements CfnResourceProvisioner {DbCluster cluster = sameNameExistingResource(priorPhysicalId, id, rdsService::getDbCluster);String engineMode = resolveOptional(props, "EngineMode", engine);boolean storageEncrypted = parseBoolProp(props, "StorageEncrypted", engine);- if (cluster != null && requiresDbClusterReplacement(cluster, engineMode, storageEncrypted)) {+ String databaseName = resolveOptional(props, "DatabaseName", engine);+ Map<String, String> createOnly = dbClusterRecordedCreateOnly(props, engine);+ String replacementReason = cluster == null ? null : dbClusterReplacementReason(cluster,+ engineMode, storageEncrypted, databaseName,+ readDbClusterCreateOnly(attributesBefore.get(DB_CLUSTER_CREATE_ONLY_ATTR)), createOnly);+ if (replacementReason != null) {if (customNamed) {throw new AwsException("ValidationError","CloudFormation cannot update a stack when a custom-named resource requires "+ "replacing. Rename " + id + " and update the stack again.", 400);}id = ctx.generatePhysicalName(r.getLogicalId(), 60, true);- LOG.infov("Replacing DB cluster {0} with {1}: EngineMode/StorageEncrypted changed from "- + "{2}/{3} to {4}/{5}", priorPhysicalId, id, cluster.getEngineMode(),- cluster.isStorageEncrypted(), engineMode, storageEncrypted);+ LOG.infov("Replacing DB cluster {0} with {1}: {2}", priorPhysicalId, id, replacementReason);cluster = null;}if (cluster != null) {@@ -352,7 +411,6 @@ public class RdsCfnProvisioner implements CfnResourceProvisioner {resolveOptionalWithoutDynamicReferences(props, "MasterUsername", engine), region, false);String masterPassword = resolveDynamicReferences(resolveOptionalWithoutDynamicReferences(props, "MasterUserPassword", engine), region, true);- String databaseName = resolveOptional(props, "DatabaseName", engine);boolean iamEnabled = parseBoolProp(props, "EnableIAMDatabaseAuthentication", engine);String parameterGroup = resolveOptional(props, "DBClusterParameterGroupName", engine);if (engineMode == null && !storageEncrypted) {@@ -387,23 +445,107 @@ public class RdsCfnProvisioner implements CfnResourceProvisioner {if (cluster.getDbClusterResourceId() != null) {r.getAttributes().put("DBClusterResourceId", cluster.getDbClusterResourceId());}+ recordDbClusterCreateOnly(r, ctx, attributesBefore, createOnly);// A provision that left the resource with a new physical id replaced the cluster: the// displaced one is deleted once the update commits, or restored if the update rolls back.ReplacementCleanup.record(r, ctx, attributesBefore);}/**- * Whether the template's {@code EngineMode}/{@code StorageEncrypted} differ from the cluster on- * file. Both are createOnlyProperties, so a difference means replacement. A template without- * {@code EngineMode} means the RDS default {@code provisioned}, and a cluster persisted before- * the mode was tracked reports no mode at all, which is the same default.+ * Why the template's createOnly properties call for a replacement of the cluster on file, or+ * null when they describe it. {@code EngineMode}, {@code StorageEncrypted} and+ * {@code DatabaseName} are read from the cluster itself: a template without {@code EngineMode}+ * means the RDS default {@code provisioned}, and a cluster persisted before the mode was tracked+ * reports no mode at all, which is the same default. The rest are read from the record the last+ * provision left ({@link #DB_CLUSTER_RECORDED_CREATE_ONLY}); a resource without one predates+ * the record, and nothing on file can say what it was created with, so it is kept.*/- private static boolean requiresDbClusterReplacement(DbCluster existing, String engineMode,- boolean storageEncrypted) {+ private static String dbClusterReplacementReason(DbCluster existing, String engineMode,+ boolean storageEncrypted, String databaseName,+ Map<String, String> recorded,+ Map<String, String> desired) {+ List<String> changed = new ArrayList<>();String desiredMode = firstNonBlank(engineMode, "provisioned");String currentMode = firstNonBlank(existing.getEngineMode(), "provisioned");- return !desiredMode.equalsIgnoreCase(currentMode)- || existing.isStorageEncrypted() != storageEncrypted;+ if (!desiredMode.equalsIgnoreCase(currentMode)) {+ changed.add("EngineMode " + currentMode + " -> " + desiredMode);+ }+ if (existing.isStorageEncrypted() != storageEncrypted) {+ changed.add("StorageEncrypted " + existing.isStorageEncrypted() + " -> " + storageEncrypted);+ }+ String currentDatabase = firstNonBlank(existing.getDatabaseName(), null);+ String desiredDatabase = firstNonBlank(databaseName, null);+ if (!Objects.equals(currentDatabase, desiredDatabase)) {+ changed.add("DatabaseName " + currentDatabase + " -> " + desiredDatabase);+ }+ if (recorded != null) {+ for (String property : DB_CLUSTER_RECORDED_CREATE_ONLY) {+ if (!Objects.equals(recorded.get(property), desired.get(property))) {+ changed.add(property + " " + recorded.get(property) + " -> " + desired.get(property));+ }+ }+ }+ return changed.isEmpty() ? null : String.join(", ", changed);+ }++ /**+ * The template's values for {@link #DB_CLUSTER_RECORDED_CREATE_ONLY}: a value only when set,+ * booleans normalised to {@code true}/{@code false}, and the ones with a fixed default of false+ * recorded as false when absent (see {@link #DB_CLUSTER_BOOLEAN_CREATE_ONLY}).+ */+ private Map<String, String> dbClusterRecordedCreateOnly(JsonNode props,+ CloudFormationTemplateEngine engine) {+ Map<String, String> values = new LinkedHashMap<>();+ for (String property : DB_CLUSTER_RECORDED_CREATE_ONLY) {+ String value = resolveOptional(props, property, engine);+ boolean set = value != null && !value.isBlank();+ if (DB_CLUSTER_BOOLEAN_CREATE_ONLY.contains(property)) {+ if (set) {+ values.put(property, String.valueOf(Boolean.parseBoolean(value.trim())));+ } else if (DB_CLUSTER_DEFAULT_FALSE_CREATE_ONLY.contains(property)) {+ values.put(property, "false");+ }+ } else if (set) {+ values.put(property, value);+ }+ }+ return values;+ }++ /**+ * Writes the createOnly record the next update compares against. On an update that changed it+ * (a replacement, or the first record of a resource that predates it) the previous record is+ * kept beside it until the update commits, so {@link #rollbackUpdate} can put it back.+ */+ private static void recordDbClusterCreateOnly(StackResource r, ProvisionContext ctx,+ Map<String, String> attributesBefore,+ Map<String, String> createOnly) {+ String priorRecord = attributesBefore.get(DB_CLUSTER_CREATE_ONLY_ATTR);+ if (ctx.isUpdate() && !createOnly.equals(readDbClusterCreateOnly(priorRecord))) {+ r.getAttributes().put(DB_CLUSTER_CREATE_ONLY_PRIOR_ATTR, priorRecord == null ? "" : priorRecord);+ }+ ObjectNode record = MAPPER.createObjectNode();+ createOnly.forEach(record::put);+ r.getAttributes().put(DB_CLUSTER_CREATE_ONLY_ATTR, record.toString());+ }++ /** The record as a map, or null when the resource carries none or it cannot be read. */+ private static Map<String, String> readDbClusterCreateOnly(String raw) {+ if (raw == null || raw.isBlank()) {+ return null;+ }+ try {+ JsonNode node = MAPPER.readTree(raw);+ if (!node.isObject()) {+ return null;+ }+ Map<String, String> values = new LinkedHashMap<>();+ node.fields().forEachRemaining(e -> values.put(e.getKey(), e.getValue().asText()));+ return values;+ } catch (Exception e) {+ LOG.warnv("Ignoring unreadable DB cluster createOnly record: {0}", raw);+ return null;+ }}private Double parseServerlessV2Capacity(JsonNode props, String field,diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/RdsCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/RdsCfnProvisionerTest.javaindex 3a6f626e70..0494978778 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/RdsCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/RdsCfnProvisionerTest.java@@ -25,6 +25,7 @@ import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;import org.mockito.InOrder;import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;import org.junit.jupiter.params.provider.ValueSource;import java.util.List;@@ -1544,6 +1545,245 @@ class RdsCfnProvisionerTest {verify(rdsService).modifyDbCluster("mycluster", null, false, null, null, null, "us-east-1");}+ // ── the remaining createOnlyProperties of AWS::RDS::DBCluster ──++ private static final String CREATE_ONLY_ATTR = "__FlociDbClusterCreateOnly";+ private static final String CREATE_ONLY_PRIOR_ATTR = "__FlociDbClusterCreateOnlyPrior";++ /**+ * A CreateStack of the template, leaving the cluster on file under a generated physical id+ * and the resource carrying the createOnly record the next update compares against.+ */+ private StackResource createUnnamedCluster(String json) {+ createDbClusterEchoesRequestedId();+ StackResource created = provision("Cluster", "AWS::RDS::DBCluster", json);+ assertEquals("CREATE_COMPLETE", created.getStatus(), created.getStatusReason());+ DbCluster existing = mock(DbCluster.class);+ when(rdsService.getDbCluster(any())).thenReturn(existing);+ DbCluster reconciled = mock(DbCluster.class);+ when(reconciled.getDbClusterIdentifier()).thenReturn(created.getPhysicalId());+ when(rdsService.modifyDbCluster(eq(created.getPhysicalId()), any(), anyBoolean(),+ any(), any(), any(), eq("us-east-1"))).thenReturn(reconciled);+ return created;+ }++ private StackResource updateCluster(StackResource committed, String json) {+ return provisionExisting("Cluster", "AWS::RDS::DBCluster", json, "us-east-1",+ committed.getPhysicalId(), committed.getAttributes());+ }++ /** A template with {@code Engine} and one more property, quoted unless it is a boolean. */+ private static String clusterTemplate(String property, String value) {+ String literal = "true".equals(value) || "false".equals(value) ? value : "\"" + value + "\"";+ return "{\"Engine\":\"aurora-postgresql\",\"" + property + "\":" + literal + "}";+ }++ @Test+ void updateStackReplacesDbClusterWhenDatabaseNameChanges() {+ // DatabaseName is createOnly and the cluster on file records it, so the change is read+ // from the cluster like EngineMode and StorageEncrypted.+ DbCluster existing = priorUnnamedCluster("provisioned", false);+ when(existing.getDatabaseName()).thenReturn("appdb");+ createDbClusterEchoesRequestedId();++ StackResource r = updateUnnamedCluster("""+ {"Engine":"aurora-postgresql","DatabaseName":"reports"}+ """);++ assertEquals("CREATE_COMPLETE", r.getStatus());+ String replacement = r.getPhysicalId();+ assertNotEquals(PRIOR_CLUSTER, replacement);+ verify(rdsService).createDbCluster(replacement, "aurora-postgresql", null, null, null,+ "reports", false, null, null, null, false, "us-east-1");+ verify(rdsService, never()).modifyDbCluster(any(), any(), any(), any(), any(), any(), any());+ verify(rdsService, never()).deleteDbCluster(any(), any());+ assertEquals(PRIOR_CLUSTER, provisioner.updateCleanupPhysicalId(r));+ }++ @ParameterizedTest+ @CsvSource({+ "KmsKeyId, alias/aws/rds, arn:aws:kms:us-east-1:000000000000:key/11111111-2222-3333-4444-555555555555",+ "DBSubnetGroupName, private-subnets, public-subnets",+ "DBSystemId, rdsCustomOracle, rdsCustomOracle2",+ "PubliclyAccessible, false, true",+ "ClusterScalabilityType, standard, limitless",+ "SnapshotIdentifier, nightly-1, nightly-2",+ "SourceDBClusterIdentifier, source-a, source-b",+ "SourceDbClusterResourceId, cluster-AAAA, cluster-BBBB",+ "SourceRegion, us-west-2, eu-west-1",+ "RestoreType, full-copy, copy-on-write",+ "RestoreToTime, 2026-01-01T00:00:00Z, 2026-02-01T00:00:00Z",+ "UseLatestRestorableTime, false, true"+ })+ void updateStackReplacesDbClusterWhenARecordedCreateOnlyPropertyChanges(+ String property, String before, String after) {+ // Nothing on the cluster on file records these, so the change is read against what the+ // template said when the cluster was created: the same replacement lifecycle as EngineMode,+ // with the prior cluster owed a delete only after the update commits.+ StackResource created = createUnnamedCluster(clusterTemplate(property, before));+ String prior = created.getPhysicalId();+ assertTrue(created.getAttributes().get(CREATE_ONLY_ATTR).contains("\"" + property + "\""));+ assertFalse(created.getAttributes().containsKey(CREATE_ONLY_PRIOR_ATTR),+ "a create has no record to roll back to");++ StackResource r = updateCluster(created, clusterTemplate(property, after));++ assertEquals("CREATE_COMPLETE", r.getStatus(), r.getStatusReason());+ assertNotEquals(prior, r.getPhysicalId());+ verify(rdsService, never()).modifyDbCluster(any(), any(), any(), any(), any(), any(), any());+ verify(rdsService, never()).deleteDbCluster(any(), any());+ assertTrue(r.getAttributes().get(CREATE_ONLY_ATTR).contains(after));+ assertEquals(prior, provisioner.updateCleanupPhysicalId(r));+ UpdateCleanupResult cleanup = provisioner.completeUpdate(r);+ assertTrue(cleanup.complete());+ verify(rdsService).deleteDbCluster(prior, "us-east-1");+ assertFalse(r.getAttributes().containsKey(CREATE_ONLY_PRIOR_ATTR),+ "the committed update drops the record it replaced");+ }++ @Test+ void updateStackKeepsDbClusterWhenRecordedCreateOnlyPropertiesUnchanged() {+ // The same values, a boolean with a fixed default omitted instead of written as false, and+ // a changed mutable property describe the same cluster: it is modified in place and the+ // record stands.+ StackResource created = createUnnamedCluster("""+ {"Engine":"aurora-postgresql","KmsKeyId":"alias/aws/rds","UseLatestRestorableTime":false,+ "DBSubnetGroupName":"private-subnets","MasterUserPassword":"secret"}+ """);+ String record = created.getAttributes().get(CREATE_ONLY_ATTR);++ StackResource r = updateCluster(created, """+ {"Engine":"aurora-postgresql","KmsKeyId":"alias/aws/rds",+ "DBSubnetGroupName":"private-subnets","MasterUserPassword":"rotated"}+ """);++ assertEquals("CREATE_COMPLETE", r.getStatus(), r.getStatusReason());+ assertEquals(created.getPhysicalId(), r.getPhysicalId());+ verify(rdsService).modifyDbCluster(created.getPhysicalId(), "rotated", false,+ null, null, null, "us-east-1");+ verify(rdsService, times(1)).createDbCluster(any(), any(), any(), any(), any(), any(),+ anyBoolean(), any(), any(), any(), anyBoolean(), any());+ assertEquals(record, r.getAttributes().get(CREATE_ONLY_ATTR));+ assertFalse(r.getAttributes().containsKey(CREATE_ONLY_PRIOR_ATTR));+ assertFalse(provisioner.hasReplacementUpdate(r));+ }++ @ParameterizedTest+ @CsvSource({"false", "true"})+ void updateStackReplacesDbClusterWhenPubliclyAccessibleIsSpelledOutAfterBeingOmitted(String value) {+ // PubliclyAccessible has no fixed default: AWS makes an omitted one true or false depending+ // on the subnet group, so a cluster created without it may well be public, and a template+ // that later writes either value is a change CloudFormation replaces on. Absent stays+ // absent in the record rather than being read as false.+ StackResource created = createUnnamedCluster("""+ {"Engine":"aurora-postgresql","DBSubnetGroupName":"private-subnets"}+ """);+ String prior = created.getPhysicalId();+ assertFalse(created.getAttributes().get(CREATE_ONLY_ATTR).contains("PubliclyAccessible"));++ StackResource r = updateCluster(created, """+ {"Engine":"aurora-postgresql","DBSubnetGroupName":"private-subnets",+ "PubliclyAccessible":%s}+ """.formatted(value));++ assertEquals("CREATE_COMPLETE", r.getStatus(), r.getStatusReason());+ assertNotEquals(prior, r.getPhysicalId());+ verify(rdsService, never()).modifyDbCluster(any(), any(), any(), any(), any(), any(), any());+ assertEquals(prior, provisioner.updateCleanupPhysicalId(r));+ assertTrue(r.getAttributes().get(CREATE_ONLY_ATTR).contains("\"PubliclyAccessible\":\"" + value + "\""));++ // And the other way round: dropping it again is a change too.+ provisioner.completeUpdate(r);+ StackResource dropped = updateCluster(r, """+ {"Engine":"aurora-postgresql","DBSubnetGroupName":"private-subnets"}+ """);+ assertEquals("CREATE_COMPLETE", dropped.getStatus(), dropped.getStatusReason());+ assertNotEquals(r.getPhysicalId(), dropped.getPhysicalId());+ }++ @Test+ void updateStackRecordsCreateOnlyPropertiesOfAClusterProvisionedBeforeTheyWereTracked() {+ // A resource from before the record existed says nothing about what its cluster was+ // created with, so the first update keeps the cluster and records the template; the update+ // after that is compared against the record.+ priorUnnamedCluster("provisioned", false);+ DbCluster reconciled = mock(DbCluster.class);+ when(reconciled.getDbClusterIdentifier()).thenReturn(PRIOR_CLUSTER);+ when(rdsService.modifyDbCluster(eq(PRIOR_CLUSTER), any(), anyBoolean(),+ any(), any(), any(), eq("us-east-1"))).thenReturn(reconciled);++ StackResource first = updateUnnamedCluster("""+ {"Engine":"aurora-postgresql","KmsKeyId":"alias/aws/rds"}+ """);++ assertEquals("CREATE_COMPLETE", first.getStatus(), first.getStatusReason());+ assertEquals(PRIOR_CLUSTER, first.getPhysicalId());+ verify(rdsService).modifyDbCluster(PRIOR_CLUSTER, null, false, null, null, null, "us-east-1");+ assertTrue(first.getAttributes().get(CREATE_ONLY_ATTR).contains("alias/aws/rds"));+ assertEquals("", first.getAttributes().get(CREATE_ONLY_PRIOR_ATTR),+ "a rollback of this update drops the record again");+ provisioner.clearUpdate(first);+ assertFalse(first.getAttributes().containsKey(CREATE_ONLY_PRIOR_ATTR));++ createDbClusterEchoesRequestedId();+ StackResource second = updateCluster(first, """+ {"Engine":"aurora-postgresql","KmsKeyId":"alias/other"}+ """);++ assertEquals("CREATE_COMPLETE", second.getStatus(), second.getStatusReason());+ assertNotEquals(PRIOR_CLUSTER, second.getPhysicalId());+ assertEquals(PRIOR_CLUSTER, provisioner.updateCleanupPhysicalId(second));+ }++ @Test+ void failedLaterUpdateRollsBackTheCreateOnlyRecordWithTheDbCluster() {+ // The record follows the cluster: rolled back to the prior cluster, the resource compares+ // the next template against what that cluster was created with, not the replacement.+ StackResource created = createUnnamedCluster(clusterTemplate("KmsKeyId", "alias/aws/rds"));+ String prior = created.getPhysicalId();+ String priorRecord = created.getAttributes().get(CREATE_ONLY_ATTR);+ StackResource r = updateCluster(created, clusterTemplate("KmsKeyId", "alias/other"));+ String replacement = r.getPhysicalId();+ assertNotEquals(prior, replacement);+ assertEquals(priorRecord, r.getAttributes().get(CREATE_ONLY_PRIOR_ATTR));++ assertTrue(provisioner.rollbackUpdate(r));++ assertEquals(prior, r.getPhysicalId());+ assertEquals(priorRecord, r.getAttributes().get(CREATE_ONLY_ATTR));+ assertFalse(r.getAttributes().containsKey(CREATE_ONLY_PRIOR_ATTR));+ verify(rdsService).deleteDbCluster(replacement, "us-east-1");+ verify(rdsService, never()).deleteDbCluster(prior, "us-east-1");++ StackResource again = updateCluster(r, clusterTemplate("KmsKeyId", "alias/aws/rds"));++ assertEquals("CREATE_COMPLETE", again.getStatus(), again.getStatusReason());+ assertEquals(prior, again.getPhysicalId(), "the rolled-back template describes the prior cluster");+ verify(rdsService).modifyDbCluster(prior, null, false, null, null, null, "us-east-1");+ verify(rdsService, times(2)).createDbCluster(any(), any(), any(), any(), any(), any(),+ anyBoolean(), any(), any(), any(), anyBoolean(), any());+ }++ @Test+ void customNamedDbClusterRefusesRecordedCreateOnlyPropertyChange() {+ createDbClusterEchoesRequestedId();+ StackResource created = provision("Cluster", "AWS::RDS::DBCluster", """+ {"DBClusterIdentifier":"mycluster","Engine":"aurora-postgresql","KmsKeyId":"alias/aws/rds"}+ """);+ when(rdsService.getDbCluster("mycluster")).thenReturn(mock(DbCluster.class));++ StackResource r = updateCluster(created, """+ {"DBClusterIdentifier":"mycluster","Engine":"aurora-postgresql","KmsKeyId":"alias/other"}+ """);++ assertEquals("CREATE_FAILED", r.getStatus());+ assertTrue(r.getStatusReason().contains(+ "custom-named resource requires replacing. Rename mycluster and update the stack again."));+ assertEquals("mycluster", r.getPhysicalId());+ verify(rdsService, never()).deleteDbCluster(any(), any());+ verify(rdsService, never()).modifyDbCluster(any(), any(), any(), any(), any(), any(), any());+ }+@Testvoid deleteDelegatesToRdsServiceForEachRdsType() {// Stack deletion tears down RDS resources via the physical id set at provision time.