Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(cloudformation): honor resource-level DeletionPolicy (#2167)

soreavis7d9b9aedd274
diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.md
index 6d9180e035..f93d0413ce 100644
--- a/docs/services/cloudformation.md
+++ b/docs/services/cloudformation.md
@@ -118,6 +118,36 @@ Resources provisioned by `CreateStack` / `UpdateStack` land in the **caller's ac
(determined from the request's access key — see [Multi-Account Isolation](../configuration/multi-account.md)).
Deleting the stack removes them from that same account.
+## Deletion Policies
+
+A resource's [`DeletionPolicy`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html)
+attribute is honored on `DeleteStack` and on the rollback of a failed `CreateStack`:
+
+| Value | `DeleteStack` | Rollback of the create that made the resource |
+|---|---|---|
+| `Delete` (default) | deleted | deleted |
+| `Retain` | kept | kept |
+| `RetainExceptOnCreate` | kept | deleted |
+
+A kept resource is reported as `DELETE_SKIPPED` in `DescribeStackEvents` and does not fail the
+deletion — the stack still reaches `DELETE_COMPLETE` while the resource keeps existing. This also
+lets a stack owning a non-empty S3 bucket be deleted, since the bucket is never touched.
+
+Deviations from AWS to be aware of:
+
+- `Snapshot` deletes the resource without taking a snapshot; floci has no snapshot support for the
+ types AWS allows it on.
+- Every resource defaults to `Delete`. AWS instead defaults `AWS::RDS::DBCluster`, and
+ `AWS::RDS::DBInstance` without a `DBClusterIdentifier`, to `Snapshot`.
+- Unrecognized values are treated as `Delete`.
+- An update that removes a resource from the template does not delete it (or consult its policy);
+ only the new template's resources are provisioned. AWS applies `DeletionPolicy` to update-time
+ removals as well.
+- After `DeleteStack` completes, a retained resource's `DELETE_SKIPPED` record is only visible
+ through `DescribeStackEvents` for the deleted stack, not `DescribeStackResources`.
+- `UpdateReplacePolicy`, and the `RetainExceptOnCreate` request parameter of `CreateStack` /
+ `UpdateStack`, are not implemented.
+
## StackSets
StackSets deploy a single template into many target accounts and regions:
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
index 3455d6e485..38bad4d97a 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
@@ -454,6 +454,7 @@ public class CloudFormationService {
for (String logicalId : sortedLogicalIds) {
JsonNode resDef = resources.get(logicalId);
String type = resDef.path("Type").asText();
+ String deletionPolicy = resDef.path("DeletionPolicy").asText(null);
JsonNode props = resDef.path("Properties");
CloudFormationTemplateEngine engine = new CloudFormationTemplateEngine(
@@ -479,6 +480,9 @@ public class CloudFormationService {
engine, region, accountId, stack.getStackName(),
resource.getPhysicalId(), resource.getAttributes());
}
+ // Both branches return a fresh StackResource, so the policy is carried over here
+ // rather than on the instance the loop started with.
+ resource.setDeletionPolicy(deletionPolicy);
stack.getResources().put(logicalId, resource);
physicalIds.put(logicalId, resource.getPhysicalId());
@@ -632,6 +636,9 @@ public class CloudFormationService {
if (resource.getPhysicalId() == null || (!completed && !ownedFailedResource)) {
continue;
}
+ if (skipRetainedResource(stack, resource, true)) {
+ continue;
+ }
addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),
resource.getResourceType(), "DELETE_IN_PROGRESS", null);
try {
@@ -667,6 +674,9 @@ public class CloudFormationService {
if (resource.getPhysicalId() == null || !deletable) {
continue;
}
+ if (skipRetainedResource(stack, resource, false)) {
+ continue;
+ }
addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),
resource.getResourceType(), "DELETE_IN_PROGRESS", null);
try {
@@ -719,6 +729,29 @@ public class CloudFormationService {
}
}
+ /**
+ * Applies a resource's {@code DeletionPolicy}. {@code Retain} keeps the resource on every stack
+ * operation; {@code RetainExceptOnCreate} keeps it too, except when the create that made it is
+ * rolled back. Every other value — including {@code Snapshot}, which floci cannot snapshot —
+ * falls through to a normal delete, matching the default.
+ *
+ * @return {@code true} when the resource was kept and reported as {@code DELETE_SKIPPED}
+ */
+ private boolean skipRetainedResource(Stack stack, StackResource resource, boolean createRollback) {
+ String policy = resource.getDeletionPolicy();
+ boolean retained = "Retain".equals(policy)
+ || (!createRollback && "RetainExceptOnCreate".equals(policy));
+ if (!retained) {
+ return false;
+ }
+ resource.setStatus("DELETE_SKIPPED");
+ addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),
+ resource.getResourceType(), "DELETE_SKIPPED", null);
+ LOG.infov("Retained {0} ({1}) in stack {2}: DeletionPolicy {3}",
+ resource.getResourceType(), resource.getPhysicalId(), stack.getStackName(), policy);
+ return true;
+ }
+
private Map<String, Boolean> resolveConditions(JsonNode template, Map<String, String> params,
Stack stack, String region, String accountId) {
Map<String, Boolean> conditions = new HashMap<>();
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/model/StackResource.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/model/StackResource.java
index 9a7c9a2e41..a74e01dd83 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/model/StackResource.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/model/StackResource.java
@@ -13,6 +13,7 @@ public class StackResource {
private String logicalId;
private String physicalId;
private String resourceType;
+ private String deletionPolicy;
private String status = "CREATE_IN_PROGRESS";
private String statusReason;
private Instant timestamp = Instant.now();
@@ -24,6 +25,8 @@ public class StackResource {
public void setPhysicalId(String physicalId) { this.physicalId = physicalId; }
public String getResourceType() { return resourceType; }
public void setResourceType(String resourceType) { this.resourceType = resourceType; }
+ public String getDeletionPolicy() { return deletionPolicy; }
+ public void setDeletionPolicy(String deletionPolicy) { this.deletionPolicy = deletionPolicy; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public String getStatusReason() { return statusReason; }
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeletionPolicyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeletionPolicyIntegrationTest.java
new file mode 100644
index 0000000000..25a619afb0
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationDeletionPolicyIntegrationTest.java
@@ -0,0 +1,243 @@
+package io.github.hectorvent.floci.services.cloudformation;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.response.Response;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Verifies the resource-level {@code DeletionPolicy} attribute (issue #1555): {@code Retain} keeps a
+ * resource on every stack operation, {@code RetainExceptOnCreate} keeps it everywhere except the
+ * rollback of the create that made it, and any other value falls through to the default delete.
+ *
+ * <p>Exercised through S3 buckets — the case the attribute is most used for, and one whose survival
+ * is directly observable without Docker.
+ */
+@QuarkusTest
+class CloudFormationDeletionPolicyIntegrationTest {
+
+ @Test
+ void retainKeepsANonEmptyBucketAndTheStackStillCompletesTheDelete() throws InterruptedException {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String bucket = "cfn-retain-bucket-" + suffix;
+ String stackName = "cfn-retain-stack-" + suffix;
+
+ String template = """
+ {
+ "Resources": {
+ "MyBucket": {
+ "Type": "AWS::S3::Bucket",
+ "DeletionPolicy": "Retain",
+ "Properties": { "BucketName": "%s" }
+ }
+ }
+ }
+ """.formatted(bucket);
+
+ String stackId = createStack(stackName, template);
+
+ given()
+ .contentType("text/plain")
+ .body("kept")
+ .when()
+ .put("/" + bucket + "/object.txt")
+ .then()
+ .statusCode(200);
+
+ deleteStack(stackName);
+
+ // A deleted bucket would have failed on its objects instead (issue #1539), so reaching
+ // DELETE_COMPLETE is itself evidence that the bucket was never touched.
+ awaitStackStatus(stackId, "DELETE_COMPLETE");
+
+ given()
+ .when()
+ .get("/" + bucket + "/object.txt")
+ .then()
+ .statusCode(200)
+ .body(containsString("kept"));
+
+ assertThat(describeStackEvents(stackId),
+ containsString("<ResourceStatus>DELETE_SKIPPED</ResourceStatus>"));
+ }
+
+ @Test
+ void retainExceptOnCreateKeepsTheBucketWhenTheStackIsDeleted() throws InterruptedException {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String bucket = "cfn-reoc-delete-bucket-" + suffix;
+ String stackName = "cfn-reoc-delete-stack-" + suffix;
+
+ String template = """
+ {
+ "Resources": {
+ "MyBucket": {
+ "Type": "AWS::S3::Bucket",
+ "DeletionPolicy": "RetainExceptOnCreate",
+ "Properties": { "BucketName": "%s" }
+ }
+ }
+ }
+ """.formatted(bucket);
+
+ String stackId = createStack(stackName, template);
+ deleteStack(stackName);
+ awaitStackStatus(stackId, "DELETE_COMPLETE");
+
+ assertBucketExists(bucket);
+ }
+
+ @Test
+ void rollingBackAFailedCreateDeletesRetainExceptOnCreateButKeepsRetain() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String keptBucket = "cfn-rollback-retain-bucket-" + suffix;
+ String rolledBackBucket = "cfn-rollback-reoc-bucket-" + suffix;
+ String stackName = "cfn-rollback-policy-stack-" + suffix;
+
+ // DependsOn forces both buckets to provision before BadSecret fails (setting SecretString
+ // and GenerateSecretString together is invalid), which triggers the create rollback.
+ String template = """
+ {
+ "Resources": {
+ "KeptBucket": {
+ "Type": "AWS::S3::Bucket",
+ "DeletionPolicy": "Retain",
+ "Properties": { "BucketName": "%s" }
+ },
+ "RolledBackBucket": {
+ "Type": "AWS::S3::Bucket",
+ "DeletionPolicy": "RetainExceptOnCreate",
+ "DependsOn": "KeptBucket",
+ "Properties": { "BucketName": "%s" }
+ },
+ "BadSecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "DependsOn": "RolledBackBucket",
+ "Properties": {
+ "Name": "cfn-rollback-policy-secret-%s",
+ "SecretString": "explicit",
+ "GenerateSecretString": { "PasswordLength": 32 }
+ }
+ }
+ }
+ }
+ """.formatted(keptBucket, rolledBackBucket, suffix);
+
+ String stackId = createStack(stackName, template);
+
+ assertThat(describeStacks(stackId), containsString("<StackStatus>ROLLBACK_COMPLETE</StackStatus>"));
+ assertBucketExists(keptBucket);
+ assertBucketDeleted(rolledBackBucket);
+ }
+
+ @Test
+ void bucketsWithoutARetainingPolicyAreStillDeleted() throws InterruptedException {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String defaulted = "cfn-policy-default-bucket-" + suffix;
+ String explicitDelete = "cfn-policy-delete-bucket-" + suffix;
+ String unrecognized = "cfn-policy-unknown-bucket-" + suffix;
+ String stackName = "cfn-policy-delete-stack-" + suffix;
+
+ String template = """
+ {
+ "Resources": {
+ "Defaulted": {
+ "Type": "AWS::S3::Bucket",
+ "Properties": { "BucketName": "%s" }
+ },
+ "ExplicitDelete": {
+ "Type": "AWS::S3::Bucket",
+ "DeletionPolicy": "Delete",
+ "Properties": { "BucketName": "%s" }
+ },
+ "Unrecognized": {
+ "Type": "AWS::S3::Bucket",
+ "DeletionPolicy": "Keep",
+ "Properties": { "BucketName": "%s" }
+ }
+ }
+ }
+ """.formatted(defaulted, explicitDelete, unrecognized);
+
+ String stackId = createStack(stackName, template);
+ deleteStack(stackName);
+ awaitStackStatus(stackId, "DELETE_COMPLETE");
+
+ assertBucketDeleted(defaulted);
+ assertBucketDeleted(explicitDelete);
+ assertBucketDeleted(unrecognized);
+ }
+
+ private static String createStack(String stackName, String template) {
+ String xml = given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+
+ int start = xml.indexOf("<StackId>") + "<StackId>".length();
+ return xml.substring(start, xml.indexOf("</StackId>", start));
+ }
+
+ private static void deleteStack(String stackName) {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ /** DeleteStack runs asynchronously, and a deleted stack stays describable by its stack ID. */
+ private static void awaitStackStatus(String stackId, String status) throws InterruptedException {
+ String xml = "";
+ long deadline = System.currentTimeMillis() + 10_000;
+ while (System.currentTimeMillis() < deadline) {
+ xml = describeStacks(stackId);
+ if (xml.contains("<StackStatus>" + status + "</StackStatus>")) {
+ return;
+ }
+ Thread.sleep(50);
+ }
+ fail("stack " + stackId + " never reached " + status + ": " + xml);
+ }
+
+ private static String describeStacks(String stackId) {
+ return cfnQuery("DescribeStacks", stackId).then().statusCode(200).extract().asString();
+ }
+
+ private static String describeStackEvents(String stackId) {
+ return cfnQuery("DescribeStackEvents", stackId).then().statusCode(200).extract().asString();
+ }
+
+ private static Response cfnQuery(String action, String stackId) {
+ return given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", action)
+ .formParam("StackName", stackId)
+ .when()
+ .post("/");
+ }
+
+ private static void assertBucketExists(String bucket) {
+ bucketRequest(bucket).then().statusCode(200);
+ }
+
+ private static void assertBucketDeleted(String bucket) {
+ bucketRequest(bucket).then().statusCode(404);
+ }
+
+ private static Response bucketRequest(String bucket) {
+ return given().header("Host", bucket + ".localhost").when().get("/");
+ }
+}