Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ecs): report service deployments and MISSING failures on DescribeServices (#2176)
Hector Ventura8b8f837728db
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcsTests.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcsTests.javaindex a7d447ad91..b2acdfb6ca 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcsTests.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcsTests.java@@ -1,9 +1,12 @@package com.floci.test;import org.junit.jupiter.api.*;+import software.amazon.awssdk.core.waiters.WaiterOverrideConfiguration;+import software.amazon.awssdk.core.waiters.WaiterResponse;import software.amazon.awssdk.services.ecs.EcsClient;import software.amazon.awssdk.services.ecs.model.*;+import java.time.Duration;import java.util.List;import static org.assertj.core.api.Assertions.*;@@ -773,6 +776,25 @@ class EcsTests {assertThat(services).hasSize(1);assertThat(services.get(0).serviceName()).isEqualTo(serviceName);assertThat(services.get(0).desiredCount()).isEqualTo(1);++ // An ACTIVE service must report exactly one PRIMARY deployment. AWS's ServicesStable+ // waiter accepts on length(deployments) == 1, so an empty list silently breaks every+ // SDK waiter and Terraform's aws_ecs_service (floci-io/floci#2174).+ List<Deployment> deployments = services.get(0).deployments();+ assertThat(deployments).hasSize(1);+ assertThat(deployments.get(0).status()).isEqualTo("PRIMARY");+ assertThat(deployments.get(0).id()).startsWith("ecs-svc/");+ assertThat(deployments.get(0).taskDefinition()).isEqualTo(services.get(0).taskDefinition());+ assertThat(deployments.get(0).desiredCount()).isEqualTo(1);+ assertThat(deployments.get(0).rolloutState())+ .isIn(DeploymentRolloutState.COMPLETED, DeploymentRolloutState.IN_PROGRESS);++ // Deployments are synthesized per request, so the id must not drift between calls.+ List<Service> again = ecs.describeServices(DescribeServicesRequest.builder()+ .cluster(clusterName)+ .services(serviceName)+ .build()).services();+ assertThat(again.get(0).deployments().get(0).id()).isEqualTo(deployments.get(0).id());}@Test@@ -807,6 +829,46 @@ class EcsTests {@Test@Order(45)+ @DisplayName("ServicesStable waiter - reaches stable")+ void servicesStableWaiter() {+ // The strongest available check on services[].deployments: this drives AWS's own+ // waiter acceptor,+ // length(services[?!(length(deployments) == `1` && runningCount == desiredCount)]) == `0`+ // rather than our reading of it. With deployments absent the expression never matches.+ // waitTimeout is capped so a regression fails in 30s rather than the default 40 x 15s.+ WaiterResponse<DescribeServicesResponse> response = ecs.waiter().waitUntilServicesStable(+ DescribeServicesRequest.builder()+ .cluster(clusterName)+ .services(serviceName)+ .build(),+ WaiterOverrideConfiguration.builder()+ .waitTimeout(Duration.ofSeconds(30))+ .build());++ assertThat(response.matched().response()).isPresent();+ assertThat(response.matched().response().get().services().get(0).deployments()).hasSize(1);+ }++ @Test+ @Order(46)+ @DisplayName("DescribeServices - unknown service returns a MISSING failure")+ void describeServicesReportsMissingService() {+ // ECS reports an unresolvable service as a failure rather than erroring, and the+ // ServicesStable waiter fails fast on failures[].reason == MISSING. Dropping it+ // silently would leave that waiter polling for its full timeout.+ DescribeServicesResponse response = ecs.describeServices(DescribeServicesRequest.builder()+ .cluster(clusterName)+ .services("no-such-service-" + suffix)+ .build());++ assertThat(response.services()).isEmpty();+ assertThat(response.failures()).hasSize(1);+ assertThat(response.failures().get(0).reason()).isEqualTo("MISSING");+ assertThat(response.failures().get(0).arn()).endsWith("no-such-service-" + suffix);+ }++ @Test+ @Order(47)@DisplayName("ListServiceDeployments - list deployments")void listServiceDeployments() {List<ServiceDeploymentBrief> briefs = ecs.listServiceDeployments(@@ -830,7 +892,7 @@ class EcsTests {}@Test- @Order(46)+ @Order(48)@DisplayName("UpdateService - update desiredCount to 0")void updateServiceDesiredCount() {Service updated = ecs.updateService(UpdateServiceRequest.builder()@@ -843,7 +905,7 @@ class EcsTests {}@Test- @Order(47)+ @Order(49)@DisplayName("UpdateService - update taskDefinition")void updateServiceTaskDefinition() {Service updated = ecs.updateService(UpdateServiceRequest.builder()@@ -856,7 +918,7 @@ class EcsTests {}@Test- @Order(48)+ @Order(50)@DisplayName("CreateTaskSet - create task set")void createTaskSet() {software.amazon.awssdk.services.ecs.model.TaskSet ts =@@ -920,7 +982,7 @@ class EcsTests {}@Test- @Order(49)+ @Order(51)@DisplayName("DeleteService - delete service")void deleteService() {Service deleted = ecs.deleteService(DeleteServiceRequest.builder()@@ -932,7 +994,7 @@ class EcsTests {}@Test- @Order(50)+ @Order(52)@DisplayName("ListServices - service no longer in list")void listServicesAfterDelete() {List<String> serviceArns = ecs.listServices(ListServicesRequest.builder()@@ -943,7 +1005,7 @@ class EcsTests {}@Test- @Order(51)+ @Order(53)@DisplayName("DeregisterTaskDefinition - deregister revision 1")void deregisterTaskDefinition() {TaskDefinition deregistered = ecs.deregisterTaskDefinition(@@ -955,7 +1017,7 @@ class EcsTests {}@Test- @Order(52)+ @Order(54)@DisplayName("ListTaskDefinitions - filter by ACTIVE")void listTaskDefinitionsActive() {List<String> activeArns = ecs.listTaskDefinitions(ListTaskDefinitionsRequest.builder()@@ -968,7 +1030,7 @@ class EcsTests {}@Test- @Order(53)+ @Order(55)@DisplayName("DeleteTaskDefinitions - delete INACTIVE")void deleteTaskDefinitions() {List<TaskDefinition> deletedDefs = ecs.deleteTaskDefinitions(@@ -981,7 +1043,7 @@ class EcsTests {}@Test- @Order(54)+ @Order(56)@DisplayName("DeleteCluster - fails with running tasks")void deleteClusterFailsWithTasks() {ecs.runTask(RunTaskRequest.builder()@@ -996,7 +1058,7 @@ class EcsTests {}@Test- @Order(55)+ @Order(57)@DisplayName("DeleteCluster - delete after stopping tasks")void deleteCluster() {List<String> running = ecs.listTasks(ListTasksRequest.builder()@@ -1019,7 +1081,7 @@ class EcsTests {}@Test- @Order(56)+ @Order(58)@DisplayName("ListClusters - cluster no longer in list")void listClustersAfterDelete() {List<String> arns = ecs.listClusters(ListClustersRequest.builder().build()).clusterArns();@@ -1027,7 +1089,7 @@ class EcsTests {}@Test- @Order(57)+ @Order(59)@DisplayName("RegisterTaskDefinition - container secrets round trip")void registerTaskDefinitionWithSecrets() {String secretFamily = family + "-secrets";diff --git a/docs/services/ecs.md b/docs/services/ecs.mdindex 601d62a965..1860880184 100644--- a/docs/services/ecs.md+++ b/docs/services/ecs.md@@ -49,10 +49,46 @@ ECS emulates clusters, task definitions, tasks, and services. In the default con| `CreateService` | Create a long-running service || `UpdateService` | Update desired count, task definition, or deployment config || `DeleteService` | Delete a service (supports `force`) |-| `DescribeServices` | Describe one or more services |+| `DescribeServices` | Describe one or more services (includes `deployments`, see below) || `ListServices` | List service ARNs in a cluster || `ListServicesByNamespace` | List services filtered by Cloud Map namespace |+#### Service deployments++An `ACTIVE` service reports exactly one `PRIMARY` entry in `services[].deployments`,+synthesized from the service's current state rather than tracked as a rollout. This is+what AWS's `ServicesStable` waiter accepts on, so `aws ecs wait services-stable`, the+SDK waiters, and Terraform's `aws_ecs_service` all converge normally. A deleted+(`INACTIVE`) service reports an empty list.++`rolloutState` is `COMPLETED` once `runningCount` reaches `desiredCount`, and+`IN_PROGRESS` before that. The deployment `id` is derived from the service ARN and its+task definition, so it is stable across calls and across restarts, and rolls over when+the task definition changes. `createdAt` tracks the deployment rather than the service:+it is the service's creation time until a task-definition change starts a new+deployment, and moves with it thereafter.++Known differences from AWS:++- There is never a second `ACTIVE` deployment draining alongside the `PRIMARY` one;+ Floci swaps the task definition in place.+- `deployments` is reported for every service. AWS omits it for services that use the+ `CODE_DEPLOY` or `EXTERNAL` deployment controller, but Floci does not yet record+ `deploymentController`, and `ECS` is the AWS default.+- `pendingCount` is always `0`, matching the top-level service field.+- `forceNewDeployment` does not mint a new deployment `id`.+- `updatedAt` equals `createdAt`. AWS advances it as a rollout progresses; Floci has no+ intermediate rollout state to report.++#### Unknown services++A service reference that does not resolve is returned in `failures` with+`reason: MISSING` and the ARN the service would have had, rather than being dropped from+the response. `DescribeServices` therefore returns partial results instead of erroring, as+AWS does, and `aws ecs wait services-stable` on a nonexistent service fails immediately+instead of polling for its full timeout. A reference supplied as an ARN is echoed back+unchanged.+### Task Sets| Operation | Description |diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.javaindex a0ce0e296c..7d3eb0288a 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java@@ -8,6 +8,8 @@ import io.github.hectorvent.floci.services.ecs.model.CapacityProvider;import io.github.hectorvent.floci.services.ecs.model.ClusterSetting;import io.github.hectorvent.floci.services.ecs.model.ContainerDefinition;import io.github.hectorvent.floci.services.ecs.model.ContainerInstance;+import io.github.hectorvent.floci.services.ecs.model.Deployment;+import io.github.hectorvent.floci.services.ecs.model.Failure;import io.github.hectorvent.floci.services.ecs.model.ContainerOverride;import io.github.hectorvent.floci.services.ecs.model.EcsCluster;import io.github.hectorvent.floci.services.ecs.model.EcsLoadBalancer;@@ -497,13 +499,16 @@ public class EcsJsonHandler {String cluster = req.has("cluster") ? req.path("cluster").asText() : null;List<String> serviceIds = jsonArrayToList(req.path("services"));- List<EcsServiceModel> found = service.describeServices(cluster, serviceIds, region);+ EcsService.DescribeServicesResult found =+ service.describeServicesDetailed(cluster, serviceIds, region);ObjectNode resp = objectMapper.createObjectNode();ArrayNode arr = objectMapper.createArrayNode();- found.forEach(s -> arr.add(serviceNode(s)));+ found.services().forEach(s -> arr.add(serviceNode(s)));resp.set("services", arr);- resp.set("failures", objectMapper.createArrayNode());+ ArrayNode failures = objectMapper.createArrayNode();+ found.failures().forEach(f -> failures.add(failureNode(f)));+ resp.set("failures", failures);return Response.ok(resp).build();}@@ -1149,6 +1154,34 @@ public class EcsJsonHandler {networkConfig.set("awsvpcConfiguration", awsvpcNode);n.set("networkConfiguration", networkConfig);}+ ArrayNode deployments = objectMapper.createArrayNode();+ service.deploymentsFor(s).forEach(d -> deployments.add(deploymentNode(d)));+ n.set("deployments", deployments);+ return n;+ }++ private ObjectNode failureNode(Failure f) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("arn", f.arn());+ n.put("reason", f.reason());+ if (f.detail() != null) { n.put("detail", f.detail()); }+ return n;+ }++ private ObjectNode deploymentNode(Deployment d) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("id", d.getId());+ n.put("status", d.getStatus());+ n.put("taskDefinition", d.getTaskDefinition());+ n.put("desiredCount", d.getDesiredCount());+ n.put("pendingCount", d.getPendingCount());+ n.put("runningCount", d.getRunningCount());+ n.put("failedTasks", d.getFailedTasks());+ n.put("rolloutState", d.getRolloutState());+ n.put("rolloutStateReason", d.getRolloutStateReason());+ if (d.getLaunchType() != null) { n.put("launchType", d.getLaunchType().name()); }+ if (d.getCreatedAt() != null) { n.put("createdAt", d.getCreatedAt().toEpochMilli() / 1000.0); }+ if (d.getUpdatedAt() != null) { n.put("updatedAt", d.getUpdatedAt().toEpochMilli() / 1000.0); }return n;}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.java b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.javaindex c088d6e795..39b4cab8a2 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.java@@ -14,6 +14,8 @@ import io.github.hectorvent.floci.services.ecs.model.CapacityProvider;import io.github.hectorvent.floci.services.ecs.model.ClusterSetting;import io.github.hectorvent.floci.services.ecs.model.ContainerDefinition;import io.github.hectorvent.floci.services.ecs.model.ContainerInstance;+import io.github.hectorvent.floci.services.ecs.model.Deployment;+import io.github.hectorvent.floci.services.ecs.model.Failure;import io.github.hectorvent.floci.services.ecs.model.ContainerOverride;import io.github.hectorvent.floci.services.ecs.model.EcsCluster;import io.github.hectorvent.floci.services.ecs.model.EcsLoadBalancer;@@ -705,6 +707,7 @@ public class EcsService implements ContainerTeardown {svc.setNetworkConfiguration(networkConfiguration);svc.setStatus("ACTIVE");svc.setCreatedAt(Instant.now());+ svc.setLastDeploymentAt(svc.getCreatedAt());if (tags != null && !tags.isEmpty()) {svc.setTags(new LinkedHashMap<>(tags));}@@ -745,6 +748,7 @@ public class EcsService implements ContainerTeardown {if (taskDefinition != null) {resolveTaskDefinitionOrThrow(taskDefinition, region);svc.setTaskDefinition(taskDefinition);+ svc.setLastDeploymentAt(Instant.now());recordServiceDeployment(svc, taskDefinition, region);}services.put(key, svc);@@ -791,16 +795,43 @@ public class EcsService implements ContainerTeardown {return svc;}+ /** The services that resolved, plus a {@code MISSING} failure for each reference that did not. */+ public record DescribeServicesResult(List<EcsServiceModel> services, List<Failure> failures) {}+public List<EcsServiceModel> describeServices(String clusterRef, List<String> serviceIds, String region) {+ return describeServicesDetailed(clusterRef, serviceIds, region).services();+ }++ /**+ * Resolves each reference, reporting the ones that do not exist as {@code MISSING} failures+ * rather than dropping them. ECS answers a describe for an unknown service with a failure+ * entry, not an error, and its {@code ServicesStable} waiter fails fast on+ * {@code failures[].reason == "MISSING"} — so silently returning an empty list leaves the+ * waiter polling for its full timeout instead of reporting the service does not exist.+ */+ public DescribeServicesResult describeServicesDetailed(String clusterRef, List<String> serviceIds,+ String region) {EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);List<EcsServiceModel> result = new ArrayList<>();+ List<Failure> failures = new ArrayList<>();for (String id : serviceIds) {EcsServiceModel svc = resolveService(cluster.getClusterName(), id, region);if (svc != null) {result.add(svc);+ } else {+ failures.add(Failure.missing(missingServiceArn(cluster, id, region)));}}- return result;+ return new DescribeServicesResult(result, failures);+ }++ /** Echoes an ARN the caller supplied, otherwise builds the ARN the service would have had. */+ private String missingServiceArn(EcsCluster cluster, String serviceRef, String region) {+ if (serviceRef != null && serviceRef.startsWith("arn:")) {+ return serviceRef;+ }+ return regionResolver.buildArn("ecs", region,+ "service/" + cluster.getClusterName() + "/" + serviceRef);}public List<String> listServices(String clusterRef, String region) {@@ -1257,6 +1288,64 @@ public class EcsService implements ContainerTeardown {.toList();}+ /**+ * The deployments of a service, derived from its current state rather than tracked as a+ * rollout. An ACTIVE service always has exactly one PRIMARY deployment: AWS's own+ * {@code ServicesStable} waiter accepts on+ * {@code length(services[?!(length(deployments) == `1` && runningCount == desiredCount)]) == `0`},+ * so reporting none leaves every SDK waiter polling until it times out.+ *+ * <p>A task-definition change is applied in place rather than draining a previous+ * deployment, so there is never a second ACTIVE entry beside the PRIMARY one. An INACTIVE+ * service has no deployments.+ */+ public List<Deployment> deploymentsFor(EcsServiceModel svc) {+ if (svc == null || !"ACTIVE".equals(svc.getStatus())) {+ return List.of();+ }++ String deploymentId = deploymentId(svc);+ boolean converged = svc.getRunningCount() >= svc.getDesiredCount();++ Deployment d = new Deployment();+ d.setId(deploymentId);+ d.setStatus("PRIMARY");+ d.setTaskDefinition(svc.getTaskDefinition());+ d.setDesiredCount(svc.getDesiredCount());+ d.setPendingCount(svc.getPendingCount());+ d.setRunningCount(svc.getRunningCount());+ d.setFailedTasks(0);+ d.setRolloutState(converged ? "COMPLETED" : "IN_PROGRESS");+ d.setRolloutStateReason("ECS deployment " + deploymentId+ + (converged ? " completed." : " in progress."));+ d.setLaunchType(svc.getLaunchType());+ // The deployment's own start time, not the service's: a task-definition change mints a+ // new deployment id, so reporting service creation here would contradict it. Older+ // persisted services predate the field and fall back to the service creation time.+ Instant startedAt = svc.getLastDeploymentAt() != null+ ? svc.getLastDeploymentAt()+ : svc.getCreatedAt();+ d.setCreatedAt(startedAt);+ d.setUpdatedAt(startedAt);+ return List.of(d);+ }++ /**+ * A stable {@code ecs-svc/<id>} identifier derived from the service ARN and its task+ * definition. Deployments are derived per request, so a random id would differ on every+ * {@code DescribeServices} call and read as perpetual drift in clients that persist it.+ * Deriving it from persisted state keeps it identical across calls and across restarts,+ * while still rolling over when the task definition changes.+ */+ private String deploymentId(EcsServiceModel svc) {+ String seed = svc.getServiceArn() + ":" + svc.getTaskDefinition();+ long hash = 0xcbf29ce484222325L;+ for (int i = 0; i < seed.length(); i++) {+ hash = (hash ^ seed.charAt(i)) * 0x100000001b3L;+ }+ return "ecs-svc/" + Long.toUnsignedString(hash);+ }+private void recordServiceDeployment(EcsServiceModel svc, String taskDefinition, String region) {String deploymentId = UUID.randomUUID().toString().replace("-", "");String deploymentArn = regionResolver.buildArn("ecs", region,diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/Deployment.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Deployment.javanew file mode 100644index 0000000000..ff7665138e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Deployment.java@@ -0,0 +1,53 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++/**+ * A deployment of an ECS service, as reported in {@code DescribeServices}'+ * {@code services[].deployments}. Distinct from {@link ServiceDeployment}, which is the+ * separate {@code DescribeServiceDeployments} API shape and carries neither counts nor a+ * rollout state.+ */+@RegisterForReflection+public class Deployment {++ private String id;+ private String status;+ private String taskDefinition;+ private int desiredCount;+ private int pendingCount;+ private int runningCount;+ private int failedTasks;+ private String rolloutState;+ private String rolloutStateReason;+ private LaunchType launchType;+ private Instant createdAt;+ private Instant updatedAt;++ public String getId() { return id; }+ public void setId(String id) { this.id = id; }+ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }+ public String getTaskDefinition() { return taskDefinition; }+ public void setTaskDefinition(String taskDefinition) { this.taskDefinition = taskDefinition; }+ public int getDesiredCount() { return desiredCount; }+ public void setDesiredCount(int desiredCount) { this.desiredCount = desiredCount; }+ public int getPendingCount() { return pendingCount; }+ public void setPendingCount(int pendingCount) { this.pendingCount = pendingCount; }+ public int getRunningCount() { return runningCount; }+ public void setRunningCount(int runningCount) { this.runningCount = runningCount; }+ public int getFailedTasks() { return failedTasks; }+ public void setFailedTasks(int failedTasks) { this.failedTasks = failedTasks; }+ public String getRolloutState() { return rolloutState; }+ public void setRolloutState(String rolloutState) { this.rolloutState = rolloutState; }+ public String getRolloutStateReason() { return rolloutStateReason; }+ public void setRolloutStateReason(String rolloutStateReason) { this.rolloutStateReason = rolloutStateReason; }+ public LaunchType getLaunchType() { return launchType; }+ public void setLaunchType(LaunchType launchType) { this.launchType = launchType; }+ public Instant getCreatedAt() { return createdAt; }+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }+ public Instant getUpdatedAt() { return updatedAt; }+ public void setUpdatedAt(Instant updatedAt) { this.updatedAt = updatedAt; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.javaindex c7e48754b7..39eb4a4033 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.java@@ -21,6 +21,8 @@ public class EcsServiceModel {private int pendingCount;private String status;private Instant createdAt;+ /** When the current deployment began: service creation, or the last task-definition change. */+ private Instant lastDeploymentAt;private String namespace;private String deploymentController;private Map<String, String> tags = new HashMap<>();@@ -56,6 +58,8 @@ public class EcsServiceModel {public Instant getCreatedAt() { return createdAt; }public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }+ public Instant getLastDeploymentAt() { return lastDeploymentAt; }+ public void setLastDeploymentAt(Instant lastDeploymentAt) { this.lastDeploymentAt = lastDeploymentAt; }public String getNamespace() { return namespace; }public void setNamespace(String namespace) { this.namespace = namespace; }diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/Failure.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Failure.javanew file mode 100644index 0000000000..84ea23a254--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Failure.java@@ -0,0 +1,16 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * A per-resource failure returned alongside the results of an ECS {@code Describe*} call.+ * ECS reports a resource it could not find here rather than throwing, so callers get partial+ * results; {@code reason} is {@code MISSING} for a resource that does not exist.+ */+@RegisterForReflection+public record Failure(String arn, String reason, String detail) {++ public static Failure missing(String arn) {+ return new Failure(arn, "MISSING", null);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsDescribeServicesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsDescribeServicesIntegrationTest.javanew file mode 100644index 0000000000..367f237ce2--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsDescribeServicesIntegrationTest.java@@ -0,0 +1,242 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.json.config.JsonPathConfig;+import io.restassured.response.Response;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.endsWith;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.startsWith;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Integration tests for the two {@code DescribeServices} response fields that AWS's+ * {@code ServicesStable} waiter depends on (floci-io/floci#2174).+ *+ * <p>The waiter accepts on+ * {@code length(services[?!(length(deployments) == `1` && runningCount == desiredCount)]) == `0`}+ * and fails fast on {@code failures[].reason == "MISSING"} (botocore+ * {@code ecs/2014-11-13/waiters-2.json}). So an ACTIVE service must report exactly one+ * deployment, and an unknown service must come back as a failure rather than being dropped;+ * getting either wrong leaves {@code aws ecs wait services-stable} and every SDK waiter+ * polling until they time out.+ */+@QuarkusTest+class EcsDescribeServicesIntegrationTest {++ private static final String TARGET = "AmazonEC2ContainerServiceV20141113.";+ private static final String CT = "application/x-amz-json-1.1";++ @BeforeAll+ static void configure() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ private static Response call(String action, String body) {+ return given().contentType(CT).header("X-Amz-Target", TARGET + action)+ .body(body)+ .when().post("/")+ .then().statusCode(200)+ .extract().response();+ }++ private static void seedClusterAndTaskDef(String cluster, String family) {+ call("CreateCluster", "{\"clusterName\":\"" + cluster + "\"}");+ registerTaskDef(family);+ }++ private static void registerTaskDef(String family) {+ call("RegisterTaskDefinition", "{\"family\":\"" + family + "\","+ + "\"containerDefinitions\":[{\"name\":\"web\",\"image\":\"nginx\",\"memory\":128}]}");+ }++ /**+ * Epoch seconds carry 10 significant digits, more than a float holds. RestAssured's default+ * number type is FLOAT_AND_DOUBLE, which silently rounds two timestamps a second apart to the+ * same value, so read them as BigDecimal.+ */+ private static double epochSeconds(Response response, String path) {+ return ((java.math.BigDecimal) response+ .jsonPath(new JsonPathConfig(JsonPathConfig.NumberReturnType.BIG_DECIMAL))+ .get(path)).doubleValue();+ }++ private static Response describe(String cluster, String service) {+ return call("DescribeServices",+ "{\"cluster\":\"" + cluster + "\",\"services\":[\"" + service + "\"]}");+ }++ @Test+ void describeServicesReportsExactlyOnePrimaryDeployment() {+ seedClusterAndTaskDef("dep-cluster-1", "dep-td-1");+ call("CreateService", "{\"cluster\":\"dep-cluster-1\",\"serviceName\":\"dep-svc-1\","+ + "\"taskDefinition\":\"dep-td-1\",\"desiredCount\":0}");++ Response r = describe("dep-cluster-1", "dep-svc-1");+ String taskDefinition = r.path("services[0].taskDefinition");+ int runningCount = r.path("services[0].runningCount");+ int pendingCount = r.path("services[0].pendingCount");++ r.then()+ .body("services", hasSize(1))+ .body("services[0].deployments", hasSize(1))+ .body("services[0].deployments[0].status", equalTo("PRIMARY"))+ .body("services[0].deployments[0].id", startsWith("ecs-svc/"))+ .body("services[0].deployments[0].taskDefinition", equalTo(taskDefinition))+ .body("services[0].deployments[0].desiredCount", equalTo(0))+ .body("services[0].deployments[0].runningCount", equalTo(runningCount))+ .body("services[0].deployments[0].pendingCount", equalTo(pendingCount))+ .body("services[0].deployments[0].failedTasks", equalTo(0))+ .body("services[0].deployments[0].rolloutStateReason",+ startsWith("ECS deployment ecs-svc/"));+ }++ @Test+ void deploymentIdIsStableAcrossCalls() {+ // Deployments are synthesized per request. A random id would change on every call and+ // surface as perpetual drift in any client that persists it, so this is the regression+ // guard for deriving the id from the service ARN and task definition instead.+ seedClusterAndTaskDef("dep-cluster-2", "dep-td-2");+ call("CreateService", "{\"cluster\":\"dep-cluster-2\",\"serviceName\":\"dep-svc-2\","+ + "\"taskDefinition\":\"dep-td-2\",\"desiredCount\":0}");++ String first = describe("dep-cluster-2", "dep-svc-2").path("services[0].deployments[0].id");+ String second = describe("dep-cluster-2", "dep-svc-2").path("services[0].deployments[0].id");++ assertEquals(first, second, "deployment id must not change between DescribeServices calls");+ }++ @Test+ void convergedServiceReportsCompletedRollout() {+ // desiredCount 0 is trivially converged (running 0 >= desired 0), so this asserts the+ // COMPLETED branch without depending on Docker-backed tasks actually starting.+ seedClusterAndTaskDef("dep-cluster-3", "dep-td-3");+ call("CreateService", "{\"cluster\":\"dep-cluster-3\",\"serviceName\":\"dep-svc-3\","+ + "\"taskDefinition\":\"dep-td-3\",\"desiredCount\":0}");++ describe("dep-cluster-3", "dep-svc-3").then()+ .body("services[0].deployments[0].rolloutState", equalTo("COMPLETED"))+ .body("services[0].deployments[0].rolloutStateReason", endsWith("completed."));+ }++ @Test+ void deploymentIdRollsOverWhenTaskDefinitionChanges() {+ seedClusterAndTaskDef("dep-cluster-5", "dep-td-5a");+ call("CreateService", "{\"cluster\":\"dep-cluster-5\",\"serviceName\":\"dep-svc-5\","+ + "\"taskDefinition\":\"dep-td-5a\",\"desiredCount\":0}");+ String before = describe("dep-cluster-5", "dep-svc-5").path("services[0].deployments[0].id");++ registerTaskDef("dep-td-5b");+ call("UpdateService", "{\"cluster\":\"dep-cluster-5\",\"service\":\"dep-svc-5\","+ + "\"taskDefinition\":\"dep-td-5b\"}");++ String after = describe("dep-cluster-5", "dep-svc-5").path("services[0].deployments[0].id");+ assertNotEquals(before, after,+ "a new task definition is a new deployment and must get a new id");+ }++ @Test+ void newDeploymentCarriesItsOwnStartTimeNotTheServiceCreationTime() throws Exception {+ // A task-definition change mints a new deployment id, so the timestamps have to move with+ // it. Reporting the service's creation time would contradict the new id and misrepresent+ // when the deployment actually started.+ seedClusterAndTaskDef("dep-cluster-11", "dep-td-11a");+ call("CreateService", "{\"cluster\":\"dep-cluster-11\",\"serviceName\":\"dep-svc-11\","+ + "\"taskDefinition\":\"dep-td-11a\",\"desiredCount\":0}");++ Response before = describe("dep-cluster-11", "dep-svc-11");+ double createdAtBefore = epochSeconds(before, "services[0].deployments[0].createdAt");+ String idBefore = before.path("services[0].deployments[0].id");++ Thread.sleep(1100);+ registerTaskDef("dep-td-11b");+ call("UpdateService", "{\"cluster\":\"dep-cluster-11\",\"service\":\"dep-svc-11\","+ + "\"taskDefinition\":\"dep-td-11b\"}");++ Response after = describe("dep-cluster-11", "dep-svc-11");+ double createdAtAfter = epochSeconds(after, "services[0].deployments[0].createdAt");+ double serviceCreatedAt = epochSeconds(after, "services[0].createdAt");++ assertNotEquals(idBefore, after.path("services[0].deployments[0].id"));+ assertTrue(createdAtAfter > createdAtBefore,+ "a new deployment must carry a later createdAt than the one it replaced");+ assertTrue(createdAtAfter > serviceCreatedAt,+ "the deployment started after the service was created, so its createdAt must be later");+ }++ @Test+ void createAndUpdateServiceEchoTheSameDeploymentShape() {+ seedClusterAndTaskDef("dep-cluster-6", "dep-td-6");++ call("CreateService", "{\"cluster\":\"dep-cluster-6\",\"serviceName\":\"dep-svc-6\","+ + "\"taskDefinition\":\"dep-td-6\",\"desiredCount\":0}").then()+ .body("service.deployments", hasSize(1))+ .body("service.deployments[0].status", equalTo("PRIMARY"));++ call("UpdateService", "{\"cluster\":\"dep-cluster-6\",\"service\":\"dep-svc-6\","+ + "\"desiredCount\":0}").then()+ .body("service.deployments", hasSize(1))+ .body("service.deployments[0].status", equalTo("PRIMARY"));+ }++ @Test+ void unknownServiceIsReportedAsAMissingFailureRatherThanDroppedSilently() {+ // ECS answers a describe for an unknown service with a failure entry, not an error, and+ // the ServicesStable waiter fails fast on failures[].reason == "MISSING". Returning an+ // empty services list with no failure leaves that waiter polling for its full timeout.+ seedClusterAndTaskDef("dep-cluster-8", "dep-td-8");++ describe("dep-cluster-8", "no-such-service").then()+ .body("services", hasSize(0))+ .body("failures", hasSize(1))+ .body("failures[0].reason", equalTo("MISSING"))+ .body("failures[0].arn", endsWith(":service/dep-cluster-8/no-such-service"));+ }++ @Test+ void describeMixesFoundServicesWithMissingOnes() {+ seedClusterAndTaskDef("dep-cluster-9", "dep-td-9");+ call("CreateService", "{\"cluster\":\"dep-cluster-9\",\"serviceName\":\"dep-svc-9\","+ + "\"taskDefinition\":\"dep-td-9\",\"desiredCount\":0}");++ call("DescribeServices", "{\"cluster\":\"dep-cluster-9\","+ + "\"services\":[\"dep-svc-9\",\"ghost-service\"]}").then()+ .body("services", hasSize(1))+ .body("services[0].serviceName", equalTo("dep-svc-9"))+ .body("failures", hasSize(1))+ .body("failures[0].reason", equalTo("MISSING"))+ .body("failures[0].arn", endsWith(":service/dep-cluster-9/ghost-service"));+ }++ @Test+ void aServiceArnThatDoesNotExistIsEchoedBackInTheFailure() {+ seedClusterAndTaskDef("dep-cluster-10", "dep-td-10");+ String arn = "arn:aws:ecs:us-east-1:000000000000:service/dep-cluster-10/absent";++ call("DescribeServices", "{\"cluster\":\"dep-cluster-10\",\"services\":[\"" + arn + "\"]}").then()+ .body("failures", hasSize(1))+ .body("failures[0].arn", equalTo(arn))+ .body("failures[0].reason", equalTo("MISSING"));+ }++ @Test+ void deletedServiceReportsAnEmptyDeploymentListRatherThanOmittingIt() {+ // AWS's ServicesStable waiter fails an INACTIVE service on status, so an empty list is+ // correct here, but the key must still be present, matching how moto renders it.+ seedClusterAndTaskDef("dep-cluster-7", "dep-td-7");+ call("CreateService", "{\"cluster\":\"dep-cluster-7\",\"serviceName\":\"dep-svc-7\","+ + "\"taskDefinition\":\"dep-td-7\",\"desiredCount\":0}");+ call("DeleteService", "{\"cluster\":\"dep-cluster-7\",\"service\":\"dep-svc-7\"}");++ describe("dep-cluster-7", "dep-svc-7").then()+ .body("services[0].status", equalTo("INACTIVE"))+ .body("services[0].deployments", hasSize(0));+ }+}