Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(cloudformation): provision AWS::ECS::CapacityProvider and ClusterCapacityProviderAssociations (#1999)

lex00907a2dfbf373
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCapacityCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCapacityCfnProvisioner.java
new file mode 100644
index 0000000000..6ad70391d4
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCapacityCfnProvisioner.java
@@ -0,0 +1,276 @@
+package io.github.hectorvent.floci.services.cloudformation.provisioners;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;
+import io.github.hectorvent.floci.services.ecs.EcsService;
+import io.github.hectorvent.floci.services.ecs.model.CapacityProvider;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+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;
+import java.util.Set;
+
+/**
+ * CloudFormation provisioning for ECS capacity: {@code AWS::ECS::CapacityProvider} and
+ * {@code AWS::ECS::ClusterCapacityProviderAssociations}. Injects only {@link EcsService}, per the
+ * per-service provisioner decomposition of {@code CloudFormationResourceProvisioner}.
+ *
+ * <p>CloudFormation spells these properties in PascalCase while {@code EcsService} stores the ECS
+ * JSON API's camelCase shape (that is what {@code CreateCapacityProvider} puts there). The whole
+ * {@code AutoScalingGroupProvider} sub-tree is therefore carried across with its keys
+ * decapitalized, so a capacity provider created by a stack holds the same state as one created
+ * through the API — including {@code ManagedScaling}, {@code ManagedTerminationProtection} and
+ * {@code ManagedDraining}.
+ */
+@ApplicationScoped
+public class EcsCapacityCfnProvisioner implements CfnResourceProvisioner {
+
+ private static final Logger LOG = Logger.getLogger(EcsCapacityCfnProvisioner.class);
+
+ private static final String CAPACITY_PROVIDER = "AWS::ECS::CapacityProvider";
+ private static final String ASSOCIATIONS = "AWS::ECS::ClusterCapacityProviderAssociations";
+
+ private final EcsService ecsService;
+
+ @Inject
+ public EcsCapacityCfnProvisioner(EcsService ecsService) {
+ this.ecsService = ecsService;
+ }
+
+ @Override
+ public Set<String> resourceTypes() {
+ return Set.of(CAPACITY_PROVIDER, ASSOCIATIONS);
+ }
+
+ @Override
+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {
+ switch (r.getResourceType()) {
+ case CAPACITY_PROVIDER -> provisionCapacityProvider(r, props, ctx);
+ case ASSOCIATIONS -> provisionAssociations(r, props, ctx);
+ default -> throw new IllegalStateException(
+ "EcsCapacityCfnProvisioner cannot handle " + r.getResourceType());
+ }
+ }
+
+ @Override
+ public void delete(String resourceType, String physicalId, String region) {
+ if (physicalId == null || physicalId.isBlank()) {
+ return;
+ }
+ switch (resourceType) {
+ case CAPACITY_PROVIDER -> deleteCapacityProvider(physicalId);
+ // Deleting the association resource leaves the cluster in place with no capacity
+ // providers attached, which is what AWS does: the associations are the resource.
+ case ASSOCIATIONS -> clearAssociations(physicalId, region);
+ default -> { }
+ }
+ }
+
+ private void provisionCapacityProvider(StackResource r, JsonNode props, ProvisionContext ctx) {
+ String existingName = r.getPhysicalId();
+ String declaredName = ctx.resolveOptional(props, "Name");
+ // An unnamed provider keeps the name its first execution generated. Minting a fresh one on
+ // every pass left the previous provider behind with nothing referencing it.
+ String name = declaredName != null && !declaredName.isBlank()
+ ? declaredName
+ : (existingName != null && !existingName.isBlank()
+ ? existingName
+ : ctx.generatePhysicalName(r.getLogicalId(), 255, false));
+
+ if (existingName != null && !existingName.isBlank() && !existingName.equals(name)) {
+ throw new AwsException("ValidationError",
+ "Updating Name requires resource replacement, which is not supported.", 400);
+ }
+
+ Map<String, Object> asgProvider = asgProvider(props, ctx);
+ Map<String, String> tags = tags(props, ctx);
+
+ // UpdateStack re-executes every resource with the physical id it got at create time, and
+ // createCapacityProvider rejects a name that already exists, so an unchanged provider used
+ // to fail the whole update. An empty result also covers a provider removed out of band,
+ // which is recreated rather than reported as a failure.
+ CapacityProvider existing = existingName == null || existingName.isBlank()
+ ? null
+ : ecsService.describeCapacityProviders(List.of(existingName)).stream()
+ .findFirst().orElse(null);
+
+ if (existing == null) {
+ ecsService.createCapacityProvider(name, asgProvider, tags, ctx.region());
+ } else {
+ if (!Objects.equals(asgArn(existing.getAutoScalingGroupProvider()), asgArn(asgProvider))) {
+ throw new AwsException("ValidationError",
+ "Updating AutoScalingGroupArn requires resource replacement, which is not "
+ + "supported.", 400);
+ }
+ ecsService.updateCapacityProvider(name, asgProvider);
+ applyTags(existing, tags);
+ }
+ // Ref returns the capacity provider name; AWS exposes no Fn::GetAtt attributes here.
+ r.setPhysicalId(name);
+ }
+
+ /** AutoScalingGroupArn is createOnly, so a change to it is a replacement rather than an update. */
+ private static String asgArn(Map<String, Object> asgProvider) {
+ Object arn = asgProvider == null ? null : asgProvider.get("autoScalingGroupArn");
+ return arn == null ? null : arn.toString();
+ }
+
+ /**
+ * Tags are updatable in place. updateCapacityProvider carries only the Auto Scaling settings,
+ * so a tag the template dropped would otherwise survive the update.
+ */
+ private void applyTags(CapacityProvider existing, Map<String, String> tags) {
+ Map<String, String> current = existing.getTags() == null ? Map.of() : existing.getTags();
+ List<String> dropped = current.keySet().stream()
+ .filter(key -> !tags.containsKey(key))
+ .toList();
+ if (!dropped.isEmpty()) {
+ ecsService.untagResource(existing.getCapacityProviderArn(), dropped);
+ }
+ if (!tags.isEmpty()) {
+ ecsService.tagResource(existing.getCapacityProviderArn(), tags);
+ }
+ }
+
+ private void provisionAssociations(StackResource r, JsonNode props, ProvisionContext ctx) {
+ String cluster = ctx.resolveOptional(props, "Cluster");
+ List<String> providers = new ArrayList<>();
+ if (props != null && props.has("CapacityProviders")) {
+ for (JsonNode entry : props.get("CapacityProviders")) {
+ String id = ctx.engine().resolve(entry);
+ if (id != null && !id.isBlank()) {
+ providers.add(id);
+ }
+ }
+ }
+ List<Map<String, Object>> strategy = new ArrayList<>();
+ if (props != null && props.has("DefaultCapacityProviderStrategy")) {
+ for (JsonNode entry : props.get("DefaultCapacityProviderStrategy")) {
+ Map<String, Object> item = new HashMap<>();
+ String provider = ctx.engine().resolve(entry.path("CapacityProvider"));
+ if (provider != null) {
+ item.put("capacityProvider", provider);
+ }
+ if (entry.hasNonNull("Weight")) {
+ item.put("weight", entry.get("Weight").asInt());
+ }
+ if (entry.hasNonNull("Base")) {
+ item.put("base", entry.get("Base").asInt());
+ }
+ strategy.add(item);
+ }
+ }
+ ecsService.putClusterCapacityProviders(cluster, providers, strategy, ctx.region());
+ r.setPhysicalId(cluster);
+ }
+
+ /**
+ * Carries {@code AutoScalingGroupProvider} across verbatim, resolving intrinsics and
+ * decapitalizing keys so the stored shape matches {@code CreateCapacityProvider}'s.
+ */
+ private Map<String, Object> asgProvider(JsonNode props, ProvisionContext ctx) {
+ JsonNode asg = props != null ? props.path("AutoScalingGroupProvider") : null;
+ if (asg == null || !asg.isObject()) {
+ return new LinkedHashMap<>();
+ }
+ Object converted = toApiShape(ctx.engine().resolveNode(asg));
+ if (converted instanceof Map<?, ?> map) {
+ @SuppressWarnings("unchecked")
+ Map<String, Object> typed = (Map<String, Object>) map;
+ return typed;
+ }
+ return new LinkedHashMap<>();
+ }
+
+ private Map<String, String> tags(JsonNode props, ProvisionContext ctx) {
+ Map<String, String> out = new HashMap<>();
+ JsonNode tagsNode = props != null ? props.get("Tags") : null;
+ if (tagsNode == null || !tagsNode.isArray()) {
+ return out;
+ }
+ for (JsonNode entry : tagsNode) {
+ JsonNode resolved = ctx.engine().resolveNode(entry);
+ String key = resolved.path("Key").asText(null);
+ if (key != null) {
+ out.put(key, resolved.path("Value").asText(""));
+ }
+ }
+ return out;
+ }
+
+ /** Recursively converts a resolved CloudFormation node to the ECS API's camelCase Java shape. */
+ private Object toApiShape(JsonNode node) {
+ if (node == null || node.isNull() || node.isMissingNode()) {
+ return null;
+ }
+ if (node.isObject()) {
+ Map<String, Object> out = new LinkedHashMap<>();
+ node.fields().forEachRemaining(field -> {
+ Object value = toApiShape(field.getValue());
+ if (value != null) {
+ out.put(decapitalize(field.getKey()), value);
+ }
+ });
+ return out;
+ }
+ if (node.isArray()) {
+ List<Object> out = new ArrayList<>();
+ for (JsonNode item : node) {
+ Object value = toApiShape(item);
+ if (value != null) {
+ out.add(value);
+ }
+ }
+ return out;
+ }
+ if (node.isBoolean()) {
+ return node.booleanValue();
+ }
+ if (node.isIntegralNumber()) {
+ return node.asInt();
+ }
+ if (node.isNumber()) {
+ return node.asDouble();
+ }
+ String text = node.asText();
+ return text.isEmpty() ? null : text;
+ }
+
+ private String decapitalize(String key) {
+ if (key == null || key.isEmpty()) {
+ return key;
+ }
+ return Character.toLowerCase(key.charAt(0)) + key.substring(1);
+ }
+
+ private void deleteCapacityProvider(String physicalId) {
+ // Idempotent: a provider that never got created (rollback) or was already removed is
+ // delete-complete. describeCapacityProviders resolves both names and ARNs.
+ if (ecsService.describeCapacityProviders(List.of(physicalId)).isEmpty()) {
+ LOG.debugv("ECS capacity provider {0} already gone, treating delete as complete", physicalId);
+ return;
+ }
+ ecsService.deleteCapacityProvider(physicalId);
+ }
+
+ private void clearAssociations(String clusterRef, String region) {
+ try {
+ ecsService.putClusterCapacityProviders(clusterRef, List.of(), List.of(), region);
+ } catch (AwsException e) {
+ // The cluster itself is deleted right after this resource; if it is already gone there
+ // is nothing left to detach. Any other failure must still fail the stack delete.
+ if (!"ClusterNotFoundException".equals(e.getErrorCode())) {
+ throw e;
+ }
+ LOG.debugv("ECS cluster {0} already gone, treating association delete as complete: {1}",
+ clusterRef, e.getMessage());
+ }
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsCapacityIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsCapacityIntegrationTest.java
new file mode 100644
index 0000000000..4732aff4e6
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsCapacityIntegrationTest.java
@@ -0,0 +1,231 @@
+package io.github.hectorvent.floci.services.cloudformation;
+
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.BeforeAll;
+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.hamcrest.Matchers.not;
+
+/**
+ * End-to-end check that CloudFormation provisions ECS capacity providers and
+ * cluster associations (issue #1998) into EcsService, and unwinds both on stack
+ * delete. Control-plane only.
+ */
+@QuarkusTest
+class CloudFormationEcsCapacityIntegrationTest {
+
+ private static final String CFN_AUTH =
+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/cloudformation/aws4_request";
+ private static final String ECS_TARGET = "AmazonEC2ContainerServiceV20141113.";
+ private static final String ECS_CT = "application/x-amz-json-1.1";
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ void capacityProviderAndAssociationsProvision() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "cfn-ecscap-" + suffix;
+ String clusterName = "cap-cluster-" + suffix;
+ String providerName = "cap-provider-" + suffix;
+
+ createStack(stackName, template(clusterName, providerName));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>CREATE_COMPLETE</StackStatus>"));
+
+ given()
+ .header("X-Amz-Target", ECS_TARGET + "DescribeClusters")
+ .contentType(ECS_CT)
+ .body("{\"clusters\":[\"" + clusterName + "\"]}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString(providerName));
+
+ // Tags declared on the capacity provider reach ECS instead of being replaced by an empty map.
+ String providers = describeCapacityProviders(providerName);
+ assertThat(providers, containsString(providerName));
+ assertThat(providers, containsString("owner"));
+ assertThat(providers, containsString("platform"));
+ }
+
+ @Test
+ void stackUpdateReusesTheCapacityProviderItAlreadyCreated() {
+ // UpdateStack re-executes every resource with the physical id it got at create time, and
+ // createCapacityProvider rejects an existing name, so the whole update used to fail. The
+ // aws-bench CDK scenarios redeploy iteratively, which is where this surfaces.
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "cfn-ecscap-upd-" + suffix;
+ String clusterName = "cap-cluster-upd-" + suffix;
+ String providerName = "cap-provider-upd-" + suffix;
+
+ createStack(stackName, template(clusterName, providerName));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template(clusterName, providerName)
+ .replace("\"TargetCapacity\": 80", "\"TargetCapacity\": 40")
+ .replace("{\"Key\": \"owner\", \"Value\": \"platform\"}",
+ "{\"Key\": \"owner\", \"Value\": \"infra\"}"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>UPDATE_COMPLETE</StackStatus>"));
+
+ // One provider still, carrying the updated tag value. The updated AutoScalingGroupProvider
+ // is asserted in EcsCapacityCfnProvisionerTest instead: DescribeCapacityProviders does not
+ // serialize autoScalingGroupProvider, so it is not observable here.
+ String providers = describeCapacityProviders(providerName);
+ assertThat(providers, containsString(providerName));
+ assertThat(providers, containsString("infra"));
+ assertThat(providers, not(containsString("platform")));
+ }
+
+ @Test
+ void stackDeleteRemovesProviderAndAssociations() throws Exception {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "cfn-ecscap-del-" + suffix;
+ String clusterName = "cap-cluster-del-" + suffix;
+ String providerName = "cap-provider-del-" + suffix;
+
+ String stackArn = createStack(stackName, template(clusterName, providerName));
+ assertThat(describeCapacityProviders(providerName), containsString(providerName));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String settled = awaitStackSettled(stackArn);
+ assertThat(settled, containsString("<StackStatus>DELETE_COMPLETE</StackStatus>"));
+
+ // The capacity provider must be deregistered, not left behind by an unsupported delete.
+ assertThat(describeCapacityProviders(providerName), not(containsString(providerName)));
+ }
+
+ private static String template(String clusterName, String providerName) {
+ return """
+ {
+ "Resources": {
+ "Cluster": {
+ "Type": "AWS::ECS::Cluster",
+ "Properties": {"ClusterName": "%s"}
+ },
+ "Provider": {
+ "Type": "AWS::ECS::CapacityProvider",
+ "Properties": {
+ "Name": "%s",
+ "AutoScalingGroupProvider": {
+ "AutoScalingGroupArn": "arn:aws:autoscaling:us-east-1:000000000000:autoScalingGroup:x:autoScalingGroupName/asg-x",
+ "ManagedTerminationProtection": "ENABLED",
+ "ManagedDraining": "ENABLED",
+ "ManagedScaling": {"Status": "ENABLED", "TargetCapacity": 80}
+ },
+ "Tags": [{"Key": "owner", "Value": "platform"}]
+ }
+ },
+ "Assoc": {
+ "Type": "AWS::ECS::ClusterCapacityProviderAssociations",
+ "Properties": {
+ "Cluster": {"Ref": "Cluster"},
+ "CapacityProviders": [{"Ref": "Provider"}, "FARGATE"],
+ "DefaultCapacityProviderStrategy": [
+ {"CapacityProvider": {"Ref": "Provider"}, "Weight": 1}
+ ]
+ }
+ }
+ }
+ }
+ """.formatted(clusterName, providerName);
+ }
+
+ private String createStack(String stackName, String template) {
+ String xml = given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackId>"))
+ .extract().asString();
+ return xml.substring(xml.indexOf("<StackId>") + "<StackId>".length(), xml.indexOf("</StackId>"));
+ }
+
+ private String describeCapacityProviders(String providerName) {
+ return given()
+ .header("X-Amz-Target", ECS_TARGET + "DescribeCapacityProviders")
+ .contentType(ECS_CT)
+ .body("{\"capacityProviders\":[\"" + providerName + "\"]}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+ }
+
+ private String awaitStackSettled(String stackArn) throws Exception {
+ long deadline = System.currentTimeMillis() + 10_000;
+ while (System.currentTimeMillis() < deadline) {
+ String xml = describeStacks(stackArn);
+ if (xml.contains("<StackStatus>DELETE_COMPLETE</StackStatus>")
+ || xml.contains("<StackStatus>DELETE_FAILED</StackStatus>")) {
+ return xml;
+ }
+ Thread.sleep(200);
+ }
+ throw new AssertionError("Stack did not settle into DELETE_COMPLETE/DELETE_FAILED: "
+ + describeStacks(stackArn));
+ }
+
+ private String describeStacks(String stackArn) {
+ return given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackArn)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCapacityCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCapacityCfnProvisionerTest.java
new file mode 100644
index 0000000000..08f786117f
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCapacityCfnProvisionerTest.java
@@ -0,0 +1,344 @@
+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;
+import io.github.hectorvent.floci.services.ecs.EcsService;
+import io.github.hectorvent.floci.services.ecs.model.CapacityProvider;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+/**
+ * The ECS capacity CFN provisioner in isolation: one mocked service, no Quarkus boot.
+ */
+class EcsCapacityCfnProvisionerTest {
+
+ private static final String PROVIDER_TYPE = "AWS::ECS::CapacityProvider";
+ private static final String ASSOCIATIONS_TYPE = "AWS::ECS::ClusterCapacityProviderAssociations";
+ private static final String ASG_ARN =
+ "arn:aws:autoscaling:us-east-1:000000000000:autoScalingGroup:x:autoScalingGroupName/asg-x";
+
+ private final EcsService ecs = mock(EcsService.class);
+ private final EcsCapacityCfnProvisioner provisioner = new EcsCapacityCfnProvisioner(ecs);
+ private final ObjectMapper mapper = new ObjectMapper();
+
+ private ProvisionContext ctx() {
+ // Scalars only: resolve returns the node's text and resolveNode is structure-preserving,
+ // which is what the engine does for templates without intrinsics.
+ CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);
+ when(engine.resolve(any())).thenAnswer(inv -> {
+ JsonNode node = inv.getArgument(0);
+ return node == null ? null : node.asText();
+ });
+ when(engine.resolveNode(any())).thenAnswer(inv -> inv.getArgument(0));
+ return new ProvisionContext(engine, "us-east-1", "000000000000", "my-stack");
+ }
+
+ private StackResource resource(String type, String logicalId) {
+ StackResource r = new StackResource();
+ r.setLogicalId(logicalId);
+ r.setResourceType(type);
+ r.setAttributes(new HashMap<>());
+ return r;
+ }
+
+ @Test
+ void capacityProviderUsesDeclaredName() {
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Name", "the-provider");
+ props.putObject("AutoScalingGroupProvider").put("AutoScalingGroupArn", ASG_ARN);
+
+ provisioner.provision(r, props, ctx());
+
+ assertEquals("the-provider", r.getPhysicalId());
+ verify(ecs).createCapacityProvider(eq("the-provider"), any(), any(), eq("us-east-1"));
+ }
+
+ @Test
+ void capacityProviderWithoutNameGeneratesPhysicalName() {
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+
+ provisioner.provision(r, mapper.createObjectNode(), ctx());
+
+ assertEquals("my-stack-Provider", r.getPhysicalId().replaceAll("-[0-9a-f]{12}$", ""));
+ }
+
+ private CapacityProvider stored(String name, String asgArn, Map<String, String> tags) {
+ CapacityProvider cp = new CapacityProvider();
+ cp.setName(name);
+ cp.setCapacityProviderArn("arn:aws:ecs:us-east-1:000000000000:capacity-provider/" + name);
+ Map<String, Object> asg = new HashMap<>();
+ asg.put("autoScalingGroupArn", asgArn);
+ cp.setAutoScalingGroupProvider(asg);
+ cp.setTags(new HashMap<>(tags));
+ return cp;
+ }
+
+ @Test
+ void updateReusesTheExistingProviderInsteadOfCreatingIt() {
+ // UpdateStack re-executes the resource with the physical id it already has, and
+ // createCapacityProvider rejects an existing name, so this used to fail the whole update.
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ r.setPhysicalId("the-provider");
+ when(ecs.describeCapacityProviders(List.of("the-provider")))
+ .thenReturn(List.of(stored("the-provider", ASG_ARN, Map.of())));
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Name", "the-provider");
+ ObjectNode asg = props.putObject("AutoScalingGroupProvider");
+ asg.put("AutoScalingGroupArn", ASG_ARN);
+ asg.put("ManagedDraining", "ENABLED");
+
+ provisioner.provision(r, props, ctx());
+
+ assertEquals("the-provider", r.getPhysicalId());
+ verify(ecs, never()).createCapacityProvider(anyString(), any(), any(), anyString());
+ ArgumentCaptor<Map<String, Object>> asgCaptor = ArgumentCaptor.forClass(Map.class);
+ verify(ecs).updateCapacityProvider(eq("the-provider"), asgCaptor.capture());
+ assertEquals("ENABLED", asgCaptor.getValue().get("managedDraining"));
+ }
+
+ @Test
+ void anUnnamedProviderKeepsItsGeneratedNameAcrossUpdates() {
+ // A fresh generated name on every pass created a second provider and orphaned the first.
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ r.setPhysicalId("my-stack-Provider-abcdef123456");
+ when(ecs.describeCapacityProviders(List.of("my-stack-Provider-abcdef123456")))
+ .thenReturn(List.of(stored("my-stack-Provider-abcdef123456", null, Map.of())));
+
+ provisioner.provision(r, mapper.createObjectNode(), ctx());
+
+ assertEquals("my-stack-Provider-abcdef123456", r.getPhysicalId());
+ verify(ecs, never()).createCapacityProvider(anyString(), any(), any(), anyString());
+ verify(ecs).updateCapacityProvider(eq("my-stack-Provider-abcdef123456"), any());
+ }
+
+ @Test
+ void aProviderRemovedOutOfBandIsRecreated() {
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ r.setPhysicalId("the-provider");
+ when(ecs.describeCapacityProviders(List.of("the-provider"))).thenReturn(List.of());
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Name", "the-provider");
+ props.putObject("AutoScalingGroupProvider").put("AutoScalingGroupArn", ASG_ARN);
+
+ provisioner.provision(r, props, ctx());
+
+ verify(ecs).createCapacityProvider(eq("the-provider"), any(), any(), eq("us-east-1"));
+ verify(ecs, never()).updateCapacityProvider(anyString(), any());
+ }
+
+ @Test
+ void changingNameIsRejectedAsAReplacement() {
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ r.setPhysicalId("the-provider");
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Name", "a-different-provider");
+
+ AwsException failure = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx()));
+
+ assertEquals("ValidationError", failure.getErrorCode());
+ verify(ecs, never()).createCapacityProvider(anyString(), any(), any(), anyString());
+ verify(ecs, never()).updateCapacityProvider(anyString(), any());
+ }
+
+ @Test
+ void changingAutoScalingGroupArnIsRejectedAsAReplacement() {
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ r.setPhysicalId("the-provider");
+ when(ecs.describeCapacityProviders(List.of("the-provider")))
+ .thenReturn(List.of(stored("the-provider", ASG_ARN, Map.of())));
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Name", "the-provider");
+ props.putObject("AutoScalingGroupProvider")
+ .put("AutoScalingGroupArn", ASG_ARN.replace("asg-x", "asg-y"));
+
+ AwsException failure = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx()));
+
+ assertEquals("ValidationError", failure.getErrorCode());
+ verify(ecs, never()).updateCapacityProvider(anyString(), any());
+ }
+
+ @Test
+ void updateAppliesTagChangesAndRemovesTheOnesTheTemplateDropped() {
+ // updateCapacityProvider carries only the Auto Scaling settings, so a dropped tag would
+ // otherwise survive the update.
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ r.setPhysicalId("the-provider");
+ String arn = "arn:aws:ecs:us-east-1:000000000000:capacity-provider/the-provider";
+ when(ecs.describeCapacityProviders(List.of("the-provider")))
+ .thenReturn(List.of(stored("the-provider", ASG_ARN, Map.of("keep", "1", "drop", "2"))));
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Name", "the-provider");
+ props.putObject("AutoScalingGroupProvider").put("AutoScalingGroupArn", ASG_ARN);
+ var tags = props.putArray("Tags");
+ tags.addObject().put("Key", "keep").put("Value", "1");
+
+ provisioner.provision(r, props, ctx());
+
+ verify(ecs).untagResource(arn, List.of("drop"));
+ verify(ecs).tagResource(arn, Map.of("keep", "1"));
+ }
+
+ /** Greptile P1: ManagedScaling / ManagedTerminationProtection / ManagedDraining were dropped. */
+ @Test
+ void capacityProviderCarriesFullAutoScalingGroupProvider() {
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Name", "the-provider");
+ ObjectNode asg = props.putObject("AutoScalingGroupProvider");
+ asg.put("AutoScalingGroupArn", ASG_ARN);
+ asg.put("ManagedTerminationProtection", "ENABLED");
+ asg.put("ManagedDraining", "ENABLED");
+ ObjectNode scaling = asg.putObject("ManagedScaling");
+ scaling.put("Status", "ENABLED");
+ scaling.put("TargetCapacity", 80);
+ scaling.put("MinimumScalingStepSize", 1);
+ scaling.put("MaximumScalingStepSize", 10);
+ scaling.put("InstanceWarmupPeriod", 300);
+
+ provisioner.provision(r, props, ctx());
+
+ @SuppressWarnings("unchecked")
+ ArgumentCaptor<Map<String, Object>> captor = ArgumentCaptor.forClass(Map.class);
+ verify(ecs).createCapacityProvider(eq("the-provider"), captor.capture(), any(), eq("us-east-1"));
+ Map<String, Object> asgProvider = captor.getValue();
+
+ // Stored in the ECS JSON API's camelCase shape, the same one CreateCapacityProvider writes.
+ assertEquals(ASG_ARN, asgProvider.get("autoScalingGroupArn"));
+ assertEquals("ENABLED", asgProvider.get("managedTerminationProtection"));
+ assertEquals("ENABLED", asgProvider.get("managedDraining"));
+ @SuppressWarnings("unchecked")
+ Map<String, Object> managedScaling = (Map<String, Object>) asgProvider.get("managedScaling");
+ assertEquals("ENABLED", managedScaling.get("status"));
+ assertEquals(80, managedScaling.get("targetCapacity"));
+ assertEquals(1, managedScaling.get("minimumScalingStepSize"));
+ assertEquals(10, managedScaling.get("maximumScalingStepSize"));
+ assertEquals(300, managedScaling.get("instanceWarmupPeriod"));
+ }
+
+ /** Greptile P1: Tags were replaced with an empty map. */
+ @Test
+ void capacityProviderCarriesTags() {
+ StackResource r = resource(PROVIDER_TYPE, "Provider");
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Name", "the-provider");
+ var tags = props.putArray("Tags");
+ tags.addObject().put("Key", "env").put("Value", "prod");
+ tags.addObject().put("Key", "team").put("Value", "platform");
+
+ provisioner.provision(r, props, ctx());
+
+ @SuppressWarnings("unchecked")
+ ArgumentCaptor<Map<String, String>> captor = ArgumentCaptor.forClass(Map.class);
+ verify(ecs).createCapacityProvider(eq("the-provider"), any(), captor.capture(), eq("us-east-1"));
+ assertEquals(Map.of("env", "prod", "team", "platform"), captor.getValue());
+ }
+
+ @Test
+ void associationsPutProvidersAndStrategy() {
+ StackResource r = resource(ASSOCIATIONS_TYPE, "Assoc");
+ ObjectNode props = mapper.createObjectNode();
+ props.put("Cluster", "the-cluster");
+ var providers = props.putArray("CapacityProviders");
+ providers.add("the-provider");
+ providers.add("FARGATE");
+ var strategy = props.putArray("DefaultCapacityProviderStrategy");
+ strategy.addObject().put("CapacityProvider", "the-provider").put("Weight", 2).put("Base", 1);
+
+ provisioner.provision(r, props, ctx());
+
+ assertEquals("the-cluster", r.getPhysicalId());
+ verify(ecs).putClusterCapacityProviders("the-cluster",
+ List.of("the-provider", "FARGATE"),
+ List.of(Map.of("capacityProvider", "the-provider", "weight", 2, "base", 1)),
+ "us-east-1");
+ }
+
+ @Test
+ void unhandledTypeThrows() {
+ StackResource r = resource("AWS::ECS::Cluster", "Cluster");
+ assertThrows(IllegalStateException.class,
+ () -> provisioner.provision(r, mapper.createObjectNode(), ctx()));
+ }
+
+ /** Greptile P1: stack delete and rollback left the capacity provider registered. */
+ @Test
+ void deleteCapacityProviderDelegatesToService() {
+ CapacityProvider existing = new CapacityProvider();
+ existing.setName("the-provider");
+ when(ecs.describeCapacityProviders(List.of("the-provider"))).thenReturn(List.of(existing));
+
+ provisioner.delete(PROVIDER_TYPE, "the-provider", "us-east-1");
+
+ verify(ecs).deleteCapacityProvider("the-provider");
+ }
+
+ @Test
+ void deleteCapacityProviderAlreadyGoneIsDeleteComplete() {
+ when(ecs.describeCapacityProviders(anyList())).thenReturn(List.of());
+
+ provisioner.delete(PROVIDER_TYPE, "the-provider", "us-east-1");
+
+ verify(ecs, never()).deleteCapacityProvider(anyString());
+ }
+
+ /** Greptile P1: the cluster kept its associations after the stack was deleted. */
+ @Test
+ void deleteAssociationsDetachesProvidersFromCluster() {
+ provisioner.delete(ASSOCIATIONS_TYPE, "the-cluster", "us-east-1");
+
+ verify(ecs).putClusterCapacityProviders("the-cluster", List.of(), List.of(), "us-east-1");
+ }
+
+ @Test
+ void deleteAssociationsToleratesAMissingCluster() {
+ when(ecs.putClusterCapacityProviders(anyString(), anyList(), anyList(), anyString()))
+ .thenThrow(new AwsException("ClusterNotFoundException", "Cluster not found: gone", 400));
+
+ provisioner.delete(ASSOCIATIONS_TYPE, "gone", "us-east-1");
+ }
+
+ @Test
+ void deleteAssociationsPropagatesOtherFailures() {
+ when(ecs.putClusterCapacityProviders(anyString(), anyList(), anyList(), anyString()))
+ .thenThrow(new AwsException("ServerException", "boom", 500));
+
+ AwsException thrown = assertThrows(AwsException.class,
+ () -> provisioner.delete(ASSOCIATIONS_TYPE, "the-cluster", "us-east-1"));
+ assertEquals("ServerException", thrown.getErrorCode());
+ }
+
+ @Test
+ void deleteWithoutAPhysicalIdIsANoOp() {
+ provisioner.delete(PROVIDER_TYPE, null, "us-east-1");
+ provisioner.delete(ASSOCIATIONS_TYPE, " ", "us-east-1");
+ verifyNoInteractions(ecs);
+ }
+
+ @Test
+ void resourceTypesCoverBothCapacityTypes() {
+ assertTrue(provisioner.resourceTypes().containsAll(List.of(PROVIDER_TYPE, ASSOCIATIONS_TYPE)));
+ assertEquals(2, provisioner.resourceTypes().size());
+ }
+}