Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ecs): complete the fargate launch surface (#4017)
Abhigyabf1152e144e6
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcsFargateTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcsFargateTest.javanew file mode 100644index 0000000000..6a12e16986--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcsFargateTest.java@@ -0,0 +1,221 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;+import software.amazon.awssdk.services.ec2.Ec2Client;+import software.amazon.awssdk.services.ec2.model.DescribeSubnetsRequest;+import software.amazon.awssdk.services.ecs.EcsClient;+import software.amazon.awssdk.services.ecs.model.AwsVpcConfiguration;+import software.amazon.awssdk.services.ecs.model.CapacityProviderStrategyItem;+import software.amazon.awssdk.services.ecs.model.Compatibility;+import software.amazon.awssdk.services.ecs.model.ContainerDefinition;+import software.amazon.awssdk.services.ecs.model.CreateClusterRequest;+import software.amazon.awssdk.services.ecs.model.DeleteTaskDefinitionsRequest;+import software.amazon.awssdk.services.ecs.model.DeregisterTaskDefinitionRequest;+import software.amazon.awssdk.services.ecs.model.DescribeTaskDefinitionRequest;+import software.amazon.awssdk.services.ecs.model.DescribeTasksRequest;+import software.amazon.awssdk.services.ecs.model.DescribeTasksResponse;+import software.amazon.awssdk.services.ecs.model.EcsException;+import software.amazon.awssdk.services.ecs.model.EphemeralStorage;+import software.amazon.awssdk.services.ecs.model.LaunchType;+import software.amazon.awssdk.services.ecs.model.NetworkConfiguration;+import software.amazon.awssdk.services.ecs.model.NetworkMode;+import software.amazon.awssdk.services.ecs.model.RegisterTaskDefinitionRequest;+import software.amazon.awssdk.services.ecs.model.RunTaskRequest;+import software.amazon.awssdk.services.ecs.model.StopTaskRequest;+import software.amazon.awssdk.services.ecs.model.Task;+import software.amazon.awssdk.services.ecs.model.TaskDefinition;++import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++/**+ * The Fargate launch type through a real SDK client: the members the generated model carries have+ * to come back populated, not just be accepted on the way in.+ */+@DisplayName("ECS Fargate launch type")+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class EcsFargateTest {++ private static EcsClient ecs;+ private static Ec2Client ec2;+ private static String clusterName;+ private static String family;+ private static String subnetId;+ private static String taskArn;++ @BeforeAll+ static void setup() {+ ecs = TestFixtures.ecsClient();+ ec2 = TestFixtures.ec2Client();+ String suffix = String.valueOf(System.currentTimeMillis() % 100000);+ clusterName = "sdk-fargate-cluster-" + suffix;+ family = "sdk-fargate-task-" + suffix;+ subnetId = ec2.describeSubnets(DescribeSubnetsRequest.builder().build())+ .subnets().get(0).subnetId();+ ecs.createCluster(CreateClusterRequest.builder().clusterName(clusterName).build());+ }++ @AfterAll+ static void cleanup() {+ if (ecs == null) {+ return;+ }+ try {+ if (taskArn != null) {+ ecs.stopTask(StopTaskRequest.builder().cluster(clusterName).task(taskArn).build());+ }+ } catch (EcsException ignored) {+ // The task may already have stopped; cleanup must not fail the run.+ }+ try {+ ecs.deregisterTaskDefinition(DeregisterTaskDefinitionRequest.builder()+ .taskDefinition(family + ":1").build());+ ecs.deleteTaskDefinitions(DeleteTaskDefinitionsRequest.builder()+ .taskDefinitions(family + ":1").build());+ } catch (EcsException ignored) {+ // Same: a failed registration leaves nothing to clean up.+ }+ ecs.close();+ ec2.close();+ }++ @Test+ @Order(1)+ @DisplayName("RegisterTaskDefinition - a Fargate definition round-trips its members")+ void registerFargateTaskDefinition() {+ TaskDefinition registered = ecs.registerTaskDefinition(RegisterTaskDefinitionRequest.builder()+ .family(family)+ .requiresCompatibilities(Compatibility.FARGATE)+ .networkMode(NetworkMode.AWSVPC)+ .cpu("512")+ .memory("1024")+ .ephemeralStorage(EphemeralStorage.builder().sizeInGiB(40).build())+ .containerDefinitions(ContainerDefinition.builder()+ .name("app")+ .image("nginx:alpine")+ .essential(true)+ .user("1000:1000")+ .workingDirectory("/srv")+ .readonlyRootFilesystem(true)+ .stopTimeout(30)+ .build())+ .build()).taskDefinition();++ assertThat(registered.compatibilitiesAsStrings()).contains("FARGATE");+ assertThat(registered.ephemeralStorage().sizeInGiB()).isEqualTo(40);+ assertThat(registered.registeredAt()).isNotNull();++ TaskDefinition described = ecs.describeTaskDefinition(DescribeTaskDefinitionRequest.builder()+ .taskDefinition(family).build()).taskDefinition();+ ContainerDefinition container = described.containerDefinitions().get(0);+ assertThat(described.ephemeralStorage().sizeInGiB()).isEqualTo(40);+ assertThat(container.user()).isEqualTo("1000:1000");+ assertThat(container.workingDirectory()).isEqualTo("/srv");+ assertThat(container.readonlyRootFilesystem()).isTrue();+ assertThat(container.stopTimeout()).isEqualTo(30);+ }++ @Test+ @Order(2)+ @DisplayName("RegisterTaskDefinition - a size Fargate does not offer is rejected")+ void rejectsAnInvalidFargateSize() {+ assertThatThrownBy(() -> ecs.registerTaskDefinition(RegisterTaskDefinitionRequest.builder()+ .family(family + "-invalid")+ .requiresCompatibilities(Compatibility.FARGATE)+ .networkMode(NetworkMode.AWSVPC)+ .cpu("256")+ .memory("4096")+ .containerDefinitions(ContainerDefinition.builder()+ .name("app").image("nginx:alpine").build())+ .build()))+ .isInstanceOf(EcsException.class)+ .hasMessageContaining("No Fargate configuration exists");+ }++ @Test+ @Order(3)+ @DisplayName("RunTask - a Fargate task reports its platform, ENI and ephemeral storage")+ void runFargateTask() {+ List<Task> tasks = ecs.runTask(RunTaskRequest.builder()+ .cluster(clusterName)+ .taskDefinition(family)+ .launchType(LaunchType.FARGATE)+ .enableExecuteCommand(true)+ .networkConfiguration(NetworkConfiguration.builder()+ .awsvpcConfiguration(AwsVpcConfiguration.builder()+ .subnets(subnetId)+ .build())+ .build())+ .build()).tasks();++ assertThat(tasks).hasSize(1);+ Task task = tasks.get(0);+ taskArn = task.taskArn();++ assertThat(task.launchType()).isEqualTo(LaunchType.FARGATE);+ assertThat(task.platformVersion()).isNotBlank();+ assertThat(task.platformFamily()).isEqualTo("Linux");+ assertThat(task.ephemeralStorage().sizeInGiB()).isEqualTo(40);+ assertThat(task.enableExecuteCommand()).isTrue();+ assertThat(task.group()).isEqualTo("family:" + family);+ assertThat(task.attachments()).hasSize(1);+ assertThat(task.attachments().get(0).type()).isEqualTo("ElasticNetworkInterface");+ assertThat(task.attachments().get(0).details())+ .anySatisfy(detail -> assertThat(detail.name()).isEqualTo("privateIPv4Address"));++ Task described = ecs.describeTasks(DescribeTasksRequest.builder()+ .cluster(clusterName)+ .tasks(taskArn)+ .build()).tasks().get(0);+ assertThat(described.connectivityAsString()).isEqualTo("CONNECTED");+ assertThat(described.healthStatusAsString()).isNotBlank();+ assertThat(described.version()).isPositive();+ }++ @Test+ @Order(4)+ @DisplayName("RunTask - FARGATE_SPOT places through the capacity provider")+ void runTaskOnFargateSpot() {+ Task task = ecs.runTask(RunTaskRequest.builder()+ .cluster(clusterName)+ .taskDefinition(family)+ .capacityProviderStrategy(CapacityProviderStrategyItem.builder()+ .capacityProvider("FARGATE_SPOT")+ .weight(1)+ .build())+ .networkConfiguration(NetworkConfiguration.builder()+ .awsvpcConfiguration(AwsVpcConfiguration.builder()+ .subnets(subnetId)+ .build())+ .build())+ .build()).tasks().get(0);++ assertThat(task.capacityProviderName()).isEqualTo("FARGATE_SPOT");+ // A task reports the launch type its capacity provider resolves to, alongside the provider.+ assertThat(task.launchType()).isEqualTo(LaunchType.FARGATE);++ ecs.stopTask(StopTaskRequest.builder()+ .cluster(clusterName).task(task.taskArn()).build());+ }++ @Test+ @Order(6)+ @DisplayName("DescribeTasks - an unknown reference comes back as MISSING")+ void describeReportsMissingRatherThanDroppingTheReference() {+ DescribeTasksResponse tasks = ecs.describeTasks(DescribeTasksRequest.builder()+ .cluster(clusterName)+ .tasks("00000000000000000000000000000000")+ .build());+ assertThat(tasks.tasks()).isEmpty();+ assertThat(tasks.failures()).singleElement()+ .satisfies(failure -> assertThat(failure.reason()).isEqualTo("MISSING"));+ }+}diff --git a/docs/services/ecs.md b/docs/services/ecs.mdindex afedf6d7a6..8072fd5337 100644--- a/docs/services/ecs.md+++ b/docs/services/ecs.md@@ -5,6 +5,11 @@ECS emulates clusters, task definitions, tasks, and services. In the default configuration tasks run as real Docker containers. Set `mock: true` (enabled automatically in tests) to run tasks as in-process stubs without Docker.+A value an enum-typed member does not have is rejected with `InvalidParameterException` rather+than treated as absent. That matters more than it sounds: a `launchType` of `EC22` silently+ignored would fall through to Floci's default and place the task on Fargate, which is neither+what the caller asked for nor what AWS answers.+## Supported Operations### Clusters@@ -30,11 +35,59 @@ ECS emulates clusters, task definitions, tasks, and services. In the default con| `DeregisterTaskDefinition` | Mark a revision INACTIVE || `DeleteTaskDefinitions` | Delete one or more task definitions |-`runtimePlatform` and a container's `logConfiguration` are stored and returned exactly as-registered, so a client that reads back what it wrote (Terraform, or a deploy tool verifying its-own `RegisterTaskDefinition`) sees no drift. `runtimePlatform` does not change where a local task+A task definition round-trips whole. Members Floci acts on are modelled+(`ephemeralStorage`, `pidMode`, `ipcMode`, `runtimePlatform`, and at container level `dependsOn`,+`startTimeout`, `stopTimeout`, `user`, `workingDirectory`, `readonlyRootFilesystem`,+`environmentFiles`, `dockerLabels`, `repositoryCredentials` and the rest); everything else it does+not act on, such as `proxyConfiguration`, `linuxParameters`, `ulimits`, `resourceRequirements`,+`systemControls` and placement constraints, is kept verbatim and returned as registered. A client+that reads back what it wrote (Terraform, or a deploy tool verifying its own+`RegisterTaskDefinition`) sees no drift. `runtimePlatform` does not change where a local taskruns: Floci launches every task on the host's own architecture.+The round trip reaches inside the members Floci does parse. A port mapping keeps its `name`,+`appProtocol` and `containerPortRange`, which is what a service's `serviceConnectConfiguration`+and `vpcLatticeConfigurations` reference by name, and a volume keeps the configurations Floci+backs with nothing: `dockerVolumeConfiguration`, `fsxWindowsFileServerVolumeConfiguration`,+`s3filesVolumeConfiguration` and `configuredAtLaunch`.++`compatibilities` is derived from the definition rather than echoed from+`requiresCompatibilities`: ECS reports the launch types a definition actually works on, so an+`awsvpc` definition with a valid Fargate size pair and no Fargate-unsupported parameters comes+back as `["EC2", "FARGATE"]` even when it never asked for FARGATE. `EXTERNAL` is added for any+network mode other than `awsvpc`, which ECS Anywhere instances do not support. The derivation runs+Fargate's own registration rules, so it can never disagree with what `requiresCompatibilities:+["FARGATE"]` would have accepted.++`requiresAttributes` names the container instance capabilities the definition needs for EC2+placement. ECS derives these from the container agent's capability model, which AWS does not+publish in full, so Floci derives the subset whose names appear verbatim in the AWS documentation:+the base `com.amazonaws.ecs.capability.docker-remote-api.1.18`, `ecs.capability.task-eni` for+`awsvpc`, `com.amazonaws.ecs.capability.task-iam-role` (or+`...task-iam-role-network-host` under `host` networking) for a `taskRoleArn`,+`com.amazonaws.ecs.capability.logging-driver.<driver>` per container log driver,+`com.amazonaws.ecs.capability.ecr-auth` for an ECR image, and+`com.amazonaws.ecs.capability.privileged-container`. Capabilities outside that set are not+reported.++A revision goes ACTIVE, then INACTIVE on `DeregisterTaskDefinition` (which stamps+`deregisteredAt`), then `DELETE_IN_PROGRESS` on `DeleteTaskDefinitions` (which stamps+`deleteRequestedAt`). Deleting a revision that has not been deregistered is refused, as is a+reference that names only the family: `DeleteTaskDefinitions` takes a revision, at most 10 per+call. A deleted revision is not dropped, because AWS keeps describing it and the tasks already on+it keep running; it just cannot start anything new, so `RunTask`, `CreateService` and+`UpdateService` refuse it.++At launch, a container's `dependsOn` decides the start order, and a `COMPLETE`, `SUCCESS` or+`HEALTHY` condition holds the dependent container until the dependency gets there. The wait is+bounded by the dependent container's `startTimeout`, defaulting to 60 seconds rather than AWS's+longer agent default, because `RunTask` here answers synchronously. A container's `cpu` becomes its+CPU shares, its `memory` its hard limit, and a container without a `memory` of its own is capped at+the task's; the task's `cpu` becomes a CPU quota. `stopTimeout` is the grace period the container gets+on teardown; a container that does not ask for one gets 5 seconds rather than AWS's 30, because+`StopTask` here answers synchronously and most containers ignore SIGTERM as PID 1. A container+still running when its grace period is up is killed, so its exit code is always reported.+`firelensConfiguration` is stored and returned the same way. `RegisterTaskDefinition` rejects amissing or unsupported `type` (`fluentd` and `fluentbit` only), and a task using `awsfirelens`must name exactly one router: a task definition with two FireLens routers, or a router publishing@@ -76,12 +129,11 @@ FirelensConfiguration config file from 's3'`, and rejects a `config-file-value`object ARN with `Invalid arn syntax`. A Fargate task can still take its config from S3 the way AWSdocuments, by giving the aws-for-fluent-bit init process its `aws_fluent_bit_init_s3_*`environment variables. ECS never inspects those and Floci passes them through, so that-registration is accepted here too; it fetches nothing locally either, because Floci serves no ECS-task metadata endpoint, which the init process reads before downloading.-Floci also does not validate a task definition's `compatibilities` /+registration is accepted here too; the init process reads the task metadata endpoint before+downloading.+Floci does not validate a task definition's `compatibilities` /`requiresCompatibilities` against `RunTask` `launchType`; a Fargate-compatible-definition can still be run with `launchType=EC2` (and the reverse) the same-way a missing metadata endpoint is accepted at registration.+definition can still be run with `launchType=EC2` (and the reverse).On an EC2-compatible task definition Floci reads the object from its own S3, writes it to thefixed `external.conf` path next to the generated config (`/fluent-bit/etc/external.conf` or`/fluentd/etc/external.conf`), and includes it from there, matching the paths the ECS agent uses.@@ -107,6 +159,89 @@ cycles involving both volume inheritance and log routing are rejected before con| `UpdateTaskProtection` | Set scale-in protection for tasks || `GetTaskProtection` | Get current task protection state |+### Fargate++A task definition that declares `FARGATE` in `requiresCompatibilities` is held to Fargate's rules+at registration:++- `awsvpc` network mode.+- A task-level `cpu` and `memory` forming one of the documented pairs, from 256 CPU units through+ 32768 (the 32 vCPU tier offers only 60 GB, 120 GB and 244 GB), in CPU units or the `1 vCPU` and+ `1 GB` string forms. Windows rules out the sub-vCPU sizes.+- An `ephemeralStorage.sizeInGiB` between 21 and 200.+- None of the parameters that are not valid in a Fargate task: `disableNetworking`,+ `dnsSearchDomains`, `dnsServers`, `dockerSecurityOptions`, `extraHosts`, a `GPU`+ `resourceRequirements` entry, `ipcMode`, `links`, `placementConstraints`, `privileged`,+ `linuxParameters.maxSwap`, `linuxParameters.swappiness`, a `pidMode` other than `task`, or a+ host volume with a `sourcePath`. All of them are accepted on an EC2-compatible definition.+- A `dependsOn` graph that names only containers of the same task definition and has no cycle.++A launched Fargate task reports what AWS reports: `platformVersion` (with `LATEST` resolved to a+concrete version, as AWS resolves it) and `platformFamily` (`Linux`, or the Windows Server family+from the task definition's `runtimePlatform.operatingSystemFamily`), `connectivity` and+`connectivityAt`, `healthStatus`, `stopCode`, `version`, `availabilityZone`, `attributes` with+`ecs.cpu-architecture`, `pullStartedAt` / `pullStoppedAt` / `stoppingAt` / `executionStoppedAt`,+`ephemeralStorage` and `fargateEphemeralStorage`, and `enableExecuteCommand`. `overrides` is+always present with one `containerOverrides` entry per container, carrying whatever the request+overrode, which is how AWS answers a task nobody overrode. `group` defaults to `family:<family>`+for a `RunTask` and is `service:<name>` for a service's tasks. A container that asked for no CPU+units reports `"cpu": "0"`, as on AWS.++A task's `attachments` entry is an `ElasticNetworkInterface` carrying `subnetId`,+`networkInterfaceId`, `macAddress`, `privateDnsName` and `privateIPv4Address`. `DescribeTasks` and+`DescribeServices` report tags only when the request asks for them with `include: ["TAGS"]`, as+`DescribeTaskDefinition` already did. A task `DescribeTasks` cannot resolve comes back as a+`MISSING` entry in `failures`, which is what the `TasksRunning` and `TasksStopped` waiters treat+as terminal.++A created service reports the documented defaults: `propagateTags` is `NONE` and+`healthCheckGracePeriodSeconds` is `0` when the request sets neither. A `role` is accepted only on+a load-balanced service whose task definition does not use `awsvpc`, which is the only case AWS+permits it in.++`RunTask` places at most 10 tasks per call and rejects `propagateTags: SERVICE`, which is a+service-only option; `TASK_DEFINITION` copies the task definition's tags onto each task.+`StartTask` requires the `containerInstances` it places onto, at most 10 of them.++On `UpdateService`, the changes that start new tasks roll the deployment: the task definition, the+network configuration, the load balancers, the service registries, the Service Connect+configuration, and `forceNewDeployment`. The ones AWS documents as not triggering a deployment+(`desiredCount`, `deploymentConfiguration`, `enableExecuteCommand`, `enableECSManagedTags`,+`propagateTags`, `healthCheckGracePeriodSeconds`, `availabilityZoneRebalancing`, the capacity+provider strategy and the placement members) are applied without rolling anything.++Every `awsvpc` task gets a real ENI in the subnet it asked for, in Docker and in mock mode alike,+and reports it as an `attachments` entry with its `networkInterfaceId`, `privateIPv4Address` and+`subnetId`; the task's containers report the same interface in `networkInterfaces`. A subnet that+does not exist fails the request rather than being ignored. While the task runs, `ec2+DescribeNetworkInterfaces` reports that ENI as `in-use` and refuses to delete it, so it never+answers a search for a free interface; it carries no EC2 attachment, every member of one naming an+instance that a task does not have. The ECS attachment is reported as `DELETED` once the task+stops, and the ENI is released. Security-group enforcement+(`FLOCI_NETWORK_SECURITY_GROUP_ENFORCEMENT_ENABLED`) adds packet filtering on top of the ENI; it is+not needed for the ENI itself.++#### Capacity providers++`capacityProviderStrategy` is honoured on `RunTask` and `CreateService`, including the built-in+`FARGATE` and `FARGATE_SPOT` providers. Tasks are spread the way ECS spreads them: the single entry+that declares a `base` is filled first, then the rest are split by weight, with the remainder of+the integer split going to the heaviest entries. A strategy and a `launchType` in the same request+are rejected, as is an unknown provider or a second `base`, and a cluster's+`defaultCapacityProviderStrategy` applies when a request carries neither. The documented bounds+are enforced: at most 20 providers in a strategy, a `weight` of 0 to 1,000 and a `base` of 0 to+100,000. A provider of `weight` 0 places nothing beyond its base, so a strategy naming several+providers that all weigh 0 is rejected; a lone provider of `weight` 0 still places the tasks,+since the request named no alternative.++A task placed through a provider reports `capacityProviderName` **and** the `launchType` that+provider resolves to. A service reports one or the other: `DescribeServices` omits `launchType`+for a service created with a strategy, and omits `capacityProviderStrategy` for one created with a+launch type, which is what AWS documents for the `Service` shape.++With no launch type, no strategy and no cluster default, a task keeps Floci's `FARGATE` default: a+local cluster has no container instances, so an EC2 default would have nowhere to place it.+### Services| Operation | Description |@@ -235,6 +370,10 @@ unchanged.| `UntagResource` | Remove tags from a resource || `ListTagsForResource` | List tags on a resource |+Every operation that takes `tags` holds it to the limits ECS documents: at most 50 tags, a key of+1 to 128 characters and a value of up to 256. The count is taken from the request rather than the+parsed map, so 51 entries that collapse to fewer distinct keys are still rejected.+### Account Settings & Attributes| Operation | Description |@@ -258,7 +397,7 @@ unchanged.## Configuration-Docker-backed `awsvpc` tasks receive an emulated ENI and share one protected network namespace across their containers when `FLOCI_NETWORK_SECURITY_GROUP_ENFORCEMENT_ENABLED=true`. A task without explicit security groups uses its subnet VPC's default group. Containers in the same task can communicate over localhost. Bridge and host task networking do not attach task-level `awsvpc` security groups. Mock mode reports control-plane state and does not enforce packet filtering.+Every `awsvpc` task receives an ENI in its subnet. With `FLOCI_NETWORK_SECURITY_GROUP_ENFORCEMENT_ENABLED=true`, a Docker-backed task's containers additionally share one protected network namespace built around that ENI, and packets are filtered against its security groups. A task without explicit security groups uses its subnet VPC's default group. Containers in the same task can communicate over localhost. Bridge and host task networking do not attach task-level `awsvpc` security groups. Mock mode reports control-plane state, including the ENI, and does not enforce packet filtering.| Variable | Default | Description ||---|---|---|@@ -313,7 +452,7 @@ A task's `efsVolumeConfiguration` volumes are backed by shared local Docker volu### Mock mode-Set `FLOCI_SERVICES_ECS_MOCK=true` to run without Docker. In this mode tasks skip container launch and immediately transition to `RUNNING`, then to `STOPPED` when stopped. This is the recommended mode for unit/integration tests and CI pipelines where Docker-in-Docker is unavailable.+Set `FLOCI_SERVICES_ECS_MOCK=true` to run without Docker. In this mode tasks skip container launch and immediately transition to `RUNNING`, then to `STOPPED` when stopped. The task still reports a container per container definition and, for `awsvpc`, a real ENI, so a client reading `containers[]` or waiting on the task's address behaves as it does against AWS; nothing is running behind those containers, so no logs are streamed. This is the recommended mode for unit/integration tests and CI pipelines where Docker-in-Docker is unavailable.```yaml# docker-compose.yml — CI / test environmentdiff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex 030798a7d7..ff90127b43 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -8309,16 +8309,57 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {return ni;}- /** Deletes a standalone ENI. AWS refuses while it is still attached, floci-kt9. */+ /**+ * Deletes a standalone ENI. AWS refuses while it is still attached, floci-kt9, and equally+ * while a service holds it: {@link #holdNetworkInterfaceForService} leaves no attachment+ * behind, so the status is what says the interface is spoken for.+ */public void deleteNetworkInterface(String region, String networkInterfaceId) {NetworkInterface ni = requireStandaloneNetworkInterface(region, networkInterfaceId);- if (ni.getAttachment() != null) {+ if (ni.getAttachment() != null || "in-use".equals(ni.getStatus())) {throw new AwsException("InvalidParameterValue","Network interface '" + networkInterfaceId + "' is currently in use", 400);}networkInterfaces.delete(key(region, networkInterfaceId));}+ /**+ * Marks an ENI as held by an AWS service rather than by an instance in this account, the state+ * a running ECS task's interface is in. DescribeNetworkInterfaces documents the status rule+ * this rests on: an interface that is not attached is {@code available}, one that is attached+ * is {@code in-use}, and AWS does not let the account delete a task's interface while the task+ * runs.+ *+ * <p>No attachment is synthesised. Every member AWS documents on one describes an instance+ * ({@code instanceId}, {@code instanceOwnerId} "The AWS account ID of the owner of the+ * instance", {@code deviceIndex} "The device index ... on the instance"), and a task has no+ * instance in the account to name there.+ */+ public void holdNetworkInterfaceForService(String region, String networkInterfaceId) {+ NetworkInterface ni = requireStandaloneNetworkInterface(region, networkInterfaceId);+ if (ni.getAttachment() != null) {+ throw new AwsException("InvalidNetworkInterface.InUse",+ "Interface: '" + networkInterfaceId + "' is currently in use.", 400);+ }+ ni.setStatus("in-use");+ networkInterfaces.put(key(region, networkInterfaceId), ni);+ }++ /**+ * Returns a service-held ENI to {@code available}, the mirror of+ * {@link #holdNetworkInterfaceForService}. Silent on an interface that is already gone, or one+ * an instance holds, so a teardown that runs twice is harmless and cannot free an attachment+ * that AttachNetworkInterface owns.+ */+ public void releaseNetworkInterfaceFromService(String region, String networkInterfaceId) {+ NetworkInterface ni = networkInterfaces.get(key(region, networkInterfaceId)).orElse(null);+ if (ni == null || ni.getAttachment() != null) {+ return;+ }+ ni.setStatus("available");+ networkInterfaces.put(key(region, networkInterfaceId), ni);+ }+/*** Attaches a standalone ENI to a running/stopped instance at the given device index,* the attach-eni example's runtime pattern (its user-data script calls this via the AWS CLIdiff --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 e46479e0de..51cdac028c 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@@ -6,13 +6,17 @@ import io.github.hectorvent.floci.services.ecs.container.HostVolumePolicy;import io.github.hectorvent.floci.services.ecs.model.Attribute;import io.github.hectorvent.floci.services.ecs.model.AwsVpcConfiguration;import io.github.hectorvent.floci.services.ecs.model.CapacityProvider;+import io.github.hectorvent.floci.services.ecs.model.CapacityProviderStrategyItem;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.ContainerDependency;import io.github.hectorvent.floci.services.ecs.model.ContainerInstance;import io.github.hectorvent.floci.services.ecs.model.ContainerOverride;import io.github.hectorvent.floci.services.ecs.model.CreateClusterRequest;import io.github.hectorvent.floci.services.ecs.model.CreateServiceRequest;import io.github.hectorvent.floci.services.ecs.model.CreateTaskSetRequest;+import io.github.hectorvent.floci.services.ecs.model.EnvironmentFile;+import io.github.hectorvent.floci.services.ecs.model.EphemeralStorage;import io.github.hectorvent.floci.services.ecs.model.FirelensConfiguration;import io.github.hectorvent.floci.services.ecs.model.HealthCheck;import io.github.hectorvent.floci.services.ecs.model.EcsCluster;@@ -35,9 +39,10 @@ import io.github.hectorvent.floci.services.ecs.model.ServiceDeployment;import io.github.hectorvent.floci.services.ecs.model.ServiceRevision;import io.github.hectorvent.floci.services.ecs.model.Secret;import io.github.hectorvent.floci.services.ecs.model.TaskDefinition;+import io.github.hectorvent.floci.services.ecs.model.TaskOverride;import io.github.hectorvent.floci.services.ecs.model.TaskSet;-import io.github.hectorvent.floci.services.ecs.model.UpdateServiceRequest;import io.github.hectorvent.floci.services.ecs.model.EfsVolumeConfiguration;+import io.github.hectorvent.floci.services.ecs.model.UpdateServiceRequest;import io.github.hectorvent.floci.services.ecs.model.Volume;import io.github.hectorvent.floci.services.ecs.model.VolumeFrom;import com.fasterxml.jackson.databind.JsonNode;@@ -49,11 +54,13 @@ import jakarta.inject.Inject;import jakarta.ws.rs.core.Response;import java.util.ArrayList;+import java.util.Arrays;import java.util.HashMap;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Set;+import java.util.TreeSet;@ApplicationScopedpublic class EcsJsonHandler {@@ -87,14 +94,14 @@ public class EcsJsonHandler {case "UpdateCluster" -> handleUpdateCluster(request, region);case "UpdateClusterSettings" -> handleUpdateClusterSettings(request, region);case "PutClusterCapacityProviders" -> handlePutClusterCapacityProviders(request, region);- // Task Definitions+case "RegisterTaskDefinition" -> handleRegisterTaskDefinition(request, region);case "DescribeTaskDefinition" -> handleDescribeTaskDefinition(request, region);case "ListTaskDefinitions" -> handleListTaskDefinitions(request, region);case "ListTaskDefinitionFamilies" -> handleListTaskDefinitionFamilies(request, region);case "DeregisterTaskDefinition" -> handleDeregisterTaskDefinition(request, region);case "DeleteTaskDefinitions" -> handleDeleteTaskDefinitions(request, region);- // Tasks+case "RunTask" -> handleRunTask(request, region);case "StartTask" -> handleStartTask(request, region);case "StopTask" -> handleStopTask(request, region);@@ -102,53 +109,54 @@ public class EcsJsonHandler {case "ListTasks" -> handleListTasks(request, region);case "UpdateTaskProtection" -> handleUpdateTaskProtection(request, region);case "GetTaskProtection" -> handleGetTaskProtection(request, region);- // Services+case "CreateService" -> handleCreateService(request, region);case "UpdateService" -> handleUpdateService(request, region);case "DeleteService" -> handleDeleteService(request, region);case "DescribeServices" -> handleDescribeServices(request, region);case "ListServices" -> handleListServices(request, region);case "ListServicesByNamespace" -> handleListServicesByNamespace(request, region);- // Tags+case "TagResource" -> handleTagResource(request, region);case "UntagResource" -> handleUntagResource(request, region);case "ListTagsForResource" -> handleListTagsForResource(request, region);- // Account Settings+case "PutAccountSetting" -> handlePutAccountSetting(request, region);case "PutAccountSettingDefault" -> handlePutAccountSettingDefault(request, region);case "DeleteAccountSetting" -> handleDeleteAccountSetting(request, region);case "ListAccountSettings" -> handleListAccountSettings(request, region);- // Attributes+case "PutAttributes" -> handlePutAttributes(request, region);case "DeleteAttributes" -> handleDeleteAttributes(request, region);case "ListAttributes" -> handleListAttributes(request, region);- // Container Instances+case "RegisterContainerInstance" -> handleRegisterContainerInstance(request, region);case "DeregisterContainerInstance" -> handleDeregisterContainerInstance(request, region);case "DescribeContainerInstances" -> handleDescribeContainerInstances(request, region);case "ListContainerInstances" -> handleListContainerInstances(request, region);case "UpdateContainerAgent" -> handleUpdateContainerAgent(request, region);case "UpdateContainerInstancesState" -> handleUpdateContainerInstancesState(request, region);- // Capacity Providers+case "CreateCapacityProvider" -> handleCreateCapacityProvider(request, region);case "UpdateCapacityProvider" -> handleUpdateCapacityProvider(request, region);case "DeleteCapacityProvider" -> handleDeleteCapacityProvider(request, region);case "DescribeCapacityProviders" -> handleDescribeCapacityProviders(request, region);- // Task Sets+case "CreateTaskSet" -> handleCreateTaskSet(request, region);case "UpdateTaskSet" -> handleUpdateTaskSet(request, region);case "DeleteTaskSet" -> handleDeleteTaskSet(request, region);case "DescribeTaskSets" -> handleDescribeTaskSets(request, region);case "UpdateServicePrimaryTaskSet" -> handleUpdateServicePrimaryTaskSet(request, region);- // Service Deployments & Revisions+case "DescribeServiceDeployments" -> handleDescribeServiceDeployments(request, region);case "ListServiceDeployments" -> handleListServiceDeployments(request, region);case "DescribeServiceRevisions" -> handleDescribeServiceRevisions(request, region);- // Stubs+case "SubmitTaskStateChange" -> handleSubmitTaskStateChange(request, region);case "SubmitContainerStateChange" -> handleSubmitContainerStateChange(request, region);case "SubmitAttachmentStateChanges" -> handleSubmitAttachmentStateChanges(request, region);case "DiscoverPollEndpoint" -> handleDiscoverPollEndpoint(request, region);+default -> Response.status(400).entity(new AwsErrorResponse("UnsupportedOperation","Operation " + action + " is not supported."))@@ -160,9 +168,16 @@ public class EcsJsonHandler {private Response handleCreateCluster(JsonNode req, String region) {CreateClusterRequest request = new CreateClusterRequest();- request.setClusterName(req.path("clusterName").asText(null));+ request.setClusterName(req.has("clusterName") ? req.path("clusterName").asText() : null);request.setTags(parseTagMap(req.path("tags")));request.setSettings(parseClusterSettings(req.path("settings")));+ if (req.has("capacityProviders")) {+ request.setCapacityProviders(jsonArrayToList(req.path("capacityProviders")));+ }+ if (req.has("defaultCapacityProviderStrategy")) {+ request.setDefaultCapacityProviderStrategy(+ parseRawObjectList(req.path("defaultCapacityProviderStrategy")));+ }EcsCluster cluster = service.createCluster(request, region);ObjectNode resp = objectMapper.createObjectNode();resp.set("cluster", writer.clusterNode(cluster));@@ -198,34 +213,40 @@ public class EcsJsonHandler {}private Response handleUpdateCluster(JsonNode req, String region) {- String clusterRef = req.path("cluster").asText();+ String clusterId = req.path("cluster").asText();List<ClusterSetting> settings = parseClusterSettings(req.path("settings"));- EcsCluster cluster = service.updateCluster(clusterRef, settings, region);+ EcsCluster cluster = service.updateCluster(clusterId, settings, region);ObjectNode resp = objectMapper.createObjectNode();resp.set("cluster", writer.clusterNode(cluster));return Response.ok(resp).build();}private Response handleUpdateClusterSettings(JsonNode req, String region) {- String clusterRef = req.path("cluster").asText();+ String clusterId = req.path("cluster").asText();List<ClusterSetting> settings = parseClusterSettings(req.path("settings"));- EcsCluster cluster = service.updateClusterSettings(clusterRef, settings, region);+ EcsCluster cluster = service.updateClusterSettings(clusterId, settings, region);ObjectNode resp = objectMapper.createObjectNode();resp.set("cluster", writer.clusterNode(cluster));return Response.ok(resp).build();}private Response handlePutClusterCapacityProviders(JsonNode req, String region) {- String clusterRef = req.path("cluster").asText();+ String clusterId = req.path("cluster").asText();List<String> providers = jsonArrayToList(req.path("capacityProviders"));List<Map<String, Object>> defaultStrategy = parseRawObjectList(req.path("defaultCapacityProviderStrategy"));- EcsCluster cluster = service.putClusterCapacityProviders(clusterRef, providers, defaultStrategy, region);+ EcsCluster cluster = service.putClusterCapacityProviders(clusterId, providers, defaultStrategy, region);ObjectNode resp = objectMapper.createObjectNode();resp.set("cluster", writer.clusterNode(cluster));return Response.ok(resp).build();}- // ── Task Definitions ──────────────────────────────────────────────────────+ // ── Task definitions ──────────────────────────────────────────────────────++ /** Members of RegisterTaskDefinition the parser consumes; the rest round-trips verbatim. */+ private static final Set<String> TASK_DEFINITION_CONSUMED = Set.of(+ "family", "containerDefinitions", "networkMode", "cpu", "memory", "taskRoleArn",+ "executionRoleArn", "requiresCompatibilities", "volumes", "runtimePlatform",+ "ephemeralStorage", "pidMode", "ipcMode", "tags");private Response handleRegisterTaskDefinition(JsonNode req, String region) {RegisterTaskDefinitionRequest request = new RegisterTaskDefinitionRequest();@@ -235,17 +256,24 @@ public class EcsJsonHandler {request.setCpu(req.has("cpu") ? req.path("cpu").asText() : null);request.setMemory(req.has("memory") ? req.path("memory").asText() : null);request.setTaskRoleArn(req.hasNonNull("taskRoleArn") ? req.path("taskRoleArn").asText() : null);- request.setExecutionRoleArn(- req.hasNonNull("executionRoleArn") ? req.path("executionRoleArn").asText() : null);- request.setRequiresCompatibilities(jsonArrayToList(req.path("requiresCompatibilities")));+ request.setExecutionRoleArn(req.hasNonNull("executionRoleArn")+ ? req.path("executionRoleArn").asText() : null);+ request.setRequiresCompatibilities(parseCompatibilities(req.path("requiresCompatibilities")));request.setVolumes(parseVolumes(req.path("volumes")));request.setRuntimePlatform(parseRuntimePlatform(req.path("runtimePlatform")));+ request.setEphemeralStorage(parseEphemeralStorage(req.path("ephemeralStorage")));+ request.setPidMode(parseChoice(req, "pidMode", PID_MODES));+ request.setIpcMode(parseChoice(req, "ipcMode", IPC_MODES));request.setTags(parseTagMap(req.path("tags")));+ request.setUnparsed(EcsJsonPassthrough.capture(req, objectMapper, TASK_DEFINITION_CONSUMED));TaskDefinition td = service.registerTaskDefinition(request, region);ObjectNode resp = objectMapper.createObjectNode();resp.set("taskDefinition", writer.taskDefinitionNode(td));+ if (td.getTags() != null && !td.getTags().isEmpty()) {+ resp.set("tags", writer.tagsNode(td.getTags()));+ }return Response.ok(resp).build();}@@ -254,6 +282,11 @@ public class EcsJsonHandler {TaskDefinition td = service.describeTaskDefinition(tdRef, region);ObjectNode resp = objectMapper.createObjectNode();resp.set("taskDefinition", writer.taskDefinitionNode(td));+ // DescribeTaskDefinition reports tags at the top level, and only when asked for them.+ if (jsonArrayToList(req.path("include")).contains("TAGS")+ && td.getTags() != null && !td.getTags().isEmpty()) {+ resp.set("tags", writer.tagsNode(td.getTags()));+ }return Response.ok(resp).build();}@@ -300,17 +333,7 @@ public class EcsJsonHandler {// ── Tasks ─────────────────────────────────────────────────────────────────private Response handleRunTask(JsonNode req, String region) {- RunTaskRequest request = new RunTaskRequest();- request.setCluster(req.has("cluster") ? req.path("cluster").asText() : null);- request.setTaskDefinition(req.path("taskDefinition").asText());- request.setCount(req.path("count").asInt(1));- request.setLaunchType(parseEnum(req, "launchType", LaunchType.class));- request.setGroup(req.has("group") ? req.path("group").asText() : null);- request.setStartedBy(req.has("startedBy") ? req.path("startedBy").asText() : null);- request.setContainerOverrides(- parseContainerOverrides(req.path("overrides").path("containerOverrides")));- request.setNetworkConfiguration(parseNetworkConfiguration(req.path("networkConfiguration")));-+ RunTaskRequest request = parseRunTaskRequest(req);List<EcsTask> launched = service.runTask(request, region);ObjectNode resp = objectMapper.createObjectNode();@@ -322,13 +345,8 @@ public class EcsJsonHandler {}private Response handleStartTask(JsonNode req, String region) {- RunTaskRequest request = new RunTaskRequest();- request.setCluster(req.has("cluster") ? req.path("cluster").asText() : null);+ RunTaskRequest request = parseRunTaskRequest(req);request.setContainerInstances(jsonArrayToList(req.path("containerInstances")));- request.setTaskDefinition(req.path("taskDefinition").asText());- request.setGroup(req.has("group") ? req.path("group").asText() : null);- request.setStartedBy(req.has("startedBy") ? req.path("startedBy").asText() : null);-List<EcsTask> launched = service.startTask(request, region);ObjectNode resp = objectMapper.createObjectNode();@@ -339,6 +357,27 @@ public class EcsJsonHandler {return Response.ok(resp).build();}+ private RunTaskRequest parseRunTaskRequest(JsonNode req) {+ RunTaskRequest request = new RunTaskRequest();+ request.setCluster(req.has("cluster") ? req.path("cluster").asText() : null);+ request.setTaskDefinition(req.path("taskDefinition").asText());+ request.setCount(req.path("count").asInt(1));+ request.setLaunchType(parseEnum(req, "launchType", LaunchType.class));+ request.setCapacityProviderStrategy(parseCapacityProviderStrategy(req.path("capacityProviderStrategy")));+ request.setGroup(req.has("group") ? req.path("group").asText() : null);+ request.setStartedBy(req.has("startedBy") ? req.path("startedBy").asText() : null);+ request.setOverrides(parseTaskOverride(req.path("overrides")));+ request.setNetworkConfiguration(parseNetworkConfiguration(req.path("networkConfiguration")));+ request.setPlatformVersion(req.hasNonNull("platformVersion")+ ? req.path("platformVersion").asText() : null);+ request.setEnableExecuteCommand(req.path("enableExecuteCommand").asBoolean(false));+ request.setEnableECSManagedTags(req.path("enableECSManagedTags").asBoolean(false));+ request.setPropagateTags(parseChoice(req, "propagateTags", PROPAGATE_TAGS));+ request.setReferenceId(req.has("referenceId") ? req.path("referenceId").asText() : null);+ request.setTags(parseTagMap(req.path("tags")));+ return request;+ }+private Response handleStopTask(JsonNode req, String region) {String cluster = req.has("cluster") ? req.path("cluster").asText() : null;String task = req.path("task").asText();@@ -354,13 +393,16 @@ public class EcsJsonHandler {private Response handleDescribeTasks(JsonNode req, String region) {String cluster = req.has("cluster") ? req.path("cluster").asText() : null;List<String> taskRefs = jsonArrayToList(req.path("tasks"));- List<EcsTask> found = service.describeTasks(cluster, taskRefs, region);+ boolean includeTags = jsonArrayToList(req.path("include")).contains("TAGS");+ EcsService.DescribeTasksResult found = service.describeTasksDetailed(cluster, taskRefs, region);ObjectNode resp = objectMapper.createObjectNode();ArrayNode arr = objectMapper.createArrayNode();- found.forEach(t -> arr.add(writer.taskNode(t)));+ found.tasks().forEach(t -> arr.add(writer.taskNode(t, includeTags)));resp.set("tasks", arr);- resp.set("failures", objectMapper.createArrayNode());+ ArrayNode failures = objectMapper.createArrayNode();+ found.failures().forEach(f -> failures.add(writer.failureNode(f)));+ resp.set("failures", failures);return Response.ok(resp).build();}@@ -420,16 +462,15 @@ public class EcsJsonHandler {request.setTaskDefinition(req.path("taskDefinition").asText());request.setDesiredCount(req.path("desiredCount").asInt(1));request.setLaunchType(parseEnum(req, "launchType", LaunchType.class));+ request.setCapacityProviderStrategy(parseCapacityProviderStrategy(req.path("capacityProviderStrategy")));request.setLoadBalancers(parseLoadBalancers(req.path("loadBalancers")));request.setNetworkConfiguration(parseNetworkConfiguration(req.path("networkConfiguration")));request.setTags(parseTagMap(req.path("tags")));request.setSchedulingStrategy(parseChoice(req, "schedulingStrategy", SCHEDULING_STRATEGIES));request.setDeploymentControllerType(parseChoice(req.path("deploymentController"), "type","deploymentController.type", DEPLOYMENT_CONTROLLER_TYPES));- request.setAvailabilityZoneRebalancing(- parseChoice(req, "availabilityZoneRebalancing", AZ_REBALANCING));- request.setServiceConnectConfiguration(- parseServiceConnectConfiguration(req.path("serviceConnectConfiguration")));+ request.setAvailabilityZoneRebalancing(parseChoice(req, "availabilityZoneRebalancing", AZ_REBALANCING));+ request.setServiceConnectConfiguration(parseRawObject(req.path("serviceConnectConfiguration")));EcsServiceModel svc = service.createService(request, region);@@ -438,6 +479,25 @@ public class EcsJsonHandler {return Response.ok(resp).build();}+ private Response handleUpdateService(JsonNode req, String region) {+ UpdateServiceRequest request = new UpdateServiceRequest();+ request.setCluster(req.has("cluster") ? req.path("cluster").asText() : null);+ request.setService(req.path("service").asText());+ request.setTaskDefinition(req.has("taskDefinition") ? req.path("taskDefinition").asText() : null);+ request.setDesiredCount(req.has("desiredCount") ? req.path("desiredCount").asInt() : null);+ request.setNetworkConfiguration(parseNetworkConfiguration(req.path("networkConfiguration")));+ request.setAvailabilityZoneRebalancing(parseChoice(req, "availabilityZoneRebalancing", AZ_REBALANCING));+ request.setForceNewDeployment(req.path("forceNewDeployment").asBoolean(false));+ request.setServiceConnectConfiguration(parseRawObject(req.path("serviceConnectConfiguration")));+ request.setCapacityProviderStrategy(parseCapacityProviderStrategy(req.path("capacityProviderStrategy")));++ EcsServiceModel svc = service.updateService(request, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("service", writer.serviceNode(svc));+ return Response.ok(resp).build();+ }+private List<EcsLoadBalancer> parseLoadBalancers(JsonNode node) {List<EcsLoadBalancer> result = new ArrayList<>();if (node == null || !node.isArray()) {@@ -476,6 +536,9 @@ public class EcsJsonHandler {m.setLoadBalancerName(loadBalancerName);m.setContainerName(containerName);m.setContainerPort(containerPort);+ // The blue/green listener and alternate target group wiring, kept raw: Floci shifts no+ // traffic, but a service created with it has to read back with it.+ m.setAdvancedConfiguration(parseRawObject(lb.path("advancedConfiguration")));result.add(m);}return result;@@ -500,26 +563,6 @@ public class EcsJsonHandler {return networkConfiguration;}- private Response handleUpdateService(JsonNode req, String region) {- UpdateServiceRequest request = new UpdateServiceRequest();- request.setCluster(req.has("cluster") ? req.path("cluster").asText() : null);- request.setService(req.path("service").asText());- request.setTaskDefinition(req.has("taskDefinition") ? req.path("taskDefinition").asText() : null);- request.setDesiredCount(req.has("desiredCount") ? req.path("desiredCount").asInt() : null);- request.setNetworkConfiguration(parseNetworkConfiguration(req.path("networkConfiguration")));- request.setAvailabilityZoneRebalancing(- parseChoice(req, "availabilityZoneRebalancing", AZ_REBALANCING));- request.setForceNewDeployment(req.path("forceNewDeployment").asBoolean(false));- request.setServiceConnectConfiguration(- parseServiceConnectConfiguration(req.path("serviceConnectConfiguration")));-- EcsServiceModel svc = service.updateService(request, region);-- ObjectNode resp = objectMapper.createObjectNode();- resp.set("service", writer.serviceNode(svc));- return Response.ok(resp).build();- }-private Response handleDeleteService(JsonNode req, String region) {String cluster = req.has("cluster") ? req.path("cluster").asText() : null;String serviceName = req.path("service").asText();@@ -933,43 +976,18 @@ public class EcsJsonHandler {return writer.taskNode(task);}- private static final Set<String> SCHEDULING_STRATEGIES = Set.of("REPLICA", "DAEMON");- private static final Set<String> DEPLOYMENT_CONTROLLER_TYPES = Set.of("ECS", "CODE_DEPLOY", "EXTERNAL");- private static final Set<String> AZ_REBALANCING = Set.of("ENABLED", "DISABLED");-- /** Optional enum-valued string field: absent → {@code null}; present but not in {@code allowed} → 400. */- private static String parseChoice(JsonNode node, String field, Set<String> allowed) {- return parseChoice(node, field, field, allowed);- }-- private static String parseChoice(JsonNode node, String field, String displayName, Set<String> allowed) {- if (node == null || node.isMissingNode() || !node.hasNonNull(field)) {- return null;- }- String value = node.path(field).asText();- if (!allowed.contains(value)) {- throw new AwsException("InvalidParameterException",- "Invalid " + displayName + ": " + value + ". Valid values: "- + String.join(", ", new java.util.TreeSet<>(allowed)) + ".", 400);- }- return value;- }-- /**- * Keeps the caller's Service Connect configuration as given. AWS's {@code Service} shape has- * no member for it, so DescribeServices reports it on each deployment rather than on the- * service, and a generated client drops anything written anywhere else.- */- @SuppressWarnings("unchecked")- private Map<String, Object> parseServiceConnectConfiguration(JsonNode node) {- if (node == null || !node.isObject()) {- return null;- }- return objectMapper.convertValue(node, Map.class);- }-// ── Parsing helpers ───────────────────────────────────────────────────────+ /** Members of a container definition the parser consumes; the rest round-trips verbatim. */+ private static final Set<String> CONTAINER_DEFINITION_CONSUMED = Set.of(+ "name", "image", "essential", "cpu", "memory", "memoryReservation", "portMappings",+ "environment", "environmentFiles", "secrets", "mountPoints", "volumesFrom", "dependsOn",+ "logConfiguration", "firelensConfiguration", "healthCheck", "command", "entryPoint",+ "startTimeout", "stopTimeout", "user", "workingDirectory", "hostname",+ "readonlyRootFilesystem", "privileged", "disableNetworking", "interactive",+ "pseudoTerminal", "links", "dnsServers", "dnsSearchDomains", "dockerSecurityOptions",+ "dockerLabels", "repositoryCredentials");+private List<ContainerDefinition> parseContainerDefinitions(JsonNode node) {List<ContainerDefinition> result = new ArrayList<>();if (!node.isArray()) {@@ -986,11 +1004,17 @@ public class EcsJsonHandler {def.setPortMappings(parsePortMappings(item.path("portMappings")));def.setEnvironment(parseKeyValuePairs(item.path("environment")));+ if (item.has("environmentFiles")) {+ def.setEnvironmentFiles(parseEnvironmentFiles(item.path("environmentFiles")));+ }if (item.has("secrets")) {def.setSecrets(parseSecrets(item.path("secrets")));}def.setMountPoints(parseMountPoints(item.path("mountPoints")));def.setVolumesFrom(parseVolumesFrom(item.path("volumesFrom")));+ if (item.has("dependsOn")) {+ def.setDependsOn(parseDependsOn(item.path("dependsOn"), def.getName()));+ }def.setLogConfiguration(parseLogConfiguration(item.path("logConfiguration")));def.setFirelensConfiguration(parseFirelensConfiguration(item.path("firelensConfiguration"), result.size() + 1));@@ -999,16 +1023,50 @@ public class EcsJsonHandler {}if (item.has("command") && item.path("command").isArray()) {- List<String> cmd = new ArrayList<>();- item.path("command").forEach(c -> cmd.add(c.asText()));- def.setCommand(cmd);+ def.setCommand(jsonArrayToList(item.path("command")));}if (item.has("entryPoint") && item.path("entryPoint").isArray()) {- List<String> ep = new ArrayList<>();- item.path("entryPoint").forEach(e -> ep.add(e.asText()));- def.setEntryPoint(ep);+ def.setEntryPoint(jsonArrayToList(item.path("entryPoint")));}+ if (item.hasNonNull("startTimeout")) { def.setStartTimeout(item.path("startTimeout").asInt()); }+ if (item.hasNonNull("stopTimeout")) { def.setStopTimeout(item.path("stopTimeout").asInt()); }+ if (item.hasNonNull("user")) { def.setUser(item.path("user").asText()); }+ if (item.hasNonNull("workingDirectory")) {+ def.setWorkingDirectory(item.path("workingDirectory").asText());+ }+ if (item.hasNonNull("hostname")) { def.setHostname(item.path("hostname").asText()); }+ if (item.hasNonNull("readonlyRootFilesystem")) {+ def.setReadonlyRootFilesystem(item.path("readonlyRootFilesystem").asBoolean());+ }+ if (item.hasNonNull("privileged")) { def.setPrivileged(item.path("privileged").asBoolean()); }+ if (item.hasNonNull("disableNetworking")) {+ def.setDisableNetworking(item.path("disableNetworking").asBoolean());+ }+ if (item.hasNonNull("interactive")) { def.setInteractive(item.path("interactive").asBoolean()); }+ if (item.hasNonNull("pseudoTerminal")) {+ def.setPseudoTerminal(item.path("pseudoTerminal").asBoolean());+ }+ if (item.has("links")) { def.setLinks(jsonArrayToList(item.path("links"))); }+ if (item.has("dnsServers")) { def.setDnsServers(jsonArrayToList(item.path("dnsServers"))); }+ if (item.has("dnsSearchDomains")) {+ def.setDnsSearchDomains(jsonArrayToList(item.path("dnsSearchDomains")));+ }+ if (item.has("dockerSecurityOptions")) {+ def.setDockerSecurityOptions(jsonArrayToList(item.path("dockerSecurityOptions")));+ }+ if (item.path("dockerLabels").isObject()) {+ Map<String, String> labels = new LinkedHashMap<>();+ item.path("dockerLabels").fields()+ .forEachRemaining(entry -> labels.put(entry.getKey(), entry.getValue().asText()));+ def.setDockerLabels(labels);+ }+ if (item.path("repositoryCredentials").hasNonNull("credentialsParameter")) {+ def.setRepositoryCredentialsParameter(+ item.path("repositoryCredentials").path("credentialsParameter").asText());+ }+ def.setUnparsed(EcsJsonPassthrough.capture(item, objectMapper, CONTAINER_DEFINITION_CONSUMED));+result.add(def);}return result;@@ -1023,7 +1081,12 @@ public class EcsJsonHandler {int containerPort = item.path("containerPort").asInt(0);int hostPort = item.path("hostPort").asInt(0);String protocol = item.path("protocol").asText("tcp");- result.add(new PortMapping(containerPort, hostPort, protocol));+ String name = item.hasNonNull("name") ? item.path("name").asText() : null;+ String appProtocol = item.hasNonNull("appProtocol") ? item.path("appProtocol").asText() : null;+ String containerPortRange = item.hasNonNull("containerPortRange")+ ? item.path("containerPortRange").asText() : null;+ result.add(new PortMapping(containerPort, hostPort, protocol, name, appProtocol,+ containerPortRange));}return result;}@@ -1039,6 +1102,40 @@ public class EcsJsonHandler {return result;}+ private List<EnvironmentFile> parseEnvironmentFiles(JsonNode node) {+ List<EnvironmentFile> result = new ArrayList<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ result.add(new EnvironmentFile(item.path("value").asText(), item.path("type").asText("s3")));+ }+ return result;+ }++ /**+ * Parses {@code dependsOn}, rejecting a condition ECS does not define. An unknown condition+ * would otherwise silently become a plain start-ordering edge.+ */+ private List<ContainerDependency> parseDependsOn(JsonNode node, String containerName) {+ List<ContainerDependency> result = new ArrayList<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ String condition = item.path("condition").asText();+ if (!DEPENDENCY_CONDITIONS.contains(condition)) {+ throw new AwsException("ClientException",+ "Container '" + containerName + "' depends on container '"+ + item.path("containerName").asText() + "' with an invalid condition: "+ + condition + ". Valid values: "+ + String.join(", ", new TreeSet<>(DEPENDENCY_CONDITIONS)) + ".", 400);+ }+ result.add(new ContainerDependency(item.path("containerName").asText(), condition));+ }+ return result;+ }+private List<Secret> parseSecrets(JsonNode node) {List<Secret> result = new ArrayList<>();if (!node.isArray()) {@@ -1075,6 +1172,43 @@ public class EcsJsonHandler {return new RuntimePlatform(cpuArchitecture, operatingSystemFamily);}+ private EphemeralStorage parseEphemeralStorage(JsonNode node) {+ if (node == null || !node.isObject() || !node.hasNonNull("sizeInGiB")) {+ return null;+ }+ return new EphemeralStorage(node.path("sizeInGiB").asInt());+ }++ private List<CapacityProviderStrategyItem> parseCapacityProviderStrategy(JsonNode node) {+ if (node == null || !node.isArray() || node.isEmpty()) {+ return null;+ }+ List<CapacityProviderStrategyItem> result = new ArrayList<>();+ for (JsonNode item : node) {+ result.add(new CapacityProviderStrategyItem(+ item.path("capacityProvider").asText(),+ item.path("weight").asInt(0),+ item.path("base").asInt(0)));+ }+ return result;+ }++ private TaskOverride parseTaskOverride(JsonNode node) {+ if (node == null || !node.isObject()) {+ return null;+ }+ TaskOverride overrides = new TaskOverride();+ overrides.setContainerOverrides(parseContainerOverrides(node.path("containerOverrides")));+ if (node.hasNonNull("cpu")) { overrides.setCpu(node.path("cpu").asText()); }+ if (node.hasNonNull("memory")) { overrides.setMemory(node.path("memory").asText()); }+ if (node.hasNonNull("taskRoleArn")) { overrides.setTaskRoleArn(node.path("taskRoleArn").asText()); }+ if (node.hasNonNull("executionRoleArn")) {+ overrides.setExecutionRoleArn(node.path("executionRoleArn").asText());+ }+ overrides.setEphemeralStorage(parseEphemeralStorage(node.path("ephemeralStorage")));+ return overrides.isEmpty() ? null : overrides;+ }+private LogConfiguration parseLogConfiguration(JsonNode node) {if (node == null || !node.isObject()) {return null;@@ -1121,6 +1255,7 @@ public class EcsJsonHandler {}return new FirelensConfiguration(type, options);}+private HealthCheck parseHealthCheck(JsonNode node) {if (node == null || !node.isObject()) {return null;@@ -1147,11 +1282,18 @@ public class EcsJsonHandler {hostVolumePolicy.validate(hostSourcePath);}EfsVolumeConfiguration efs = parseEfsVolumeConfiguration(item.path("efsVolumeConfiguration"));- result.add(new Volume(item.path("name").asText(), hostSourcePath, efs));+ // "host" stays out of the consumed set so that a volume declaring an empty one reads+ // back with it; a host that did carry a sourcePath is written from the typed field and+ // the passthrough leaves it alone.+ result.add(new Volume(item.path("name").asText(), hostSourcePath, efs,+ EcsJsonPassthrough.capture(item, objectMapper, VOLUME_CONSUMED)));}return result;}+ /** Volume members the parser consumes; the rest round-trips verbatim. */+ private static final Set<String> VOLUME_CONSUMED = Set.of("name", "efsVolumeConfiguration");+private EfsVolumeConfiguration parseEfsVolumeConfiguration(JsonNode node) {if (node == null || !node.isObject()) {return null;@@ -1205,11 +1347,17 @@ public class EcsJsonHandler {ContainerOverride co = new ContainerOverride();co.setName(item.path("name").asText());if (item.has("command") && item.path("command").isArray()) {- List<String> cmd = new ArrayList<>();- item.path("command").forEach(c -> cmd.add(c.asText()));- co.setCommand(cmd);+ co.setCommand(jsonArrayToList(item.path("command")));}co.setEnvironment(parseKeyValuePairs(item.path("environment")));+ if (item.has("environmentFiles")) {+ co.setEnvironmentFiles(parseEnvironmentFiles(item.path("environmentFiles")));+ }+ if (item.hasNonNull("cpu")) { co.setCpu(item.path("cpu").asInt()); }+ if (item.hasNonNull("memory")) { co.setMemory(item.path("memory").asInt()); }+ if (item.hasNonNull("memoryReservation")) {+ co.setMemoryReservation(item.path("memoryReservation").asInt());+ }result.add(co);}return result;@@ -1242,24 +1390,53 @@ public class EcsJsonHandler {return result;}+ /**+ * Parses a {@code tags} list, holding it to the limits ECS documents for every operation that+ * takes one: at most 50 tags, a key of 1 to 128 characters and a value of up to 256. The count+ * is taken from the request rather than the parsed map, so 51 entries that collapse to fewer+ * distinct keys are still rejected.+ */private Map<String, String> parseTagMap(JsonNode node) {Map<String, String> result = new HashMap<>();if (!node.isArray()) {return result;}+ if (node.size() > MAX_TAGS_PER_RESOURCE) {+ throw new AwsException("InvalidParameterException",+ "Too many tags specified. A resource takes at most "+ + MAX_TAGS_PER_RESOURCE + " tags.", 400);+ }for (JsonNode item : node) {- result.put(item.path("key").asText(), item.path("value").asText());+ String key = item.path("key").asText();+ String value = item.path("value").asText();+ if (key.isEmpty() || key.length() > MAX_TAG_KEY_LENGTH) {+ throw new AwsException("InvalidParameterException",+ "Tag keys must be between 1 and " + MAX_TAG_KEY_LENGTH+ + " characters long.", 400);+ }+ if (value.length() > MAX_TAG_VALUE_LENGTH) {+ throw new AwsException("InvalidParameterException",+ "Tag values can be up to " + MAX_TAG_VALUE_LENGTH+ + " characters long.", 400);+ }+ result.put(key, value);}return result;}+ private static final int MAX_TAGS_PER_RESOURCE = 50;+ private static final int MAX_TAG_KEY_LENGTH = 128;+ private static final int MAX_TAG_VALUE_LENGTH = 256;++ @SuppressWarnings("unchecked")private Map<String, Object> parseRawObject(JsonNode node) {- if (node == null || node.isMissingNode()) {+ if (node == null || node.isMissingNode() || !node.isObject()) {return null;}return objectMapper.convertValue(node, Map.class);}+ @SuppressWarnings("unchecked")private List<Map<String, Object>> parseRawObjectList(JsonNode node) {List<Map<String, Object>> result = new ArrayList<>();if (!node.isArray()) {@@ -1279,15 +1456,67 @@ public class EcsJsonHandler {return result;}+ /**+ * Parses an enum-typed member, rejecting a value the enum does not have. Treating an+ * unrecognised value as absent is worse than it sounds: a {@code launchType} of {@code "EC22"}+ * would silently fall through to Floci's default and place the task on Fargate, which is not+ * what the caller asked for and not what AWS answers.+ */private <T extends Enum<T>> T parseEnum(JsonNode req, String field, Class<T> enumClass) {- if (!req.has(field)) {+ if (!req.hasNonNull(field)) {return null;}String val = req.path(field).asText();try {return Enum.valueOf(enumClass, val);} catch (IllegalArgumentException e) {+ List<String> valid = Arrays.stream(enumClass.getEnumConstants()).map(Enum::name).toList();+ throw new AwsException("InvalidParameterException",+ "Invalid " + field + ": " + val + ". Valid values: "+ + String.join(", ", valid) + ".", 400);+ }+ }++ /** Rejects a compatibility the enum does not have, rather than carrying it into the model. */+ private List<String> parseCompatibilities(JsonNode node) {+ List<String> requested = jsonArrayToList(node);+ for (String value : requested) {+ if (!COMPATIBILITIES.contains(value)) {+ throw new AwsException("InvalidParameterException",+ "Invalid requiresCompatibilities value: " + value + ". Valid values: "+ + String.join(", ", new TreeSet<>(COMPATIBILITIES)) + ".", 400);+ }+ }+ return requested;+ }++ private static final Set<String> COMPATIBILITIES =+ Set.of("EC2", "FARGATE", "EXTERNAL", "MANAGED_INSTANCES");+ private static final Set<String> PID_MODES = Set.of("host", "task");+ private static final Set<String> IPC_MODES = Set.of("host", "task", "none");+ private static final Set<String> SCHEDULING_STRATEGIES = Set.of("REPLICA", "DAEMON");+ private static final Set<String> DEPLOYMENT_CONTROLLER_TYPES = Set.of("ECS", "CODE_DEPLOY", "EXTERNAL");+ private static final Set<String> AZ_REBALANCING = Set.of("ENABLED", "DISABLED");+ private static final Set<String> PROPAGATE_TAGS = Set.of("TASK_DEFINITION", "SERVICE", "NONE");+ private static final Set<String> DEPENDENCY_CONDITIONS = Set.of(+ ContainerDependency.START, ContainerDependency.COMPLETE,+ ContainerDependency.SUCCESS, ContainerDependency.HEALTHY);++ /** Optional enum-valued string field: absent → {@code null}; present but not in {@code allowed} → 400. */+ private static String parseChoice(JsonNode node, String field, Set<String> allowed) {+ return parseChoice(node, field, field, allowed);+ }++ private static String parseChoice(JsonNode node, String field, String displayName, Set<String> allowed) {+ if (node == null || node.isMissingNode() || !node.hasNonNull(field)) {return null;}+ String value = node.path(field).asText();+ if (!allowed.contains(value)) {+ throw new AwsException("InvalidParameterException",+ "Invalid " + displayName + ": " + value + ". Valid values: "+ + String.join(", ", new TreeSet<>(allowed)) + ".", 400);+ }+ return value;}}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonPassthrough.java b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonPassthrough.javanew file mode 100644index 0000000000..9ef66f0c51--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonPassthrough.java@@ -0,0 +1,62 @@+package io.github.hectorvent.floci.services.ecs;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;++import java.util.Iterator;+import java.util.LinkedHashMap;+import java.util.Map;+import java.util.Set;++/**+ * Keeps the members of a request that Floci has no behaviour for, so a describe returns what the+ * caller registered instead of a subset of it.+ *+ * <p>ECS's task definition and service shapes carry a long tail of members that only have to+ * survive a round trip: {@code proxyConfiguration}, {@code linuxParameters}, {@code ulimits},+ * {@code resourceRequirements}, placement constraints and so on. A client that writes one and+ * reads it back, such as Terraform or CDK, treats a dropped member as drift and proposes the same+ * change on every plan. Capturing whatever the parser did not consume covers the whole tail at+ * once, including members AWS adds later.+ */+final class EcsJsonPassthrough {++ private EcsJsonPassthrough() {+ }++ /**+ * The members of {@code node} that are not in {@code consumed}, in the order they arrived, or+ * {@code null} when there are none.+ */+ static Map<String, Object> capture(JsonNode node, ObjectMapper objectMapper, Set<String> consumed) {+ if (node == null || !node.isObject()) {+ return null;+ }+ Map<String, Object> result = new LinkedHashMap<>();+ Iterator<Map.Entry<String, JsonNode>> fields = node.fields();+ while (fields.hasNext()) {+ Map.Entry<String, JsonNode> field = fields.next();+ if (consumed.contains(field.getKey())) {+ continue;+ }+ result.put(field.getKey(), objectMapper.convertValue(field.getValue(), Object.class));+ }+ return result.isEmpty() ? null : result;+ }++ /**+ * Writes the captured members onto a response node. A member the serializer already wrote from+ * a typed field wins, so a value Floci normalizes is never overwritten by the raw input.+ */+ static void write(ObjectNode target, Map<String, Object> passthrough, ObjectMapper objectMapper) {+ if (passthrough == null || passthrough.isEmpty()) {+ return;+ }+ passthrough.forEach((key, value) -> {+ if (!target.has(key)) {+ target.set(key, objectMapper.valueToTree(value));+ }+ });+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsResponseWriter.java b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsResponseWriter.javaindex b85c155b70..44ad307af5 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsResponseWriter.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsResponseWriter.java@@ -3,20 +3,26 @@ package io.github.hectorvent.floci.services.ecs;import io.github.hectorvent.floci.services.ecs.model.Attribute;import io.github.hectorvent.floci.services.ecs.model.AwsVpcConfiguration;import io.github.hectorvent.floci.services.ecs.model.CapacityProvider;+import io.github.hectorvent.floci.services.ecs.model.CapacityProviderStrategyItem;import io.github.hectorvent.floci.services.ecs.model.Container;import io.github.hectorvent.floci.services.ecs.model.ContainerDefinition;+import io.github.hectorvent.floci.services.ecs.model.ContainerDependency;import io.github.hectorvent.floci.services.ecs.model.ContainerInstance;+import io.github.hectorvent.floci.services.ecs.model.ContainerOverride;import io.github.hectorvent.floci.services.ecs.model.Deployment;import io.github.hectorvent.floci.services.ecs.model.EcsCluster;import io.github.hectorvent.floci.services.ecs.model.EcsLoadBalancer;import io.github.hectorvent.floci.services.ecs.model.EcsServiceModel;import io.github.hectorvent.floci.services.ecs.model.EcsTask;import io.github.hectorvent.floci.services.ecs.model.EfsVolumeConfiguration;+import io.github.hectorvent.floci.services.ecs.model.EnvironmentFile;+import io.github.hectorvent.floci.services.ecs.model.EphemeralStorage;import io.github.hectorvent.floci.services.ecs.model.Failure;import io.github.hectorvent.floci.services.ecs.model.FirelensConfiguration;import io.github.hectorvent.floci.services.ecs.model.HealthCheck;import io.github.hectorvent.floci.services.ecs.model.KeyValuePair;import io.github.hectorvent.floci.services.ecs.model.LogConfiguration;+import io.github.hectorvent.floci.services.ecs.model.ManagedAgent;import io.github.hectorvent.floci.services.ecs.model.MountPoint;import io.github.hectorvent.floci.services.ecs.model.NetworkBinding;import io.github.hectorvent.floci.services.ecs.model.PortMapping;@@ -26,6 +32,8 @@ import io.github.hectorvent.floci.services.ecs.model.Secret;import io.github.hectorvent.floci.services.ecs.model.ServiceDeployment;import io.github.hectorvent.floci.services.ecs.model.ServiceRevision;import io.github.hectorvent.floci.services.ecs.model.TaskDefinition;+import io.github.hectorvent.floci.services.ecs.model.TaskNetworkInterface;+import io.github.hectorvent.floci.services.ecs.model.TaskOverride;import io.github.hectorvent.floci.services.ecs.model.TaskSet;import io.github.hectorvent.floci.services.ecs.model.Volume;import io.github.hectorvent.floci.services.ecs.model.VolumeFrom;@@ -35,6 +43,8 @@ import com.fasterxml.jackson.databind.node.ObjectNode;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;+import java.time.Instant;+import java.util.LinkedHashMap;import java.util.List;import java.util.Map;@@ -104,6 +114,11 @@ public class EcsResponseWriter {if (td.getMemory() != null) { n.put("memory", td.getMemory()); }if (td.getTaskRoleArn() != null) { n.put("taskRoleArn", td.getTaskRoleArn()); }if (td.getExecutionRoleArn() != null) { n.put("executionRoleArn", td.getExecutionRoleArn()); }+ if (td.getPidMode() != null) { n.put("pidMode", td.getPidMode()); }+ if (td.getIpcMode() != null) { n.put("ipcMode", td.getIpcMode()); }+ if (td.getEphemeralStorage() != null) {+ n.set("ephemeralStorage", ephemeralStorageNode(td.getEphemeralStorage()));+ }if (td.getRuntimePlatform() != null) {RuntimePlatform platform = td.getRuntimePlatform();ObjectNode platformNode = objectMapper.createObjectNode();@@ -125,6 +140,11 @@ public class EcsResponseWriter {td.getCompatibilities().forEach(arr::add);n.set("compatibilities", arr);}+ if (td.getRequiresAttributes() != null && !td.getRequiresAttributes().isEmpty()) {+ ArrayNode arr = objectMapper.createArrayNode();+ td.getRequiresAttributes().forEach(a -> arr.add(attributeNode(a)));+ n.set("requiresAttributes", arr);+ }ArrayNode containers = objectMapper.createArrayNode();if (td.getContainerDefinitions() != null) {@@ -136,9 +156,14 @@ public class EcsResponseWriter {if (td.getVolumes() != null && !td.getVolumes().isEmpty()) {n.set("volumes", volumesNode(td.getVolumes()));}+ putInstant(n, "registeredAt", td.getRegisteredAt());+ putInstant(n, "deregisteredAt", td.getDeregisteredAt());+ putInstant(n, "deleteRequestedAt", td.getDeleteRequestedAt());+ if (td.getRegisteredBy() != null) { n.put("registeredBy", td.getRegisteredBy()); }if (td.getTags() != null && !td.getTags().isEmpty()) {n.set("tags", tagsNode(td.getTags()));}+ EcsJsonPassthrough.write(n, td.getUnparsed(), objectMapper);return n;}@@ -177,6 +202,7 @@ public class EcsResponseWriter {}vNode.set("efsVolumeConfiguration", efs);}+ EcsJsonPassthrough.write(vNode, v.unparsed(), objectMapper);vols.add(vNode);}return vols;@@ -189,6 +215,7 @@ public class EcsResponseWriter {n.put("essential", def.isEssential());if (def.getCpu() != null) { n.put("cpu", def.getCpu()); }if (def.getMemory() != null) { n.put("memory", def.getMemory()); }+ if (def.getMemoryReservation() != null) { n.put("memoryReservation", def.getMemoryReservation()); }if (def.getPortMappings() != null && !def.getPortMappings().isEmpty()) {ArrayNode pms = objectMapper.createArrayNode();@@ -197,6 +224,11 @@ public class EcsResponseWriter {pmNode.put("containerPort", pm.containerPort());pmNode.put("hostPort", pm.hostPort());pmNode.put("protocol", pm.protocol());+ if (pm.name() != null) { pmNode.put("name", pm.name()); }+ if (pm.appProtocol() != null) { pmNode.put("appProtocol", pm.appProtocol()); }+ if (pm.containerPortRange() != null) {+ pmNode.put("containerPortRange", pm.containerPortRange());+ }pms.add(pmNode);}n.set("portMappings", pms);@@ -211,6 +243,9 @@ public class EcsResponseWriter {if (def.getEnvironment() != null && !def.getEnvironment().isEmpty()) {n.set("environment", keyValuePairsNode(def.getEnvironment()));}+ if (def.getEnvironmentFiles() != null && !def.getEnvironmentFiles().isEmpty()) {+ n.set("environmentFiles", environmentFilesNode(def.getEnvironmentFiles()));+ }if (def.getSecrets() != null && !def.getSecrets().isEmpty()) {n.set("secrets", secretsNode(def.getSecrets()));}@@ -235,6 +270,16 @@ public class EcsResponseWriter {}n.set("volumesFrom", volumesFrom);}+ if (def.getDependsOn() != null && !def.getDependsOn().isEmpty()) {+ ArrayNode dependsOn = objectMapper.createArrayNode();+ for (ContainerDependency dependency : def.getDependsOn()) {+ ObjectNode dependencyNode = objectMapper.createObjectNode();+ dependencyNode.put("containerName", dependency.containerName());+ dependencyNode.put("condition", dependency.condition());+ dependsOn.add(dependencyNode);+ }+ n.set("dependsOn", dependsOn);+ }if (def.getLogConfiguration() != null) {LogConfiguration logConfig = def.getLogConfiguration();@@ -279,11 +324,57 @@ public class EcsResponseWriter {n.set("healthCheck", hcNode);}+ if (def.getStartTimeout() != null) { n.put("startTimeout", def.getStartTimeout()); }+ if (def.getStopTimeout() != null) { n.put("stopTimeout", def.getStopTimeout()); }+ if (def.getUser() != null) { n.put("user", def.getUser()); }+ if (def.getWorkingDirectory() != null) { n.put("workingDirectory", def.getWorkingDirectory()); }+ if (def.getHostname() != null) { n.put("hostname", def.getHostname()); }+ if (def.getReadonlyRootFilesystem() != null) {+ n.put("readonlyRootFilesystem", def.getReadonlyRootFilesystem());+ }+ if (def.getPrivileged() != null) { n.put("privileged", def.getPrivileged()); }+ if (def.getDisableNetworking() != null) { n.put("disableNetworking", def.getDisableNetworking()); }+ if (def.getInteractive() != null) { n.put("interactive", def.getInteractive()); }+ if (def.getPseudoTerminal() != null) { n.put("pseudoTerminal", def.getPseudoTerminal()); }+ if (def.getLinks() != null && !def.getLinks().isEmpty()) {+ n.set("links", stringArray(def.getLinks()));+ }+ if (def.getDnsServers() != null && !def.getDnsServers().isEmpty()) {+ n.set("dnsServers", stringArray(def.getDnsServers()));+ }+ if (def.getDnsSearchDomains() != null && !def.getDnsSearchDomains().isEmpty()) {+ n.set("dnsSearchDomains", stringArray(def.getDnsSearchDomains()));+ }+ if (def.getDockerSecurityOptions() != null && !def.getDockerSecurityOptions().isEmpty()) {+ n.set("dockerSecurityOptions", stringArray(def.getDockerSecurityOptions()));+ }+ if (def.getDockerLabels() != null && !def.getDockerLabels().isEmpty()) {+ ObjectNode labels = objectMapper.createObjectNode();+ def.getDockerLabels().forEach(labels::put);+ n.set("dockerLabels", labels);+ }+ if (def.getRepositoryCredentialsParameter() != null) {+ n.putObject("repositoryCredentials")+ .put("credentialsParameter", def.getRepositoryCredentialsParameter());+ }+ EcsJsonPassthrough.write(n, def.getUnparsed(), objectMapper);return n;}// ── Tasks ─────────────────────────────────────────────────────────────────+ /**+ * Renders a task for a describe, where its tags are reported only when the caller asked for+ * them with {@code include: ["TAGS"]}.+ */+ public ObjectNode taskNode(EcsTask t, boolean includeTags) {+ ObjectNode n = taskNode(t);+ if (!includeTags) {+ n.remove("tags");+ }+ return n;+ }+/** Renders an ECS task to its data-plane JSON shape. Reused by the Step Functions* ecs:runTask integration ({@link io.github.hectorvent.floci.services.stepfunctions.AslExecutor}). */public ObjectNode taskNode(EcsTask t) {@@ -293,16 +384,52 @@ public class EcsResponseWriter {n.put("taskDefinitionArn", t.getTaskDefinitionArn());n.put("lastStatus", t.getLastStatus());n.put("desiredStatus", t.getDesiredStatus());- if (t.getLaunchType() != null) { n.put("launchType", t.getLaunchType().name()); }+ // A task placed through a capacity provider reports both: the provider it was placed+ // through and the launch type that provider resolves to. (A service reports only one of+ // the two, which is why serviceNode does it differently.)+ if (t.getCapacityProviderName() != null) {+ n.put("capacityProviderName", t.getCapacityProviderName());+ }+ if (t.getLaunchType() != null) {+ n.put("launchType", t.getLaunchType().name());+ }+ if (t.getPlatformVersion() != null) { n.put("platformVersion", t.getPlatformVersion()); }+ if (t.getPlatformFamily() != null) { n.put("platformFamily", t.getPlatformFamily()); }if (t.getCpu() != null) { n.put("cpu", t.getCpu()); }if (t.getMemory() != null) { n.put("memory", t.getMemory()); }+ if (t.getEphemeralStorage() != null) {+ n.set("ephemeralStorage", ephemeralStorageNode(t.getEphemeralStorage()));+ // A Fargate task also reports the storage it actually got, which is the same size here.+ if (t.getPlatformVersion() != null) {+ n.set("fargateEphemeralStorage", ephemeralStorageNode(t.getEphemeralStorage()));+ }+ }if (t.getGroup() != null) { n.put("group", t.getGroup()); }if (t.getStartedBy() != null) { n.put("startedBy", t.getStartedBy()); }if (t.getContainerInstanceArn() != null) { n.put("containerInstanceArn", t.getContainerInstanceArn()); }- if (t.getCreatedAt() != null) { n.put("createdAt", t.getCreatedAt().toEpochMilli() / 1000.0); }- if (t.getStartedAt() != null) { n.put("startedAt", t.getStartedAt().toEpochMilli() / 1000.0); }- if (t.getStoppedAt() != null) { n.put("stoppedAt", t.getStoppedAt().toEpochMilli() / 1000.0); }+ if (t.getAvailabilityZone() != null) { n.put("availabilityZone", t.getAvailabilityZone()); }+ if (t.getConnectivity() != null) { n.put("connectivity", t.getConnectivity()); }+ putInstant(n, "connectivityAt", t.getConnectivityAt());+ if (t.getHealthStatus() != null) { n.put("healthStatus", t.getHealthStatus()); }+ if (t.getStopCode() != null) { n.put("stopCode", t.getStopCode()); }+ n.put("enableExecuteCommand", t.isEnableExecuteCommand());+ n.put("version", t.getVersion());+ putInstant(n, "createdAt", t.getCreatedAt());+ putInstant(n, "startedAt", t.getStartedAt());+ putInstant(n, "stoppingAt", t.getStoppingAt());+ putInstant(n, "stoppedAt", t.getStoppedAt());+ putInstant(n, "pullStartedAt", t.getPullStartedAt());+ putInstant(n, "pullStoppedAt", t.getPullStoppedAt());+ putInstant(n, "executionStoppedAt", t.getExecutionStoppedAt());if (t.getStoppedReason() != null) { n.put("stoppedReason", t.getStoppedReason()); }+ // A task always reports overrides, with one containerOverrides entry per container even+ // when the request overrode nothing, which is what DescribeTasks answers with.+ n.set("overrides", taskOverrideNode(t));+ if (t.getAttributes() != null && !t.getAttributes().isEmpty()) {+ ArrayNode attrs = objectMapper.createArrayNode();+ t.getAttributes().forEach(a -> attrs.add(attributeNode(a)));+ n.set("attributes", attrs);+ }if (t.getNetworkInterfaceId() != null) {n.putArray("attachments").add(eniAttachmentNode(t));}@@ -322,9 +449,10 @@ public class EcsResponseWriter {private ObjectNode eniAttachmentNode(EcsTask t) {ObjectNode attachment = objectMapper.createObjectNode();- attachment.put("id", "eni-attach-" + t.getNetworkInterfaceId());+ attachment.put("id", t.getAttachmentId() != null+ ? t.getAttachmentId() : "eni-attach-" + t.getNetworkInterfaceId());attachment.put("type", "ElasticNetworkInterface");- attachment.put("status", "ATTACHED");+ attachment.put("status", t.getAttachmentStatus() != null ? t.getAttachmentStatus() : "ATTACHED");ArrayNode details = objectMapper.createArrayNode();if (t.getNetworkConfiguration() != null&& t.getNetworkConfiguration().getAwsvpcConfiguration() != null@@ -333,6 +461,12 @@ public class EcsResponseWriter {t.getNetworkConfiguration().getAwsvpcConfiguration().getSubnets().getFirst());}details.addObject().put("name", "networkInterfaceId").put("value", t.getNetworkInterfaceId());+ if (t.getMacAddress() != null) {+ details.addObject().put("name", "macAddress").put("value", t.getMacAddress());+ }+ if (t.getPrivateDnsName() != null) {+ details.addObject().put("name", "privateDnsName").put("value", t.getPrivateDnsName());+ }details.addObject().put("name", "privateIPv4Address").put("value", t.getPrivateIpAddress());attachment.set("details", details);return attachment;@@ -347,6 +481,13 @@ public class EcsResponseWriter {cn.put("lastStatus", c.getLastStatus());if (c.getExitCode() != null) { cn.put("exitCode", c.getExitCode()); }if (c.getReason() != null) { cn.put("reason", c.getReason()); }+ if (c.getHealthStatus() != null) { cn.put("healthStatus", c.getHealthStatus()); }+ if (c.getRuntimeId() != null) { cn.put("runtimeId", c.getRuntimeId()); }+ if (c.getImageDigest() != null) { cn.put("imageDigest", c.getImageDigest()); }+ // A container definition that asked for no CPU units reports zero, not nothing.+ cn.put("cpu", c.getCpu() != null ? c.getCpu() : "0");+ if (c.getMemory() != null) { cn.put("memory", c.getMemory()); }+ if (c.getMemoryReservation() != null) { cn.put("memoryReservation", c.getMemoryReservation()); }ArrayNode bindings = objectMapper.createArrayNode();if (c.getNetworkBindings() != null) {@@ -360,11 +501,91 @@ public class EcsResponseWriter {}}cn.set("networkBindings", bindings);+ if (c.getNetworkInterfaces() != null && !c.getNetworkInterfaces().isEmpty()) {+ ArrayNode interfaces = objectMapper.createArrayNode();+ for (TaskNetworkInterface ni : c.getNetworkInterfaces()) {+ ObjectNode in = objectMapper.createObjectNode();+ if (ni.attachmentId() != null) { in.put("attachmentId", ni.attachmentId()); }+ if (ni.privateIpv4Address() != null) { in.put("privateIpv4Address", ni.privateIpv4Address()); }+ if (ni.ipv6Address() != null) { in.put("ipv6Address", ni.ipv6Address()); }+ interfaces.add(in);+ }+ cn.set("networkInterfaces", interfaces);+ }+ if (c.getManagedAgents() != null && !c.getManagedAgents().isEmpty()) {+ ArrayNode agents = objectMapper.createArrayNode();+ for (ManagedAgent agent : c.getManagedAgents()) {+ ObjectNode an = objectMapper.createObjectNode();+ an.put("name", agent.name());+ an.put("lastStatus", agent.lastStatus());+ if (agent.reason() != null) { an.put("reason", agent.reason()); }+ putInstant(an, "lastStartedAt", agent.lastStartedAt());+ agents.add(an);+ }+ cn.set("managedAgents", agents);+ }return cn;}+ /**+ * The task's overrides. Every container is listed, carrying whatever the request overrode for+ * it and nothing more, so a client that walks {@code containerOverrides} sees the same entries+ * AWS returns rather than an empty list for a task nobody overrode.+ */+ private ObjectNode taskOverrideNode(EcsTask task) {+ TaskOverride overrides = task.getOverrides() != null ? task.getOverrides() : new TaskOverride();+ Map<String, ContainerOverride> byName = new LinkedHashMap<>();+ if (task.getContainers() != null) {+ task.getContainers().forEach(container -> {+ ContainerOverride placeholder = new ContainerOverride();+ placeholder.setName(container.getName());+ byName.put(container.getName(), placeholder);+ });+ }+ if (overrides.getContainerOverrides() != null) {+ overrides.getContainerOverrides().forEach(override -> byName.put(override.getName(), override));+ }+ return taskOverrideNode(overrides, List.copyOf(byName.values()));+ }++ private ObjectNode taskOverrideNode(TaskOverride overrides, List<ContainerOverride> perContainer) {+ ObjectNode n = objectMapper.createObjectNode();+ ArrayNode containerOverrides = objectMapper.createArrayNode();+ for (ContainerOverride co : perContainer) {+ ObjectNode con = objectMapper.createObjectNode();+ con.put("name", co.getName());+ if (co.getCommand() != null && !co.getCommand().isEmpty()) {+ con.set("command", stringArray(co.getCommand()));+ }+ if (co.getEnvironment() != null && !co.getEnvironment().isEmpty()) {+ con.set("environment", keyValuePairsNode(co.getEnvironment()));+ }+ if (co.getEnvironmentFiles() != null && !co.getEnvironmentFiles().isEmpty()) {+ con.set("environmentFiles", environmentFilesNode(co.getEnvironmentFiles()));+ }+ if (co.getCpu() != null) { con.put("cpu", co.getCpu()); }+ if (co.getMemory() != null) { con.put("memory", co.getMemory()); }+ if (co.getMemoryReservation() != null) {+ con.put("memoryReservation", co.getMemoryReservation());+ }+ containerOverrides.add(con);+ }+ n.set("containerOverrides", containerOverrides);+ if (overrides.getCpu() != null) { n.put("cpu", overrides.getCpu()); }+ if (overrides.getMemory() != null) { n.put("memory", overrides.getMemory()); }+ if (overrides.getTaskRoleArn() != null) { n.put("taskRoleArn", overrides.getTaskRoleArn()); }+ if (overrides.getExecutionRoleArn() != null) {+ n.put("executionRoleArn", overrides.getExecutionRoleArn());+ }+ if (overrides.getEphemeralStorage() != null) {+ n.set("ephemeralStorage", ephemeralStorageNode(overrides.getEphemeralStorage()));+ }+ return n;+ }+// ── Services ──────────────────────────────────────────────────────────────+ /** Renders a service for a describe, gating its tags on {@code include: ["TAGS"]}. */public ObjectNode serviceNode(EcsServiceModel s) {ObjectNode n = objectMapper.createObjectNode();n.put("serviceArn", s.getServiceArn());@@ -375,8 +596,13 @@ public class EcsResponseWriter {n.put("runningCount", s.getRunningCount());n.put("pendingCount", s.getPendingCount());n.put("status", s.getStatus());- if (s.getLaunchType() != null) { n.put("launchType", s.getLaunchType().name()); }- if (s.getCreatedAt() != null) { n.put("createdAt", s.getCreatedAt().toEpochMilli() / 1000.0); }+ if (s.getCapacityProviderStrategy() != null && !s.getCapacityProviderStrategy().isEmpty()) {+ n.set("capacityProviderStrategy",+ capacityProviderStrategyNode(s.getCapacityProviderStrategy()));+ } else if (s.getLaunchType() != null) {+ n.put("launchType", s.getLaunchType().name());+ }+ putInstant(n, "createdAt", s.getCreatedAt());if (s.getNamespace() != null) { n.put("namespace", s.getNamespace()); }// Services persisted before these fields existed read back with the AWS defaults.n.put("schedulingStrategy", s.getSchedulingStrategy() != null@@ -407,12 +633,15 @@ public class EcsResponseWriter {}private ObjectNode loadBalancerNode(EcsLoadBalancer lb) {- ObjectNode ln = objectMapper.createObjectNode();- if (lb.getTargetGroupArn() != null) { ln.put("targetGroupArn", lb.getTargetGroupArn()); }- if (lb.getLoadBalancerName() != null) { ln.put("loadBalancerName", lb.getLoadBalancerName()); }- if (lb.getContainerName() != null) { ln.put("containerName", lb.getContainerName()); }- if (lb.getContainerPort() != null) { ln.put("containerPort", lb.getContainerPort()); }- return ln;+ ObjectNode n = objectMapper.createObjectNode();+ if (lb.getTargetGroupArn() != null) { n.put("targetGroupArn", lb.getTargetGroupArn()); }+ if (lb.getLoadBalancerName() != null) { n.put("loadBalancerName", lb.getLoadBalancerName()); }+ if (lb.getContainerName() != null) { n.put("containerName", lb.getContainerName()); }+ if (lb.getContainerPort() != null) { n.put("containerPort", lb.getContainerPort()); }+ if (lb.getAdvancedConfiguration() != null) {+ n.set("advancedConfiguration", objectMapper.valueToTree(lb.getAdvancedConfiguration()));+ }+ return n;}private ObjectNode networkConfigurationNode(AwsVpcConfiguration awsvpc) {@@ -455,8 +684,6 @@ public class EcsResponseWriter {return n;}- // ── Container instances ───────────────────────────────────────────────────-public ObjectNode containerInstanceNode(ContainerInstance ci) {ObjectNode n = objectMapper.createObjectNode();n.put("containerInstanceArn", ci.getContainerInstanceArn());@@ -477,8 +704,7 @@ public class EcsResponseWriter {return n;}- // ── Capacity providers ────────────────────────────────────────────────────-+ /** @param includeTags DescribeCapacityProviders returns tags only for {@code include: ["TAGS"]}. */public ObjectNode capacityProviderNode(CapacityProvider cp) {ObjectNode n = objectMapper.createObjectNode();n.put("name", cp.getName());@@ -490,8 +716,6 @@ public class EcsResponseWriter {return n;}- // ── Task sets ─────────────────────────────────────────────────────────────-public ObjectNode taskSetNode(TaskSet ts) {ObjectNode n = objectMapper.createObjectNode();n.put("id", ts.getId());@@ -518,8 +742,6 @@ public class EcsResponseWriter {return n;}- // ── Service deployments and revisions ─────────────────────────────────────-public ObjectNode serviceDeploymentNode(ServiceDeployment d) {ObjectNode n = objectMapper.createObjectNode();n.put("serviceDeploymentArn", d.getServiceDeploymentArn());@@ -543,15 +765,11 @@ public class EcsResponseWriter {return n;}- // ── Shared members ────────────────────────────────────────────────────────-public ObjectNode protectedTaskNode(ProtectedTask pt) {ObjectNode n = objectMapper.createObjectNode();n.put("taskArn", pt.taskArn());n.put("protectionEnabled", pt.protectionEnabled());- if (pt.expirationDate() != null) {- n.put("expirationDate", pt.expirationDate().toEpochMilli() / 1000.0);- }+ putInstant(n, "expirationDate", pt.expirationDate());return n;}@@ -582,6 +800,24 @@ public class EcsResponseWriter {return arr;}+ public ArrayNode capacityProviderStrategyNode(List<CapacityProviderStrategyItem> strategy) {+ ArrayNode arr = objectMapper.createArrayNode();+ for (CapacityProviderStrategyItem item : strategy) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("capacityProvider", item.capacityProvider());+ n.put("weight", item.weight());+ n.put("base", item.base());+ arr.add(n);+ }+ return arr;+ }++ private ObjectNode ephemeralStorageNode(EphemeralStorage storage) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("sizeInGiB", storage.sizeInGiB());+ return n;+ }+private ArrayNode keyValuePairsNode(List<KeyValuePair> pairs) {ArrayNode arr = objectMapper.createArrayNode();for (KeyValuePair kv : pairs) {@@ -593,6 +829,17 @@ public class EcsResponseWriter {return arr;}+ private ArrayNode environmentFilesNode(List<EnvironmentFile> files) {+ ArrayNode arr = objectMapper.createArrayNode();+ for (EnvironmentFile file : files) {+ ObjectNode fileNode = objectMapper.createObjectNode();+ fileNode.put("value", file.value());+ fileNode.put("type", file.type());+ arr.add(fileNode);+ }+ return arr;+ }+private ArrayNode secretsNode(List<Secret> secrets) {ArrayNode arr = objectMapper.createArrayNode();for (Secret secret : secrets) {@@ -606,7 +853,16 @@ public class EcsResponseWriter {private ArrayNode stringArray(List<String> values) {ArrayNode arr = objectMapper.createArrayNode();- values.forEach(arr::add);+ if (values != null) {+ values.forEach(arr::add);+ }return arr;}++ /** ECS timestamps go on the wire as epoch seconds with a fractional part. */+ private static void putInstant(ObjectNode target, String field, Instant value) {+ if (value != null) {+ target.put(field, value.toEpochMilli() / 1000.0);+ }+ }}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 6403b934f5..ff9509791c 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@@ -15,13 +15,17 @@ import io.github.hectorvent.floci.services.ecs.container.EcsContainerManager;import io.github.hectorvent.floci.services.ecs.container.EcsTaskHandle;import io.github.hectorvent.floci.services.ecs.model.Attribute;import io.github.hectorvent.floci.services.ecs.model.CapacityProvider;+import io.github.hectorvent.floci.services.ecs.model.CapacityProviderStrategyItem;import io.github.hectorvent.floci.services.ecs.model.ClusterSetting;+import io.github.hectorvent.floci.services.ecs.model.Container;import io.github.hectorvent.floci.services.ecs.model.ContainerDefinition;+import io.github.hectorvent.floci.services.ecs.model.ContainerDependency;import io.github.hectorvent.floci.services.ecs.model.ContainerInstance;import io.github.hectorvent.floci.services.ecs.model.CreateClusterRequest;import io.github.hectorvent.floci.services.ecs.model.CreateServiceRequest;import io.github.hectorvent.floci.services.ecs.model.CreateTaskSetRequest;import io.github.hectorvent.floci.services.ecs.model.Deployment;+import io.github.hectorvent.floci.services.ecs.model.EphemeralStorage;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;@@ -31,17 +35,22 @@ import io.github.hectorvent.floci.services.ecs.model.EcsTask;import io.github.hectorvent.floci.services.ecs.model.FirelensConfiguration;import io.github.hectorvent.floci.services.ecs.model.LaunchType;import io.github.hectorvent.floci.services.ecs.model.ListTasksRequest;+import io.github.hectorvent.floci.services.ecs.model.ManagedAgent;import io.github.hectorvent.floci.services.ecs.model.NetworkConfiguration;import io.github.hectorvent.floci.services.ecs.model.NetworkMode;import io.github.hectorvent.floci.services.ecs.model.ProtectedTask;import io.github.hectorvent.floci.services.ecs.model.RegisterTaskDefinitionRequest;import io.github.hectorvent.floci.services.ecs.model.RunTaskRequest;+import io.github.hectorvent.floci.services.ecs.model.RuntimePlatform;import io.github.hectorvent.floci.services.ecs.model.ServiceDeployment;import io.github.hectorvent.floci.services.ecs.model.ServiceRevision;import io.github.hectorvent.floci.services.ecs.model.TaskDefinition;+import io.github.hectorvent.floci.services.ecs.model.TaskNetworkInterface;+import io.github.hectorvent.floci.services.ecs.model.TaskOverride;import io.github.hectorvent.floci.services.ecs.model.TaskSet;import io.github.hectorvent.floci.services.ecs.model.TaskStatus;import io.github.hectorvent.floci.services.ecs.model.UpdateServiceRequest;+import io.github.hectorvent.floci.services.ecs.model.Volume;import jakarta.annotation.PostConstruct;import jakarta.annotation.PreDestroy;import jakarta.enterprise.context.ApplicationScoped;@@ -51,6 +60,8 @@ import org.jboss.logging.Logger;import java.time.Instant;import java.util.ArrayList;+import java.util.Collection;+import java.util.Collections;import java.util.LinkedHashMap;import java.util.LinkedHashSet;import java.util.List;@@ -109,6 +120,34 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabpublic static final String DEFAULT_AZ_REBALANCING_ON_CREATE = "ENABLED";/** A service that never had a value (persisted before the field existed) reads as DISABLED. */public static final String DEFAULT_AZ_REBALANCING_UNSET = "DISABLED";+ /** The Fargate platform version {@code LATEST} resolves to. */+ public static final String DEFAULT_PLATFORM_VERSION = "1.4.0";+ public static final String PLATFORM_VERSION_LATEST = "LATEST";+ /** The platform family a Linux task reports, as DescribeTasks answers it. */+ public static final String DEFAULT_PLATFORM_FAMILY = "Linux";+ public static final String CONNECTIVITY_CONNECTED = "CONNECTED";+ public static final String HEALTH_STATUS_UNKNOWN = "UNKNOWN";+ public static final String HEALTH_STATUS_HEALTHY = "HEALTHY";+ public static final String HEALTH_STATUS_UNHEALTHY = "UNHEALTHY";+ public static final String STOP_CODE_TASK_FAILED_TO_START = "TaskFailedToStart";+ public static final String STOP_CODE_ESSENTIAL_CONTAINER_EXITED = "EssentialContainerExited";+ public static final String STOP_CODE_USER_INITIATED = "UserInitiated";+ public static final String STOP_CODE_SERVICE_SCHEDULER_INITIATED = "ServiceSchedulerInitiated";+ public static final String PROPAGATE_TAGS_SERVICE = "SERVICE";+ public static final String PROPAGATE_TAGS_TASK_DEFINITION = "TASK_DEFINITION";+ /** RunTask places at most ten tasks in one call, and StartTask at most ten instances. */+ public static final int MAX_TASKS_PER_RUN = 10;+ public static final String STATUS_ACTIVE = "ACTIVE";+ public static final String STATUS_INACTIVE = "INACTIVE";+ public static final String STATUS_DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS";+ /** The attribute every task carries, naming the architecture it actually runs on. */+ private static final String CPU_ARCHITECTURE_ATTRIBUTE = "ecs.cpu-architecture";+ /** The two built-in capacity providers, which place Fargate tasks rather than EC2 ones. */+ private static final Set<String> FARGATE_CAPACITY_PROVIDERS = Set.of("FARGATE", "FARGATE_SPOT");+ /** The bounds the ECS model puts on a capacity provider strategy and on its entries. */+ private static final int MAX_CAPACITY_PROVIDERS_PER_STRATEGY = 20;+ private static final int MAX_CAPACITY_PROVIDER_WEIGHT = 1000;+ private static final int MAX_CAPACITY_PROVIDER_BASE = 100_000;// region::clusterArn/instanceArn → ContainerInstanceprivate final Map<String, ContainerInstance> containerInstances = new ConcurrentHashMap<>();// name → CapacityProvider (excludes built-ins FARGATE, FARGATE_SPOT)@@ -122,6 +161,8 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettab// targetArn → List<Attribute>private Map<String, List<Attribute>> attributes = new ConcurrentHashMap<>();// name → value (account-level settings)+ // principalArn::name → value. The root principal's row doubles as the account default, which+ // is how AWS describes it: "the account settings for the root user or the default setting".private Map<String, String> accountSettings = new ConcurrentHashMap<>();// deploymentIds for which SERVICE_DEPLOYMENT_IN_PROGRESS has already been emitted this process.private final Set<String> inProgressEmitted = java.util.concurrent.ConcurrentHashMap.newKeySet();@@ -237,6 +278,16 @@ public class EcsService implements ContainerTeardown, ResourceProvider, ResettabLOG.warnv("Failed to stop ECS task {0} on shutdown: {1}", taskArn, e.getMessage());}}+ // Task state is memory-only, so an ENI left behind here would outlive every task that+ // could claim it and reload from EC2's store as an orphan on the next start.+ for (EcsTask task : tasks.values()) {+ try {+ containerManager.releaseTaskNetwork(task, taskRegion(task));+ } catch (Exception e) {+ LOG.warnv("Failed to release the ENI of ECS task {0} on shutdown: {1}",+ task.getTaskArn(), e.getMessage());+ }+ }}@Override@@ -304,13 +355,15 @@ public class EcsService implements ContainerTeardown, ResourceProvider, ResettabEcsCluster cluster = new EcsCluster();cluster.setClusterName(name);cluster.setClusterArn(regionResolver.buildArn("ecs", region, "cluster/" + name));- cluster.setStatus("ACTIVE");+ cluster.setStatus(STATUS_ACTIVE);if (request.getTags() != null && !request.getTags().isEmpty()) {cluster.setTags(new LinkedHashMap<>(request.getTags()));}if (request.getSettings() != null && !request.getSettings().isEmpty()) {cluster.setSettings(new ArrayList<>(request.getSettings()));}+ cluster.setCapacityProviders(request.getCapacityProviders());+ cluster.setDefaultCapacityProviderStrategy(request.getDefaultCapacityProviderStrategy());clusters.put(key, cluster);LOG.infov("Created ECS cluster: {0} in {1}", name, region);return cluster;@@ -409,23 +462,14 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabpublic TaskDefinition registerTaskDefinition(RegisterTaskDefinitionRequest request, String region) {List<ContainerDefinition> containerDefs = request.getContainerDefinitions();- List<String> requiresCompatibilities = request.getRequiresCompatibilities();boolean fargate = request.isFargate();+ validateTaskSize(request, fargate);+ validateEphemeralStorage(request.getEphemeralStorage());+ validateContainerDependencies(containerDefs);+ validateFirelensS3Config(containerDefs, fargate);if (fargate) {- if (request.getNetworkMode() != NetworkMode.awsvpc) {- throw new AwsException("ClientException", "Fargate only supports network mode 'awsvpc'.", 400);- }- if (request.getCpu() == null) {- throw new AwsException("ClientException", "Fargate requires that 'cpu' be defined at the task level.", 400);- }- if (request.getMemory() == null) {- throw new AwsException("ClientException", "Fargate requires that 'memory' be defined at the task level.", 400);- }- if (!isValidFargateCpuMemory(request.getCpu(), request.getMemory())) {- throw new AwsException("ClientException", "No Fargate configuration exists for given values.", 400);- }+ validateFargateUnsupportedParameters(request);}- validateFirelensS3Config(containerDefs, fargate);String family = request.getFamily();int revision = latestRevisions.merge(family, 1, Integer::sum);@@ -439,15 +483,18 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabtd.setTaskRoleArn(request.getTaskRoleArn());td.setExecutionRoleArn(request.getExecutionRoleArn());td.setContainerDefinitions(containerDefs != null ? containerDefs : List.of());- td.setRequiresCompatibilities(requiresCompatibilities);+ td.setRequiresCompatibilities(request.getRequiresCompatibilities());td.setVolumes(request.getVolumes());td.setRuntimePlatform(request.getRuntimePlatform());+ td.setEphemeralStorage(request.getEphemeralStorage());+ td.setPidMode(request.getPidMode());+ td.setIpcMode(request.getIpcMode());+ td.setUnparsed(request.getUnparsed());+ td.setRegisteredAt(Instant.now());+ td.setRegisteredBy(regionResolver.buildArn("iam", region, "root"));- if (requiresCompatibilities != null && !requiresCompatibilities.isEmpty()) {- td.setCompatibilities(new ArrayList<>(requiresCompatibilities));- } else {- td.setCompatibilities(List.of("EC2"));- }+ td.setCompatibilities(deriveCompatibilities(request, fargate));+ td.setRequiresAttributes(deriveRequiresAttributes(request));td.setTaskDefinitionArn(regionResolver.buildArn("ecs", region,"task-definition/" + family + ":" + revision));@@ -460,6 +507,276 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabreturn td;}+ /**+ * The launch types a registered definition is actually compatible with, which is not the same+ * as the {@code requiresCompatibilities} it was validated against: "Amazon ECS validates the+ * task definition parameters with those supported by the launch type", so a definition that+ * satisfies Fargate's rules reports FARGATE even when it never asked for it.+ *+ * <p>EXTERNAL covers the same ground as EC2 minus {@code awsvpc}, which ECS Anywhere instances+ * do not support.+ */+ private List<String> deriveCompatibilities(RegisterTaskDefinitionRequest request, boolean fargate) {+ List<String> compatibilities = new ArrayList<>();+ compatibilities.add("EC2");+ if (fargate || isFargateCompatible(request)) {+ compatibilities.add("FARGATE");+ }+ if (request.getNetworkMode() != NetworkMode.awsvpc) {+ compatibilities.add("EXTERNAL");+ }+ return compatibilities;+ }++ /** Runs Fargate's own rules over a definition that did not ask for them, to see if it passes. */+ private boolean isFargateCompatible(RegisterTaskDefinitionRequest request) {+ if (request.getNetworkMode() != NetworkMode.awsvpc) {+ return false;+ }+ try {+ validateTaskSize(request, true);+ validateEphemeralStorage(request.getEphemeralStorage());+ validateFirelensS3Config(request.getContainerDefinitions(), true);+ validateFargateUnsupportedParameters(request);+ return true;+ } catch (AwsException notFargateCompatible) {+ LOG.debugv("Task definition {0} is not Fargate compatible: {1}",+ request.getFamily(), notFargateCompatible.getMessage());+ return false;+ }+ }++ /** The Docker remote API version every task definition needs, per the RegisterTaskDefinition sample. */+ private static final String BASE_AGENT_CAPABILITY = "com.amazonaws.ecs.capability.docker-remote-api.1.18";++ /**+ * The container instance capabilities a definition needs to be placed on EC2.+ *+ * <p>ECS derives these from the agent's capability model, which AWS does not publish in full.+ * Floci derives the subset whose names appear verbatim in the AWS documentation: the base+ * Docker remote API version, the log driver, ECR authentication, the task IAM role (which has+ * a separate name under {@code host} networking), privileged containers, and the task ENI+ * capability that {@code awsvpc} placement requires.+ */+ private List<Attribute> deriveRequiresAttributes(RegisterTaskDefinitionRequest request) {+ Set<String> names = new LinkedHashSet<>();+ names.add(BASE_AGENT_CAPABILITY);+ NetworkMode networkMode = request.getNetworkMode() != null+ ? request.getNetworkMode() : NetworkMode.bridge;+ if (networkMode == NetworkMode.awsvpc) {+ names.add("ecs.capability.task-eni");+ }+ if (request.getTaskRoleArn() != null) {+ names.add(networkMode == NetworkMode.host+ ? "com.amazonaws.ecs.capability.task-iam-role-network-host"+ : "com.amazonaws.ecs.capability.task-iam-role");+ }+ if (request.getContainerDefinitions() != null) {+ for (ContainerDefinition def : request.getContainerDefinitions()) {+ if (def.getLogConfiguration() != null && def.getLogConfiguration().logDriver() != null) {+ names.add("com.amazonaws.ecs.capability.logging-driver."+ + def.getLogConfiguration().logDriver());+ }+ if (def.getImage() != null && def.getImage().contains(".dkr.ecr.")) {+ names.add("com.amazonaws.ecs.capability.ecr-auth");+ }+ if (Boolean.TRUE.equals(def.getPrivileged())) {+ names.add("com.amazonaws.ecs.capability.privileged-container");+ }+ }+ }+ return names.stream().map(name -> new Attribute(name, null, null, null)).toList();+ }++ /**+ * The task-level size rules. Fargate requires both values and accepts only the documented+ * pairs; Windows on Fargate additionally has no sub-vCPU size.+ */+ private void validateTaskSize(RegisterTaskDefinitionRequest request, boolean fargate) {+ if (!fargate) {+ return;+ }+ if (request.getNetworkMode() != NetworkMode.awsvpc) {+ throw new AwsException("ClientException", "Fargate only supports network mode 'awsvpc'.", 400);+ }+ if (request.getCpu() == null) {+ throw new AwsException("ClientException",+ "Fargate requires that 'cpu' be defined at the task level.", 400);+ }+ if (request.getMemory() == null) {+ throw new AwsException("ClientException",+ "Fargate requires that 'memory' be defined at the task level.", 400);+ }+ if (!isValidFargateCpuMemory(request.getCpu(), request.getMemory())) {+ throw new AwsException("ClientException", "No Fargate configuration exists for given values.", 400);+ }+ RuntimePlatform platform = request.getRuntimePlatform();+ boolean windows = platform != null && platform.operatingSystemFamily() != null+ && platform.operatingSystemFamily().startsWith("WINDOWS");+ if (windows && parseCpu(request.getCpu()) < 1024) {+ throw new AwsException("ClientException", "No Fargate configuration exists for given values.", 400);+ }+ }++ /**+ * Fargate's ephemeral storage is 20 GiB by default and can be expanded up to 200 GiB, so an+ * explicit request below the default or above the ceiling is rejected the way AWS rejects it.+ */+ private static void validateEphemeralStorage(EphemeralStorage storage) {+ if (storage == null) {+ return;+ }+ if (storage.sizeInGiB() <= EphemeralStorage.DEFAULT_SIZE_IN_GIB+ || storage.sizeInGiB() > EphemeralStorage.MAX_SIZE_IN_GIB) {+ throw new AwsException("ClientException",+ "Invalid setting for ephemeral storage. Size must be between "+ + (EphemeralStorage.DEFAULT_SIZE_IN_GIB + 1) + " GiB and "+ + EphemeralStorage.MAX_SIZE_IN_GIB + " GiB.", 400);+ }+ }++ /**+ * A {@code dependsOn} entry may only name another container of the same task definition, and+ * the graph they form has to be acyclic: a cycle would leave every container in it waiting for+ * another, so ECS rejects it at registration rather than at launch.+ */+ private static void validateContainerDependencies(List<ContainerDefinition> containerDefs) {+ if (containerDefs == null) {+ return;+ }+ Map<String, ContainerDefinition> byName = new LinkedHashMap<>();+ containerDefs.forEach(def -> byName.put(def.getName(), def));+ for (ContainerDefinition def : containerDefs) {+ if (def.getDependsOn() == null) {+ continue;+ }+ for (ContainerDependency dependency : def.getDependsOn()) {+ if (dependency.containerName().equals(def.getName())) {+ throw new AwsException("ClientException",+ "Container '" + def.getName() + "' cannot depend on itself.", 400);+ }+ if (!byName.containsKey(dependency.containerName())) {+ throw new AwsException("ClientException",+ "Container '" + def.getName() + "' depends on container '"+ + dependency.containerName() + "' which does not exist.", 400);+ }+ }+ }+ Set<String> resolved = new HashSet<>();+ Set<String> visiting = new LinkedHashSet<>();+ for (ContainerDefinition def : containerDefs) {+ rejectDependencyCycle(def, byName, visiting, resolved);+ }+ }++ private static void rejectDependencyCycle(ContainerDefinition def,+ Map<String, ContainerDefinition> byName,+ Set<String> visiting, Set<String> resolved) {+ if (resolved.contains(def.getName())) {+ return;+ }+ if (!visiting.add(def.getName())) {+ throw new AwsException("ClientException",+ "The container dependencies form a cycle: "+ + String.join(" -> ", visiting) + " -> " + def.getName() + ".", 400);+ }+ if (def.getDependsOn() != null) {+ for (ContainerDependency dependency : def.getDependsOn()) {+ rejectDependencyCycle(byName.get(dependency.containerName()), byName, visiting, resolved);+ }+ }+ visiting.remove(def.getName());+ resolved.add(def.getName());+ }++ /**+ * The task definition parameters that are not valid in a Fargate task, as the Fargate task+ * definition differences document lists them: {@code disableNetworking},+ * {@code dnsSearchDomains}, {@code dnsServers}, {@code dockerSecurityOptions},+ * {@code extraHosts}, {@code gpu}, {@code ipcMode}, {@code links},+ * {@code placementConstraints}, {@code privileged}, {@code maxSwap} and {@code swappiness},+ * plus the {@code pidMode} values other than {@code task} and the host bind mounts Fargate+ * cannot provide. ECS rejects each of them at registration rather than failing the task later.+ */+ private static void validateFargateUnsupportedParameters(RegisterTaskDefinitionRequest request) {+ if (request.getIpcMode() != null) {+ throw new AwsException("ClientException",+ "Fargate compatible task definitions do not support ipcMode.", 400);+ }+ if (request.getPidMode() != null && !"task".equals(request.getPidMode())) {+ throw new AwsException("ClientException",+ "Fargate compatible task definitions only support the 'task' pidMode.", 400);+ }+ if (notEmpty(request.getUnparsed(), "placementConstraints")) {+ throw new AwsException("ClientException",+ "Fargate compatible task definitions do not support placementConstraints.", 400);+ }+ if (request.getVolumes() != null) {+ for (Volume volume : request.getVolumes()) {+ if (volume.hostSourcePath() != null && !volume.hostSourcePath().isBlank()) {+ throw new AwsException("ClientException",+ "Fargate compatible task definitions do not support host volume sourcePath.", 400);+ }+ }+ }+ if (request.getContainerDefinitions() == null) {+ return;+ }+ for (ContainerDefinition def : request.getContainerDefinitions()) {+ rejectOnFargate(Boolean.TRUE.equals(def.getPrivileged()), "privileged");+ rejectOnFargate(Boolean.TRUE.equals(def.getDisableNetworking()), "disableNetworking");+ rejectOnFargate(def.getLinks() != null && !def.getLinks().isEmpty(), "links");+ rejectOnFargate(def.getDnsServers() != null && !def.getDnsServers().isEmpty(), "dnsServers");+ rejectOnFargate(def.getDnsSearchDomains() != null && !def.getDnsSearchDomains().isEmpty(),+ "dnsSearchDomains");+ rejectOnFargate(def.getDockerSecurityOptions() != null && !def.getDockerSecurityOptions().isEmpty(),+ "dockerSecurityOptions");+ rejectOnFargate(notEmpty(def.getUnparsed(), "extraHosts"), "extraHosts");+ validateFargateLinuxParameters(def);+ validateFargateResourceRequirements(def);+ }+ }++ private static void rejectOnFargate(boolean present, String parameter) {+ if (present) {+ throw new AwsException("ClientException",+ "Fargate compatible task definitions do not support " + parameter + ".", 400);+ }+ }++ /** {@code maxSwap} and {@code swappiness} have no meaning on Fargate's managed kernel. */+ @SuppressWarnings("unchecked")+ private static void validateFargateLinuxParameters(ContainerDefinition def) {+ Object linuxParameters = def.getUnparsed() == null ? null : def.getUnparsed().get("linuxParameters");+ if (!(linuxParameters instanceof Map<?, ?> parameters)) {+ return;+ }+ rejectOnFargate(parameters.get("maxSwap") != null, "maxSwap");+ rejectOnFargate(parameters.get("swappiness") != null, "swappiness");+ }++ /** A Fargate task cannot ask for a GPU; only {@code InferenceAccelerator} requirements remain. */+ private static void validateFargateResourceRequirements(ContainerDefinition def) {+ Object requirements = def.getUnparsed() == null ? null : def.getUnparsed().get("resourceRequirements");+ if (!(requirements instanceof List<?> entries)) {+ return;+ }+ for (Object entry : entries) {+ if (entry instanceof Map<?, ?> requirement && "GPU".equals(requirement.get("type"))) {+ throw new AwsException("ClientException",+ "Fargate compatible task definitions do not support gpu.", 400);+ }+ }+ }++ private static boolean notEmpty(Map<String, Object> members, String key) {+ Object value = members == null ? null : members.get(key);+ if (value instanceof Collection<?> collection) {+ return !collection.isEmpty();+ }+ return value != null;+ }+/*** RegisterTaskDefinition-time validation of a FireLens config that comes from S3, in the* order ECS applies it.@@ -507,6 +824,8 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabif (cpu == 4096) return memory >= 8192 && memory <= 30720 && memory % 1024 == 0;if (cpu == 8192) return memory >= 16384 && memory <= 61440 && memory % 4096 == 0;if (cpu == 16384) return memory >= 32768 && memory <= 122880 && memory % 8192 == 0;+ // 32 vCPU offers three fixed sizes rather than a range: 60 GB, 120 GB and 244 GB.+ if (cpu == 32768) return memory == 61440 || memory == 122880 || memory == 249856;return false;}@@ -582,25 +901,62 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabpublic TaskDefinition deregisterTaskDefinition(String taskDefinitionRef, String region) {TaskDefinition td = resolveTaskDefinitionOrThrow(taskDefinitionRef, region);- td.setStatus("INACTIVE");+ td.setStatus(STATUS_INACTIVE);+ td.setDeregisteredAt(Instant.now());taskDefinitions.put(td.getFamily() + ":" + td.getRevision(), td);return td;}+ /**+ * Moves task definition revisions to {@code DELETE_IN_PROGRESS}.+ *+ * <p>A revision has to be deregistered first, and has to be named with its revision rather+ * than by family. The revision is not dropped from the store: AWS keeps describing a+ * {@code DELETE_IN_PROGRESS} revision, and tasks and services already on it keep running,+ * which is also why it can no longer be used to start anything new.+ */public List<TaskDefinition> deleteTaskDefinitions(List<String> taskDefinitionRefs, String region) {+ if (taskDefinitionRefs.size() > MAX_TASKS_PER_RUN) {+ throw new AwsException("InvalidParameterException",+ "You can specify up to " + MAX_TASKS_PER_RUN + " task definitions.", 400);+ }List<TaskDefinition> deleted = new ArrayList<>();for (String ref : taskDefinitionRefs) {+ if (!namesARevision(ref)) {+ throw new AwsException("InvalidParameterException",+ "You must specify a revision to delete a task definition: " + ref, 400);+ }TaskDefinition td = resolveTaskDefinitionOrThrow(ref, region);- if (!"INACTIVE".equals(td.getStatus())) {+ if (!STATUS_INACTIVE.equals(td.getStatus())) {throw new AwsException("InvalidParameterException","Task definition " + ref + " must be INACTIVE before deletion.", 400);}- taskDefinitions.remove(td.getFamily() + ":" + td.getRevision());+ td.setStatus(STATUS_DELETE_IN_PROGRESS);+ td.setDeleteRequestedAt(Instant.now());+ taskDefinitions.put(td.getFamily() + ":" + td.getRevision(), td);deleted.add(td);}return deleted;}+ /** A reference names a revision when it carries one, as {@code family:1} or an ARN does. */+ private static boolean namesARevision(String ref) {+ if (ref == null) {+ return false;+ }+ String tail = ref.startsWith("arn:") ? ref.substring(ref.lastIndexOf('/') + 1) : ref;+ int colon = tail.lastIndexOf(':');+ if (colon < 0) {+ return false;+ }+ try {+ Integer.parseInt(tail.substring(colon + 1));+ return true;+ } catch (NumberFormatException e) {+ return false;+ }+ }+// ── Tasks ─────────────────────────────────────────────────────────────────public List<EcsTask> runTask(String clusterRef, String taskDefinitionRef, int count,@@ -614,14 +970,28 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabrequest.setLaunchType(launchType);request.setGroup(group);request.setStartedBy(startedBy);- request.setContainerOverrides(containerOverrides);request.setNetworkConfiguration(networkConfiguration);+ if (containerOverrides != null && !containerOverrides.isEmpty()) {+ TaskOverride overrides = new TaskOverride();+ overrides.setContainerOverrides(containerOverrides);+ request.setOverrides(overrides);+ }return runTask(request, region);}public List<EcsTask> runTask(RunTaskRequest request, String region) {+ // RunTask places at most 10 tasks per call, and propagating a service's tags is a service+ // concept: both are rejected rather than quietly ignored.+ if (request.getCount() < 1 || request.getCount() > MAX_TASKS_PER_RUN) {+ throw new AwsException("InvalidParameterException",+ "count must be between 1 and " + MAX_TASKS_PER_RUN + ".", 400);+ }+ if (PROPAGATE_TAGS_SERVICE.equals(request.getPropagateTags())) {+ throw new AwsException("InvalidParameterException",+ "The SERVICE option is not supported when running a task.", 400);+ }EcsCluster cluster = resolveClusterOrDefault(request.getCluster(), region);- TaskDefinition taskDef = resolveTaskDefinitionOrThrow(request.getTaskDefinition(), region);+ TaskDefinition taskDef = resolveLaunchableTaskDefinition(request.getTaskDefinition(), region);return launchTasks(cluster, taskDef, request, null, null, region);}@@ -639,14 +1009,23 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabpublic List<EcsTask> startTask(RunTaskRequest request, String region) {List<String> instanceRefs = request.getContainerInstances() != null? request.getContainerInstances() : List.of();+ // StartTask places onto instances the caller names, so naming none is a malformed request,+ // and ECS takes at most ten of them per call.+ if (instanceRefs.isEmpty()) {+ throw new AwsException("InvalidParameterException",+ "containerInstances is required and cannot be empty.", 400);+ }+ if (instanceRefs.size() > MAX_TASKS_PER_RUN) {+ throw new AwsException("InvalidParameterException",+ "You can specify up to " + MAX_TASKS_PER_RUN + " container instances.", 400);+ }EcsCluster cluster = resolveClusterOrDefault(request.getCluster(), region);- TaskDefinition taskDef = resolveTaskDefinitionOrThrow(request.getTaskDefinition(), region);+ TaskDefinition taskDef = resolveLaunchableTaskDefinition(request.getTaskDefinition(), region);List<EcsTask> result = new ArrayList<>();// StartTask places one task onto each named container instance, which is EC2 by definition.request.setCount(1);request.setLaunchType(LaunchType.EC2);- request.setContainerOverrides(null);- request.setNetworkConfiguration(null);+ request.setCapacityProviderStrategy(null);for (String instanceRef : instanceRefs) {ContainerInstance instance = resolveContainerInstanceOrThrow(cluster.getClusterArn(), instanceRef);result.addAll(launchTasks(cluster, taskDef, request,@@ -673,41 +1052,58 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabthrow new AwsException("ClientException","Task definition " + taskDef.getTaskDefinitionArn() + " has no container definitions.", 400);}- int count = request.getCount();- LaunchType launchType = request.getLaunchType();- String group = request.getGroup();- String startedBy = request.getStartedBy();- List<ContainerOverride> containerOverrides = request.getContainerOverrides();+ int count = Math.max(1, request.getCount());NetworkConfiguration networkConfiguration = request.getNetworkConfiguration();+ validateLaunchNetworking(taskDef, networkConfiguration);+ List<Placement> placements = resolvePlacements(cluster, request, count);+ List<ContainerOverride> containerOverrides = request.getContainerOverrides();List<EcsTask> launched = new ArrayList<>();for (int i = 0; i < count; i++) {String taskId = UUID.randomUUID().toString().replace("-", "");String taskArn = regionResolver.buildArn("ecs", region,"task/" + cluster.getClusterName() + "/" + taskId);+ Placement placement = placements.get(i);EcsTask task = new EcsTask();task.setTaskArn(taskArn);task.setClusterArn(cluster.getClusterArn());task.setTaskDefinitionArn(taskDef.getTaskDefinitionArn());- task.setLaunchType(launchType != null ? launchType : LaunchType.FARGATE);- task.setGroup(group);- task.setStartedBy(startedBy);+ task.setLaunchType(placement.launchType());+ task.setCapacityProviderName(placement.capacityProviderName());+ task.setGroup(request.getGroup() != null ? request.getGroup() : "family:" + taskDef.getFamily());+ task.setStartedBy(request.getStartedBy());task.setOwningServiceArn(owningServiceArn);task.setLastStatus(TaskStatus.PENDING.name());task.setDesiredStatus(TaskStatus.RUNNING.name());- task.setCpu(taskDef.getCpu());- task.setMemory(taskDef.getMemory());+ task.setCpu(effectiveCpu(taskDef, request));+ task.setMemory(effectiveMemory(taskDef, request));task.setCreatedAt(Instant.now());task.setContainers(List.of());task.setContainerInstanceArn(containerInstanceArn);task.setNetworkConfiguration(networkConfiguration);+ task.setOverrides(request.getOverrides());+ task.setEnableExecuteCommand(request.isEnableExecuteCommand());+ task.setAttributes(List.of(new Attribute(CPU_ARCHITECTURE_ATTRIBUTE, hostCpuArchitecture(),+ null, null)));+ applyPlatform(task, taskDef, request);+ Map<String, String> taskTags = PROPAGATE_TAGS_TASK_DEFINITION.equals(request.getPropagateTags())+ ? taskDef.getTags() : request.getTags();+ if (taskTags != null && !taskTags.isEmpty()) {+ task.setTags(new LinkedHashMap<>(taskTags));+ }+ // Before the task is visible: an awsvpc task that cannot get its ENI (an unknown+ // subnet, say) never existed, the way AWS rejects the request rather than placing it.+ containerManager.attachTaskNetwork(task, taskDef, region);tasks.put(taskArn, task);if (dockerMode) {try {+ task.setPullStartedAt(Instant.now());EcsTaskHandle handle = containerManager.startTask(task, taskDef, containerOverrides, region);+ task.setPullStoppedAt(Instant.now());taskHandles.put(taskArn, handle);+ markTaskRunning(task);cluster.setRunningTasksCount(cluster.getRunningTasksCount() + 1);LOG.infov("Started ECS task (docker): {0}", taskArn);registerTaskWithLoadBalancers(task, cluster, region);@@ -726,14 +1122,17 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabtask.setStoppedReason(resourceInitError? e.getMessage(): "Failed to start: " + e.getMessage());+ task.setStopCode(STOP_CODE_TASK_FAILED_TO_START);task.setStoppedAt(Instant.now());+ task.bumpVersion();+ containerManager.releaseTaskNetwork(task, region);if (eventPublisher != null) {eventPublisher.emitTaskLadder(task, TaskStatus.PENDING, TaskStatus.STOPPED, region);}}} else {- task.setLastStatus(TaskStatus.RUNNING.name());- task.setStartedAt(Instant.now());+ task.setContainers(mockContainers(task, taskDef, region));+ markTaskRunning(task);cluster.setRunningTasksCount(cluster.getRunningTasksCount() + 1);LOG.infov("Started ECS task (mock): {0}", taskArn);if (eventPublisher != null) {@@ -747,6 +1146,55 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabreturn launched;}+ /**+ * The container models a mock-mode task reports. Nothing is running behind them, so they carry+ * no runtime id, but a task with an empty {@code containers} list is unlike anything AWS+ * returns and breaks every client that reads the list.+ */+ private List<Container> mockContainers(EcsTask task, TaskDefinition taskDef, String region) {+ String taskId = task.getTaskArn().substring(task.getTaskArn().lastIndexOf('/') + 1);+ List<Container> containers = new ArrayList<>();+ for (ContainerDefinition def : taskDef.getContainerDefinitions()) {+ Container container = new Container();+ container.setTaskArn(task.getTaskArn());+ container.setName(def.getName());+ container.setImage(def.getImage());+ container.setLastStatus(TaskStatus.RUNNING.name());+ container.setContainerArn(regionResolver.buildArn("ecs", region,+ "container/" + taskId + "/" + def.getName()));+ container.setNetworkBindings(List.of());+ if (def.getCpu() != null) {+ container.setCpu(String.valueOf(def.getCpu()));+ }+ if (def.getMemory() != null) {+ container.setMemory(String.valueOf(def.getMemory()));+ }+ if (task.getNetworkInterfaceId() != null) {+ container.setNetworkInterfaces(List.of(new TaskNetworkInterface(+ task.getAttachmentId(), task.getPrivateIpAddress(), null)));+ }+ if (task.isEnableExecuteCommand()) {+ container.setManagedAgents(List.of(ManagedAgent.executeCommandAgent(Instant.now())));+ }+ containers.add(container);+ }+ return containers;+ }++ /**+ * The state a task reaches once its containers are up: RUNNING, connected, and healthy as far+ * as ECS can tell. {@code healthStatus} stays UNKNOWN unless a container declares a health+ * check, which is what AWS reports for a task nothing is probing.+ */+ private static void markTaskRunning(EcsTask task) {+ task.setLastStatus(TaskStatus.RUNNING.name());+ task.setStartedAt(Instant.now());+ task.setConnectivity(CONNECTIVITY_CONNECTED);+ task.setConnectivityAt(Instant.now());+ task.setHealthStatus(HEALTH_STATUS_UNKNOWN);+ task.bumpVersion();+ }+/*** Launches one task on behalf of a service, stamping it with the service's ARN so later* reconciliation can recognize it as service-owned without trusting the caller-settable@@ -758,23 +1206,272 @@ public class EcsService implements ContainerTeardown, ResourceProvider, ResettabRunTaskRequest request = new RunTaskRequest();request.setCount(1);request.setLaunchType(launchType);- request.setGroup(svc.getServiceName());- request.setStartedBy("ecs-svc");+ // AWS labels a service's tasks "service:<name>" and attributes them to the deployment.+ request.setGroup("service:" + svc.getServiceName());+ request.setStartedBy(deploymentId(svc));request.setNetworkConfiguration(svc.getNetworkConfiguration());+ // A service pinned to a capacity provider places its tasks through it, unless the+ // reconciler is placing a DAEMON task on a named container instance.+ if (containerInstanceArn == null) {+ request.setCapacityProviderStrategy(svc.getCapacityProviderStrategy());+ }EcsTask task = launchTasks(cluster, taskDef, request, containerInstanceArn,svc.getServiceArn(), region).getFirst();task.setDeploymentId(deploymentId(svc));return task;}+ /** Where a task runs: a launch type, or the capacity provider that chose one for it. */+ private record Placement(LaunchType launchType, String capacityProviderName) {}++ /**+ * Decides where each of {@code count} tasks runs, in request order.+ *+ * <p>A capacity provider strategy wins over a launch type (the two are mutually exclusive on+ * the wire), and an absent strategy falls back to the cluster's default one. With neither,+ * the task keeps Floci's FARGATE default: a local cluster has no container instances, so EC2+ * would have nowhere to place it.+ */+ private List<Placement> resolvePlacements(EcsCluster cluster, RunTaskRequest request, int count) {+ List<CapacityProviderStrategyItem> strategy = request.getCapacityProviderStrategy();+ if (strategy != null && !strategy.isEmpty() && request.getLaunchType() != null) {+ throw new AwsException("InvalidParameterException",+ "You cannot specify both a launch type and a capacity provider strategy in the "+ + "same request. Specify only one.", 400);+ }+ if ((strategy == null || strategy.isEmpty()) && request.getLaunchType() == null) {+ strategy = clusterDefaultStrategy(cluster);+ }+ if (strategy == null || strategy.isEmpty()) {+ LaunchType launchType = request.getLaunchType() != null ? request.getLaunchType() : LaunchType.FARGATE;+ return Collections.nCopies(count, new Placement(launchType, null));+ }+ return distribute(strategy, count);+ }++ /** The cluster's {@code defaultCapacityProviderStrategy}, which is stored as raw JSON. */+ private List<CapacityProviderStrategyItem> clusterDefaultStrategy(EcsCluster cluster) {+ List<Map<String, Object>> raw = cluster.getDefaultCapacityProviderStrategy();+ if (raw == null || raw.isEmpty()) {+ return List.of();+ }+ List<CapacityProviderStrategyItem> result = new ArrayList<>();+ for (Map<String, Object> entry : raw) {+ Object provider = entry.get("capacityProvider");+ if (provider == null) {+ continue;+ }+ result.add(new CapacityProviderStrategyItem(provider.toString(),+ intValue(entry.get("weight")), intValue(entry.get("base"))));+ }+ return result;+ }++ private static int intValue(Object value) {+ return value instanceof Number number ? number.intValue() : 0;+ }++ /**+ * Checks a strategy against the bounds the ECS model puts on it: at most twenty providers,+ * each entry's {@code weight} between 0 and 1,000 and its {@code base} between 0 and 100,000,+ * and only one entry carrying a base.+ *+ * <p>A provider weighing 0 places nothing beyond its base, so a strategy of several providers+ * that all weigh 0 has nowhere to put the tasks no base covers and the model has RunTask and+ * CreateService fail on it. A lone entry weighing 0 is left alone: the model scopes that rule+ * to a strategy naming more than one provider.+ */+ private void validateCapacityProviderStrategy(List<CapacityProviderStrategyItem> strategy) {+ if (strategy.size() > MAX_CAPACITY_PROVIDERS_PER_STRATEGY) {+ throw new AwsException("InvalidParameterException",+ "A capacity provider strategy can contain a maximum of "+ + MAX_CAPACITY_PROVIDERS_PER_STRATEGY + " capacity providers.", 400);+ }+ for (CapacityProviderStrategyItem item : strategy) {+ if (item.weight() < 0 || item.weight() > MAX_CAPACITY_PROVIDER_WEIGHT) {+ throw new AwsException("InvalidParameterException",+ "The weight of a capacity provider strategy entry must be between 0 and "+ + MAX_CAPACITY_PROVIDER_WEIGHT + ".", 400);+ }+ if (item.base() < 0 || item.base() > MAX_CAPACITY_PROVIDER_BASE) {+ throw new AwsException("InvalidParameterException",+ "The base of a capacity provider strategy entry must be between 0 and "+ + MAX_CAPACITY_PROVIDER_BASE + ".", 400);+ }+ }+ if (strategy.stream().filter(item -> item.base() > 0).count() > 1) {+ throw new AwsException("InvalidParameterException",+ "Only one capacity provider in a capacity provider strategy can have a base defined.", 400);+ }+ if (strategy.size() > 1 && strategy.stream().allMatch(item -> item.weight() == 0)) {+ throw new AwsException("InvalidParameterException",+ "At least one capacity provider in a capacity provider strategy must have a "+ + "weight greater than zero.", 400);+ }+ strategy.forEach(item -> requireCapacityProvider(item.capacityProvider()));+ }++ /**+ * Spreads {@code count} tasks over a strategy the way ECS does: the single entry that declares+ * a {@code base} is filled first, then whatever is left is split by weight. Leftovers from the+ * integer split go to the heaviest entries, so a 1:1 strategy with an odd count still places+ * every task.+ */+ private List<Placement> distribute(List<CapacityProviderStrategyItem> strategy, int count) {+ validateCapacityProviderStrategy(strategy);++ List<Placement> placements = new ArrayList<>();+ for (CapacityProviderStrategyItem item : strategy) {+ for (int i = 0; i < item.base() && placements.size() < count; i++) {+ placements.add(placementFor(item.capacityProvider()));+ }+ }+ int remaining = count - placements.size();+ if (remaining <= 0) {+ return placements;+ }+ int totalWeight = strategy.stream().mapToInt(CapacityProviderStrategyItem::weight).sum();+ if (totalWeight <= 0) {+ // Validation already rejected a multi-entry strategy whose weights are all 0, so the+ // only way to get here is a lone entry that carries no weight: it is the one provider+ // the request named, and the tasks its base did not cover go on it.+ for (int i = 0; i < remaining; i++) {+ placements.add(placementFor(strategy.getFirst().capacityProvider()));+ }+ return placements;+ }+ int[] shares = new int[strategy.size()];+ int assigned = 0;+ for (int i = 0; i < strategy.size(); i++) {+ shares[i] = remaining * strategy.get(i).weight() / totalWeight;+ assigned += shares[i];+ }+ List<Integer> byWeightDescending = new ArrayList<>();+ for (int i = 0; i < strategy.size(); i++) {+ byWeightDescending.add(i);+ }+ byWeightDescending.sort(Comparator.comparingInt((Integer i) -> strategy.get(i).weight()).reversed());+ for (int i = 0; assigned < remaining; i++) {+ shares[byWeightDescending.get(i % byWeightDescending.size())]++;+ assigned++;+ }+ for (int i = 0; i < strategy.size(); i++) {+ for (int placed = 0; placed < shares[i]; placed++) {+ placements.add(placementFor(strategy.get(i).capacityProvider()));+ }+ }+ return placements;+ }++ /** FARGATE and FARGATE_SPOT place Fargate tasks; any other provider is backed by an ASG. */+ private static Placement placementFor(String capacityProvider) {+ LaunchType launchType = FARGATE_CAPACITY_PROVIDERS.contains(capacityProvider)+ ? LaunchType.FARGATE : LaunchType.EC2;+ return new Placement(launchType, capacityProvider);+ }++ /** Accepts the two built-in Fargate providers as well as anything CreateCapacityProvider made. */+ private void requireCapacityProvider(String name) {+ if (name == null || name.isBlank()) {+ throw new AwsException("InvalidParameterException",+ "A capacity provider strategy entry must name a capacity provider.", 400);+ }+ if (FARGATE_CAPACITY_PROVIDERS.contains(name) || capacityProviders.containsKey(name)) {+ return;+ }+ boolean knownByArn = capacityProviders.values().stream()+ .anyMatch(cp -> name.equals(cp.getCapacityProviderArn()));+ if (!knownByArn) {+ throw new AwsException("ClientException",+ "The specified capacity provider '" + name + "' was not found. "+ + "Specify a valid capacity provider and try again.", 400);+ }+ }++ /** An awsvpc task cannot be placed without the subnets its ENI goes into. */+ private static void validateLaunchNetworking(TaskDefinition taskDef, NetworkConfiguration networkConfiguration) {+ if (taskDef.getNetworkMode() != NetworkMode.awsvpc) {+ return;+ }+ boolean hasSubnets = networkConfiguration != null+ && networkConfiguration.getAwsvpcConfiguration() != null+ && networkConfiguration.getAwsvpcConfiguration().getSubnets() != null+ && !networkConfiguration.getAwsvpcConfiguration().getSubnets().isEmpty();+ if (!hasSubnets) {+ throw new AwsException("InvalidParameterException",+ "Network Configuration must be provided when networkMode 'awsvpc' is specified.", 400);+ }+ }++ private static String effectiveCpu(TaskDefinition taskDef, RunTaskRequest request) {+ TaskOverride overrides = request.getOverrides();+ if (overrides != null && overrides.getCpu() != null) {+ return overrides.getCpu();+ }+ return taskDef.getCpu();+ }++ private static String effectiveMemory(TaskDefinition taskDef, RunTaskRequest request) {+ TaskOverride overrides = request.getOverrides();+ if (overrides != null && overrides.getMemory() != null) {+ return overrides.getMemory();+ }+ return taskDef.getMemory();+ }++ /**+ * The architecture a task reports running on. A task definition's {@code runtimePlatform} does+ * not move it anywhere: every local task runs on the host, so the host's architecture is what+ * the attribute says.+ */+ private static String hostCpuArchitecture() {+ String architecture = System.getProperty("os.arch", "");+ return switch (architecture) {+ case "aarch64", "arm64" -> "arm64";+ default -> "x86_64";+ };+ }++ /**+ * Stamps the Fargate platform members. {@code LATEST} resolves to a concrete version the way+ * AWS resolves it, since a client that asked for LATEST still reads back the version it got.+ * An EC2 task has neither member.+ */+ private static void applyPlatform(EcsTask task, TaskDefinition taskDef, RunTaskRequest request) {+ if (task.getLaunchType() != LaunchType.FARGATE) {+ return;+ }+ String requested = request.getPlatformVersion();+ task.setPlatformVersion(requested == null || requested.isBlank() || PLATFORM_VERSION_LATEST.equals(requested)+ ? DEFAULT_PLATFORM_VERSION : requested);+ task.setPlatformFamily(platformFamilyOf(taskDef));+ TaskOverride overrides = request.getOverrides();+ EphemeralStorage ephemeralStorage = overrides != null && overrides.getEphemeralStorage() != null+ ? overrides.getEphemeralStorage() : taskDef.getEphemeralStorage();+ task.setEphemeralStorage(ephemeralStorage != null+ ? ephemeralStorage : new EphemeralStorage(EphemeralStorage.DEFAULT_SIZE_IN_GIB));+ }+public EcsTask stopTask(String clusterRef, String taskRef, String reason, String region) {+ return stopTask(clusterRef, taskRef, reason, STOP_CODE_USER_INITIATED, region);+ }++ /**+ * @param stopCode why the task is going away, as the {@code stopCode} AWS reports: a caller's+ * StopTask is {@code UserInitiated}, anything the reconciler decides is+ * {@code ServiceSchedulerInitiated}.+ */+ private EcsTask stopTask(String clusterRef, String taskRef, String reason, String stopCode, String region) {EcsTask task = resolveTaskOrThrow(taskRef, region);if (TaskStatus.STOPPED.name().equals(task.getLastStatus())) {return task;}task.setDesiredStatus(TaskStatus.STOPPED.name());task.setLastStatus(TaskStatus.STOPPING.name());+ task.setStoppingAt(Instant.now());task.setStoppedReason(reason != null ? reason : "Stopped by user");+ task.setStopCode(stopCode);+ task.bumpVersion();deregisterTaskFromLoadBalancers(task, region);@@ -790,6 +1487,9 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabtask.setLastStatus(TaskStatus.STOPPED.name());task.setStoppedAt(Instant.now());+ task.setExecutionStoppedAt(Instant.now());+ task.bumpVersion();+ containerManager.releaseTaskNetwork(task, region);if (task.getContainers() != null) {final Map<String, Integer> codes = exitCodes;task.getContainers().forEach(c -> {@@ -856,14 +1556,34 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettab}public List<EcsTask> describeTasks(String clusterRef, List<String> taskRefs, String region) {+ return describeTasksDetailed(clusterRef, taskRefs, region).tasks();+ }++ public record DescribeTasksResult(List<EcsTask> tasks, List<Failure> failures) {}++ /**+ * Resolves each reference, reporting the ones that do not exist as {@code MISSING} failures.+ * ECS answers a describe for an unknown task with a failure entry rather than an error, and the+ * {@code TasksRunning} and {@code TasksStopped} waiters treat a MISSING failure as terminal: a+ * describe that returns neither the task nor a failure leaves them polling until they time out.+ */+ public DescribeTasksResult describeTasksDetailed(String clusterRef, List<String> taskRefs,+ String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);List<EcsTask> result = new ArrayList<>();+ List<Failure> failures = new ArrayList<>();for (String ref : taskRefs) {EcsTask task = resolveTask(ref, region);if (task != null) {result.add(task);+ } else {+ failures.add(Failure.missing(ref != null && ref.startsWith("arn:")+ ? ref+ : regionResolver.buildArn("ecs", region,+ "task/" + cluster.getClusterName() + "/" + ref)));}}- return result;+ return new DescribeTasksResult(result, failures);}public List<String> listTasks(String clusterRef, String family, String desiredStatus,@@ -1000,13 +1720,12 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettab}public EcsServiceModel createService(CreateServiceRequest request, String region) {- String serviceName = request.getServiceName();- int desiredCount = request.getDesiredCount();EcsCluster cluster = resolveClusterOrDefault(request.getCluster(), region);// AWS resolves family / family:revision at create time and stores the ARN; the// reconciler compares it with each task's taskDefinitionArn, so pin it here.- String taskDefinition =- resolveTaskDefinitionOrThrow(request.getTaskDefinition(), region).getTaskDefinitionArn();+ TaskDefinition taskDef = resolveLaunchableTaskDefinition(request.getTaskDefinition(), region);+ String taskDefinition = taskDef.getTaskDefinitionArn();+ String serviceName = request.getServiceName();String key = serviceKey(region, cluster.getClusterName(), serviceName);if (services.containsKey(key)) {@@ -1017,6 +1736,13 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettab"Creation of service was not idempotent.", 400);}}+ if (request.getLaunchType() != null && request.getCapacityProviderStrategy() != null+ && !request.getCapacityProviderStrategy().isEmpty()) {+ throw new AwsException("InvalidParameterException",+ "You cannot specify both a launch type and a capacity provider strategy in the "+ + "same request. Specify only one.", 400);+ }+ validateLaunchNetworking(taskDef, request.getNetworkConfiguration());EcsServiceModel svc = new EcsServiceModel();svc.setServiceArn(regionResolver.buildArn("ecs", region,@@ -1024,7 +1750,9 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabsvc.setServiceName(serviceName);svc.setClusterArn(cluster.getClusterArn());svc.setTaskDefinition(taskDefinition);- svc.setLaunchType(request.getLaunchType() != null ? request.getLaunchType() : LaunchType.FARGATE);+ svc.setCapacityProviderStrategy(request.getCapacityProviderStrategy());+ svc.setLaunchType(serviceLaunchType(cluster, request));+ int desiredCount = request.getDesiredCount();if (desiredCount < 0) {throw new AwsException("InvalidParameterException", "desiredCount cannot be a negative number.", 400);}@@ -1112,6 +1840,7 @@ public class EcsService implements ContainerTeardown, ResourceProvider, ResettabEcsCluster cluster = resolveClusterOrDefault(request.getCluster(), region);String serviceName = extractServiceName(request.getService());+ boolean forceNewDeployment = request.isForceNewDeployment();String key = serviceKey(region, cluster.getClusterName(), serviceName);EcsServiceModel svc = services.get(key);@@ -1122,12 +1851,11 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabthrow new AwsException("ServiceNotActiveException","Service " + serviceName + " is not active.", 400);}- Integer desiredCount = request.getDesiredCount();- if (desiredCount != null) {- if (desiredCount < 0) {+ if (request.getDesiredCount() != null) {+ if (request.getDesiredCount() < 0) {throw new AwsException("InvalidParameterException", "desiredCount cannot be a negative number.", 400);}- svc.setDesiredCount(desiredCount);+ svc.setDesiredCount(request.getDesiredCount());}if (request.getNetworkConfiguration() != null) {svc.setNetworkConfiguration(request.getNetworkConfiguration());@@ -1135,6 +1863,12 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabif (request.getAvailabilityZoneRebalancing() != null) {svc.setAvailabilityZoneRebalancing(request.getAvailabilityZoneRebalancing());}+ if (request.getCapacityProviderStrategy() != null) {+ svc.setCapacityProviderStrategy(request.getCapacityProviderStrategy());+ svc.setLaunchType(request.getCapacityProviderStrategy().isEmpty()+ ? svc.getLaunchType()+ : placementFor(request.getCapacityProviderStrategy().getFirst().capacityProvider()).launchType());+ }// UpdateServiceRequest.serviceConnectConfiguration is documented as "This parameter// triggers a new service deployment", so a real change rolls the deployment the way a// task-definition change does. An omitted parameter is not a change and rolls nothing.@@ -1146,12 +1880,11 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettab}boolean taskDefChanged = false;if (request.getTaskDefinition() != null) {- String resolvedArn =- resolveTaskDefinitionOrThrow(request.getTaskDefinition(), region).getTaskDefinitionArn();- taskDefChanged = !resolvedArn.equals(svc.getTaskDefinition());- svc.setTaskDefinition(resolvedArn);+ TaskDefinition resolved = resolveLaunchableTaskDefinition(request.getTaskDefinition(), region);+ taskDefChanged = !resolved.getTaskDefinitionArn().equals(svc.getTaskDefinition());+ svc.setTaskDefinition(resolved.getTaskDefinitionArn());}- if (taskDefChanged || request.isForceNewDeployment() || serviceConnectChanged) {+ if (taskDefChanged || forceNewDeployment || serviceConnectChanged) {svc.setDeploymentId(newDeploymentId());svc.setLastDeploymentAt(Instant.now());recordServiceDeployment(svc, svc.getTaskDefinition(), region);@@ -1164,6 +1897,44 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabreturn svc;}+ /**+ * The launch type a service's tasks get. An explicit one wins; otherwise the first entry of+ * the service's own capacity provider strategy, then the cluster's default strategy, decides+ * it, and with neither the service keeps Floci's FARGATE default.+ */+ private LaunchType serviceLaunchType(EcsCluster cluster, CreateServiceRequest request) {+ if (request.getLaunchType() != null) {+ return request.getLaunchType();+ }+ List<CapacityProviderStrategyItem> strategy = request.getCapacityProviderStrategy();+ if (strategy == null || strategy.isEmpty()) {+ strategy = clusterDefaultStrategy(cluster);+ }+ if (strategy == null || strategy.isEmpty()) {+ return LaunchType.FARGATE;+ }+ validateCapacityProviderStrategy(strategy);+ return placementFor(strategy.getFirst().capacityProvider()).launchType();+ }++ /**+ * The platform family a Fargate task or service reports.+ *+ * <p>A Linux task reports {@code Linux}, which is what DescribeTasks answers with. A Windows+ * task reports the Windows Server family from the task definition's+ * {@code runtimePlatform.operatingSystemFamily}, because that is the value a Windows task has+ * to match against its container image.+ */+ private static String platformFamilyOf(TaskDefinition taskDef) {+ String operatingSystemFamily = taskDef != null && taskDef.getRuntimePlatform() != null+ ? taskDef.getRuntimePlatform().operatingSystemFamily() : null;+ if (operatingSystemFamily == null || operatingSystemFamily.isBlank()+ || operatingSystemFamily.startsWith("LINUX")) {+ return DEFAULT_PLATFORM_FAMILY;+ }+ return operatingSystemFamily;+ }+public EcsServiceModel deleteService(String clusterRef, String serviceName, boolean force, String region) {EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);@@ -1193,7 +1964,8 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettab.filter(t -> !TaskStatus.STOPPED.name().equals(t.getLastStatus())).forEach(t -> {try {- stopTask(cluster.getClusterName(), t.getTaskArn(), "Service deleted", region);+ stopTask(cluster.getClusterName(), t.getTaskArn(), "Service deleted",+ STOP_CODE_SERVICE_SCHEDULER_INITIATED, region);} catch (Exception e) {LOG.warnv("Failed to stop task {0} on service delete: {1}",t.getTaskArn(), e.getMessage());@@ -1246,8 +2018,9 @@ public class EcsService implements ContainerTeardown, ResourceProvider, ResettabString prefix = serviceKeyPrefix(region, cluster.getClusterName());return services.entrySet().stream().filter(e -> e.getKey().startsWith(prefix))- .filter(e -> !"INACTIVE".equals(e.getValue().getStatus()))- .map(e -> e.getValue().getServiceArn())+ .map(Map.Entry::getValue)+ .filter(svc -> !"INACTIVE".equals(svc.getStatus()))+ .map(EcsServiceModel::getServiceArn).toList();}@@ -1902,6 +2675,8 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabreturn;}+ updateHealth(task, handle);+// Inspect every container; abort if any are still running.Map<String, Integer> exitCodes = new LinkedHashMap<>();for (Map.Entry<String, String> entry : handle.getContainerIds().entrySet()) {@@ -1934,8 +2709,12 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabtask.setLastStatus(TaskStatus.STOPPED.name());task.setDesiredStatus(TaskStatus.STOPPED.name());+ task.setStoppingAt(Instant.now());task.setStoppedAt(Instant.now());+ task.setExecutionStoppedAt(Instant.now());task.setStoppedReason("Essential container in task exited");+ task.setStopCode(STOP_CODE_ESSENTIAL_CONTAINER_EXITED);+ task.bumpVersion();EcsCluster cluster = resolveClusterByArn(task.getClusterArn());if (cluster != null && cluster.getRunningTasksCount() > 0) {@@ -1943,20 +2722,56 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettab}LOG.infov("ECS task {0} reconciled to STOPPED (all containers exited)", taskArn);+ String region = taskRegion(task);+ containerManager.releaseTaskNetwork(task, region);if (eventPublisher != null) {- String region = null;- if (task.getTaskArn() != null) {- try {- region = AwsArnUtils.parse(task.getTaskArn()).region();- } catch (Exception e) {- LOG.warnv(e, "Could not parse region from task ARN {0}, falling back to default region", task.getTaskArn());- }+ eventPublisher.emitTaskLadder(task, TaskStatus.RUNNING, TaskStatus.STOPPED, region);+ }+ }++ /**+ * Refreshes a running task's health from its containers' health checks. The task is HEALTHY+ * only when every container that has a health check reports healthy, UNHEALTHY as soon as one+ * does not, and UNKNOWN when nothing is being probed, which is how ECS aggregates it.+ */+ private void updateHealth(EcsTask task, EcsTaskHandle handle) {+ if (task.getContainers() == null || task.getContainers().isEmpty()) {+ return;+ }+ boolean anyUnhealthy = false;+ boolean anyHealthy = false;+ for (Container container : task.getContainers()) {+ String dockerId = handle.getContainerIds().get(container.getName());+ if (dockerId == null) {+ continue;}- if (region == null || region.isBlank()) {- region = regionResolver != null ? regionResolver.getDefaultRegion() : "us-east-1";+ String health = containerManager.ecsHealthStatus(dockerId);+ container.setHealthStatus(health);+ anyUnhealthy |= HEALTH_STATUS_UNHEALTHY.equals(health);+ anyHealthy |= HEALTH_STATUS_HEALTHY.equals(health);+ }+ String aggregate = anyUnhealthy ? HEALTH_STATUS_UNHEALTHY+ : anyHealthy ? HEALTH_STATUS_HEALTHY : HEALTH_STATUS_UNKNOWN;+ if (!aggregate.equals(task.getHealthStatus())) {+ task.setHealthStatus(aggregate);+ task.bumpVersion();+ }+ }++ /** The region a task lives in, read off its ARN, falling back to the default region. */+ private String taskRegion(EcsTask task) {+ if (task.getTaskArn() != null) {+ try {+ String region = AwsArnUtils.parse(task.getTaskArn()).region();+ if (region != null && !region.isBlank()) {+ return region;+ }+ } catch (Exception e) {+ LOG.warnv(e, "Could not parse region from task ARN {0}, falling back to default region",+ task.getTaskArn());}- eventPublisher.emitTaskLadder(task, TaskStatus.RUNNING, TaskStatus.STOPPED, region);}+ return regionResolver != null ? regionResolver.getDefaultRegion() : "us-east-1";}private void reconcileStoppedTask(String taskArn) {@@ -2025,7 +2840,8 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabtry {stopTask(clusterName, t.getTaskArn(), instanceArn == null || !activeArns.contains(instanceArn)? "Daemon task's container instance is no longer active"- : "Daemon service already has a task on this container instance", region);+ : "Daemon service already has a task on this container instance",+ STOP_CODE_SERVICE_SCHEDULER_INITIATED, region);} catch (Exception e) {LOG.warnv("Service reconciler failed to stop daemon task {0}: {1}", t.getTaskArn(), e.getMessage());}@@ -2194,7 +3010,8 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabtry {stopTask(clusterName, t.getTaskArn(),stale ? "Service deployment replaced task definition " + t.getTaskDefinitionArn()- : "Service scale-in", region);+ : "Service scale-in",+ STOP_CODE_SERVICE_SCHEDULER_INITIATED, region);} catch (Exception e) {LOG.warnv("Service reconciler failed to stop task {0}: {1}",t.getTaskArn(), e.getMessage());@@ -2266,6 +3083,21 @@ public class EcsService implements ContainerTeardown, ResourceProvider, Resettabthrow new AwsException("ClientException", "Unable to describe task definition: " + ref, 400);}+ /**+ * Resolves a task definition for something that is about to run on it. A revision on its way+ * out cannot start new work: AWS refuses to run a task or create a service on a+ * {@code DELETE_IN_PROGRESS} revision, while the tasks already on it keep running.+ */+ private TaskDefinition resolveLaunchableTaskDefinition(String ref, String region) {+ TaskDefinition td = resolveTaskDefinitionOrThrow(ref, region);+ if (STATUS_DELETE_IN_PROGRESS.equals(td.getStatus())) {+ throw new AwsException("ClientException",+ "The task definition " + td.getTaskDefinitionArn() + " is being deleted and "+ + "cannot be used to start new tasks.", 400);+ }+ return td;+ }+private EcsTask resolveTask(String ref, String region) {EcsTask task = tasks.get(ref);if (task != null) { return task; }diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.javaindex c58554a71c..c880776c41 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.java@@ -22,17 +22,20 @@ import io.github.hectorvent.floci.services.ec2.model.SecurityGroup;import io.github.hectorvent.floci.services.ecs.model.AwsVpcConfiguration;import io.github.hectorvent.floci.services.ecs.model.Container;import io.github.hectorvent.floci.services.ecs.model.ContainerDefinition;+import io.github.hectorvent.floci.services.ecs.model.ContainerDependency;import io.github.hectorvent.floci.services.ecs.model.ContainerOverride;import io.github.hectorvent.floci.services.ecs.model.EcsTask;import io.github.hectorvent.floci.services.ecs.model.EfsVolumeConfiguration;import io.github.hectorvent.floci.services.ecs.model.FirelensConfiguration;import io.github.hectorvent.floci.services.ecs.model.LogConfiguration;+import io.github.hectorvent.floci.services.ecs.model.ManagedAgent;import io.github.hectorvent.floci.services.ecs.model.MountPoint;import io.github.hectorvent.floci.services.ecs.model.NetworkBinding;import io.github.hectorvent.floci.services.ecs.model.NetworkMode;import io.github.hectorvent.floci.services.ecs.model.PortMapping;import io.github.hectorvent.floci.services.ecs.model.Secret;import io.github.hectorvent.floci.services.ecs.model.TaskDefinition;+import io.github.hectorvent.floci.services.ecs.model.TaskNetworkInterface;import io.github.hectorvent.floci.services.ecs.model.Volume;import io.github.hectorvent.floci.services.ecs.model.VolumeFrom;import io.github.hectorvent.floci.services.s3.S3Service;@@ -67,6 +70,7 @@ import java.util.List;import java.util.Map;import java.util.Optional;import java.util.Set;+import java.util.concurrent.TimeUnit;import java.util.stream.Stream;/**@@ -78,6 +82,17 @@ public class EcsContainerManager {private static final Logger LOG = Logger.getLogger(EcsContainerManager.class);+ private static final String ATTACHMENT_DELETED = "DELETED";++ /** EC2 error codes the task ENI path can raise, none of which RunTask declares. */+ private static final Set<String> EC2_NETWORK_LOOKUP_FAILURES =+ Set.of("InvalidSubnetID.NotFound", "InvalidGroup.NotFound");+ /** How long a container waits for a dependency that has to COMPLETE, SUCCEED or get HEALTHY. */+ private static final int DEPENDENCY_WAIT_SECONDS = 60;+ private static final long DEPENDENCY_POLL_MILLIS = 200;+ /** How long a killed container gets to register as exited before its code is read. */+ private static final int KILL_SETTLE_SECONDS = 5;+private final ContainerBuilder containerBuilder;private final ContainerLifecycleManager lifecycleManager;private final ContainerLogStreamer logStreamer;@@ -210,6 +225,7 @@ public class EcsContainerManager {try {for (ContainerDefinition def : launchOrder) {+ awaitDependencies(def, containerIds);String containerName = ContainerStorageHelper.dockerName(config, "floci-ecs-" + taskId + "-" + def.getName());// RunTask containerOverrides matched by container name: command replaces@@ -252,9 +268,33 @@ public class EcsContainerManager {specBuilder.withNamedVolume(firelensVolumeName, "/var/run");}- // Add memory limit if specified+ // Resource limits. A container-level memory is its own hard limit; without one the+ // container is capped at the task's memory, which is what a Fargate task gets+ // (the whole task shares one allocation). The task's cpu becomes a quota and a+ // container-level cpu becomes its share of that quota, as on ECS.if (def.getMemory() != null) {specBuilder.withMemoryMb(def.getMemory());+ } else {+ Integer taskMemoryMb = parseTaskMemoryMb(task.getMemory());+ if (taskMemoryMb != null) {+ specBuilder.withMemoryMb(taskMemoryMb);+ }+ }+ Integer taskCpuUnits = parseTaskCpuUnits(task.getCpu());+ if (taskCpuUnits != null) {+ specBuilder.withCpuUnits(taskCpuUnits);+ }+ if (def.getCpu() != null && def.getCpu() > 0) {+ specBuilder.withCpuShares(def.getCpu());+ }+ if (def.getUser() != null) {+ specBuilder.withUser(def.getUser());+ }+ if (def.getWorkingDirectory() != null) {+ specBuilder.withWorkingDir(def.getWorkingDirectory());+ }+ if (Boolean.TRUE.equals(def.getReadonlyRootFilesystem())) {+ specBuilder.withReadonlyRootfs();}// Add port mappings. In bridge/host mode an explicit hostPort is@@ -394,8 +434,7 @@ public class EcsContainerManager {lifecycleManager.removeVolume(firelensVolumeName);}if (protectedNetwork != null) {- firewallManager.unregister(protectedNetwork.eni().getNetworkInterfaceId());- ec2Service.deleteNetworkInterface(region, protectedNetwork.eni().getNetworkInterfaceId());+ releaseTaskNetwork(task, region);}throw e;}@@ -411,14 +450,160 @@ public class EcsContainerManager {containersInDefinitionOrder.add(container);}}+ // An awsvpc task's containers share the task ENI, and each reports it.+ if (task.getNetworkInterfaceId() != null) {+ List<TaskNetworkInterface> taskInterfaces = List.of(new TaskNetworkInterface(+ task.getAttachmentId(), task.getPrivateIpAddress(), null));+ containersInDefinitionOrder.forEach(container -> container.setNetworkInterfaces(taskInterfaces));+ }+ // ECS Exec is gated on the agent reporting RUNNING, which a client checks before it tries+ // to open a session.+ if (task.isEnableExecuteCommand()) {+ List<ManagedAgent> agents = List.of(ManagedAgent.executeCommandAgent(Instant.now()));+ containersInDefinitionOrder.forEach(container -> container.setManagedAgents(agents));+ }task.setContainers(containersInDefinitionOrder);task.setLastStatus(TaskStatus.RUNNING.name());task.setDesiredStatus(TaskStatus.RUNNING.name());task.setStartedAt(Instant.now());+ Map<String, Integer> stopTimeouts = new LinkedHashMap<>();+ for (ContainerDefinition def : taskDef.getContainerDefinitions()) {+ if (def.getStopTimeout() != null) {+ stopTimeouts.put(def.getName(), def.getStopTimeout());+ }+ }return new EcsTaskHandle(task.getTaskArn(), containerIds, logStreamsByContainerId,firelensVolumeName,- protectedNetwork == null ? null : protectedNetwork.eni().getNetworkInterfaceId(), region);+ protectedNetwork == null ? null : protectedNetwork.eni().getNetworkInterfaceId(), region,+ stopTimeouts);+ }++ /** A task-level {@code memory} is MiB as a plain number, or a {@code "1GB"}-style string. */+ private static Integer parseTaskMemoryMb(String memory) {+ if (memory == null || memory.isBlank()) {+ return null;+ }+ String trimmed = memory.trim().toUpperCase();+ try {+ if (trimmed.endsWith("GB")) {+ return (int) Math.round(Double.parseDouble(trimmed.substring(0, trimmed.length() - 2).trim()) * 1024);+ }+ return Integer.parseInt(trimmed.replaceAll("(?i)mib|mb", "").trim());+ } catch (NumberFormatException e) {+ LOG.debugv("Ignoring unparseable task memory {0}", memory);+ return null;+ }+ }++ /** A task-level {@code cpu} is CPU units as a plain number, or a {@code "0.5vCPU"}-style string. */+ private static Integer parseTaskCpuUnits(String cpu) {+ if (cpu == null || cpu.isBlank()) {+ return null;+ }+ String trimmed = cpu.trim().toUpperCase();+ try {+ if (trimmed.endsWith("VCPU")) {+ return (int) Math.round(+ Double.parseDouble(trimmed.substring(0, trimmed.length() - 4).trim()) * 1024);+ }+ return Integer.parseInt(trimmed);+ } catch (NumberFormatException e) {+ LOG.debugv("Ignoring unparseable task cpu {0}", cpu);+ return null;+ }+ }++ /**+ * Holds a container's start until the containers it declared a {@code dependsOn} on have+ * reached the state it asked for. {@code START} is satisfied by the launch order alone;+ * {@code COMPLETE} and {@code SUCCESS} wait for the dependency to exit (and {@code SUCCESS}+ * additionally requires it to have exited cleanly); {@code HEALTHY} waits for its health check+ * to pass.+ *+ * <p>The wait is bounded by the dependent container's {@code startTimeout}, defaulting to+ * {@value #DEPENDENCY_WAIT_SECONDS} seconds rather than AWS's longer agent default, because+ * RunTask here is synchronous and a caller is holding the request open. A dependency that does+ * not get there in time fails the task.+ */+ private void awaitDependencies(ContainerDefinition definition, Map<String, String> startedContainerIds) {+ if (definition.getDependsOn() == null || definition.getDependsOn().isEmpty()) {+ return;+ }+ long timeoutSeconds = definition.getStartTimeout() != null+ ? definition.getStartTimeout() : DEPENDENCY_WAIT_SECONDS;+ for (ContainerDependency dependency : definition.getDependsOn()) {+ String condition = dependency.condition();+ if (ContainerDependency.START.equals(condition)) {+ continue;+ }+ String dockerId = startedContainerIds.get(dependency.containerName());+ if (dockerId == null) {+ continue;+ }+ long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(timeoutSeconds);+ while (!dependencySatisfied(dockerId, condition)) {+ if (System.nanoTime() > deadline) {+ throw new AwsException("ClientException",+ "Container '" + definition.getName() + "' did not start because container '"+ + dependency.containerName() + "' did not reach " + condition+ + " within " + timeoutSeconds + " seconds.", 400);+ }+ try {+ TimeUnit.MILLISECONDS.sleep(DEPENDENCY_POLL_MILLIS);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("Interrupted while waiting for ECS container dependency "+ + dependency.containerName(), e);+ }+ }+ }+ }++ private boolean dependencySatisfied(String dockerId, String condition) {+ if (ContainerDependency.HEALTHY.equals(condition)) {+ return "healthy".equals(inspectHealthStatus(dockerId));+ }+ Integer exitCode = getExitCodeIfStopped(dockerId);+ if (exitCode == null) {+ return false;+ }+ if (ContainerDependency.SUCCESS.equals(condition) && exitCode != 0) {+ throw new AwsException("ClientException",+ "A dependency container exited with code " + exitCode+ + ", so the containers depending on its SUCCESS were not started.", 400);+ }+ return true;+ }++ /**+ * A container's health in ECS's vocabulary: {@code HEALTHY} or {@code UNHEALTHY} once its+ * health check has reported, {@code UNKNOWN} while it is still starting or when the container+ * declares no health check at all.+ */+ public String ecsHealthStatus(String dockerId) {+ String status = inspectHealthStatus(dockerId);+ if (status == null) {+ return "UNKNOWN";+ }+ return switch (status) {+ case "healthy" -> "HEALTHY";+ case "unhealthy" -> "UNHEALTHY";+ default -> "UNKNOWN";+ };+ }++ /** The Docker health status of a container, or null when it declares no health check. */+ private String inspectHealthStatus(String dockerId) {+ try {+ InspectContainerResponse inspect = lifecycleManager.getDockerClient()+ .inspectContainerCmd(dockerId).exec();+ return inspect.getState() != null && inspect.getState().getHealth() != null+ ? inspect.getState().getHealth().getStatus() : null;+ } catch (Exception e) {+ LOG.debugv("Could not read the health of container {0}: {1}", dockerId, e.getMessage());+ return null;+ }}private List<ContainerDefinition> orderForDependencies(List<ContainerDefinition> definitions,@@ -463,11 +648,121 @@ public class EcsContainerManager {addAfterDependencies(source, definitionsByName, firelensRouter, visiting, visited, ordered);}}+ if (definition.getDependsOn() != null) {+ for (ContainerDependency dependency : definition.getDependsOn()) {+ ContainerDefinition source = definitionsByName.get(dependency.containerName());+ if (source == null) {+ throw new IllegalArgumentException("ECS dependsOn references unknown container "+ + dependency.containerName());+ }+ addAfterDependencies(source, definitionsByName, firelensRouter, visiting, visited, ordered);+ }+ }visiting.remove(definition);visited.add(definition);ordered.add(definition);}+ /**+ * Gives an {@code awsvpc} task the elastic network interface AWS gives it: its own ENI in the+ * requested subnet, with a private address of its own and the task's security groups.+ *+ * <p>Called for every {@code awsvpc} task, in Docker and in mock mode alike, because the ENI is+ * control-plane state that DescribeTasks reports (a client waits on+ * {@code attachments[].details[?name=='privateIPv4Address']} to find the task) rather than a+ * property of the containers. Security-group enforcement, which additionally puts the task's+ * containers in a protected network namespace, stays opt-in on top of it.+ *+ * <p>A subnet or security group that does not exist fails the task, reported as the+ * {@code InvalidParameterException} RunTask declares rather than the EC2 code+ * {@link Ec2Service#createNetworkInterface} raises.+ */+ public void attachTaskNetwork(EcsTask task, TaskDefinition definition, String region) {+ if (definition.getNetworkMode() != NetworkMode.awsvpc || ec2Service == null) {+ return;+ }+ AwsVpcConfiguration awsvpc = task.getNetworkConfiguration() == null ? null+ : task.getNetworkConfiguration().getAwsvpcConfiguration();+ if (awsvpc == null || awsvpc.getSubnets() == null || awsvpc.getSubnets().isEmpty()) {+ throw new AwsException("InvalidParameterException",+ "Network Configuration must be provided when networkMode 'awsvpc' is specified.", 400);+ }+ String subnetId = awsvpc.getSubnets().getFirst();+ NetworkInterface eni;+ try {+ eni = ec2Service.createNetworkInterface(region, subnetId,+ "ECS task " + task.getTaskArn(), null, List.of(), awsvpc.getSecurityGroups(), List.of());+ } catch (AwsException e) {+ throw asEcsNetworkRejection(e);+ }+ // A running task holds its interface, so EC2 must report it "in-use" rather than+ // "available" as a fresh one starts out, and must refuse to delete it under the task.+ ec2Service.holdNetworkInterfaceForService(region, eni.getNetworkInterfaceId());+ task.setNetworkInterfaceId(eni.getNetworkInterfaceId());+ task.setPrivateIpAddress(eni.getPrivateIpAddress());+ task.setMacAddress(eni.getMacAddress());+ task.setPrivateDnsName(eni.getPrivateDnsName());+ task.setAttachmentId("eni-attach-" + eni.getNetworkInterfaceId());+ ec2Service.describeSubnets(region, List.of(subnetId), Map.of()).stream()+ .findFirst()+ .ifPresent(subnet -> task.setAvailabilityZone(subnet.getAvailabilityZone()));+ }++ /**+ * Restates an EC2 lookup failure as the error RunTask declares. A caller naming a subnet or a+ * security group that is not there asked for something the task cannot have, and+ * {@code InvalidSubnetID.NotFound} is not in RunTask's error list, so an SDK sees it as an+ * unmodelled failure rather than the InvalidParameterException AWS returns. Anything else the+ * ENI path raises is already an ECS-shaped error and travels unchanged.+ */+ private static AwsException asEcsNetworkRejection(AwsException e) {+ if (!EC2_NETWORK_LOOKUP_FAILURES.contains(e.getErrorCode())) {+ return e;+ }+ return new AwsException("InvalidParameterException", e.getMessage(), 400);+ }++ /**+ * Releases a stopped task's ENI. The interface id stays on the task, with its attachment+ * reported as {@code DELETED}, because AWS keeps describing a stopped task's attachment.+ * Idempotent: the status is flipped first, so a second teardown path does nothing.+ */+ public void releaseTaskNetwork(EcsTask task, String region) {+ String eniId = task.getNetworkInterfaceId();+ if (eniId == null || ec2Service == null || ATTACHMENT_DELETED.equals(task.getAttachmentStatus())) {+ return;+ }+ task.setAttachmentStatus(ATTACHMENT_DELETED);+ if (firewallManager != null) {+ firewallManager.unregister(eniId);+ }+ try {+ // EC2 refuses to delete an interface that is in use, and attachTaskNetwork marked+ // this one as held by the task, so the hold goes before the interface does.+ ec2Service.releaseNetworkInterfaceFromService(region, eniId);+ ec2Service.deleteNetworkInterface(region, eniId);+ } catch (RuntimeException e) {+ LOG.debugv("Could not delete the ENI {0} of task {1}: {2}",+ eniId, task.getTaskArn(), e.getMessage());+ }+ }++ /** The ENI {@link #attachTaskNetwork} allocated for this task, or null if it is already gone. */+ private NetworkInterface existingTaskEni(EcsTask task, String region) {+ if (task.getNetworkInterfaceId() == null) {+ return null;+ }+ try {+ return ec2Service.describeNetworkInterfaces(region, List.of(task.getNetworkInterfaceId()),+ Map.of(), 0, null)+ .networkInterfaces().stream().findFirst().orElse(null);+ } catch (RuntimeException e) {+ LOG.debugv("Could not resolve the ENI {0} of task {1}, allocating a new one: {2}",+ task.getNetworkInterfaceId(), task.getTaskArn(), e.getMessage());+ return null;+ }+ }+private PreparedNetwork prepareNetwork(EcsTask task, TaskDefinition definition, String region, String taskId) {if (definition.getNetworkMode() != NetworkMode.awsvpc|| firewallManager == null || !firewallManager.enabled()) {@@ -478,8 +773,13 @@ public class EcsContainerManager {if (awsvpc == null || awsvpc.getSubnets() == null || awsvpc.getSubnets().isEmpty()) {throw new AwsException("ClientException", "awsvpc tasks require a subnet", 400);}- NetworkInterface eni = ec2Service.createNetworkInterface(region, awsvpc.getSubnets().getFirst(),- "ECS task " + task.getTaskArn(), null, List.of(), awsvpc.getSecurityGroups(), List.of());+ // attachTaskNetwork already allocated the task ENI; the namespace is built around it.+ NetworkInterface eni = existingTaskEni(task, region);+ if (eni == null) {+ eni = ec2Service.createNetworkInterface(region, awsvpc.getSubnets().getFirst(),+ "ECS task " + task.getTaskArn(), null, List.of(), awsvpc.getSecurityGroups(), List.of());+ ec2Service.holdNetworkInterfaceForService(region, eni.getNetworkInterfaceId());+ }String eniId = eni.getNetworkInterfaceId();SecurityGroupFirewallManager.Namespace namespace = null;try {@@ -514,6 +814,7 @@ public class EcsContainerManager {if (namespace != null) {lifecycleManager.removeIfExists(namespace.helperId());}+ ec2Service.releaseNetworkInterfaceFromService(region, eniId);ec2Service.deleteNetworkInterface(region, eniId);throw e;}@@ -576,17 +877,21 @@ public class EcsContainerManager {return exitCodes;}- // Phase 1: stop all containers (no-op for those already exited).+ // Phase 1: stop all containers (no-op for those already exited), each given the grace+ // period its container definition asked for.Set<String> terminatedContainerIds = new HashSet<>();- for (String dockerId : handle.getContainerIds().values()) {+ for (Map.Entry<String, String> entry : handle.getContainerIds().entrySet()) {+ String dockerId = entry.getValue();try {- lifecycleManager.getDockerClient().stopContainerCmd(dockerId).withTimeout(5).exec();+ lifecycleManager.getDockerClient().stopContainerCmd(dockerId)+ .withTimeout(handle.stopTimeoutFor(entry.getKey())).exec();terminatedContainerIds.add(dockerId);} catch (NotFoundException ignored) {terminatedContainerIds.add(dockerId);} catch (Exception e) {LOG.warnv("Error stopping ECS container {0}: {1}", dockerId, e.getMessage());}+ killIfStillRunning(dockerId);}// Phase 2: inspect exit codes, then remove.@@ -611,6 +916,37 @@ public class EcsContainerManager {return exitCodes;}+ /**+ * Makes sure a container really is stopped before its exit code is read.+ *+ * <p>A container that ignores SIGTERM only dies when its {@code stopTimeout} elapses, and the+ * Docker client can give up on the stop request before the daemon gets there. Either way the+ * container would still be running when the exit code is collected, and the task would report+ * no exit code at all, so it is killed here.+ */+ private void killIfStillRunning(String dockerId) {+ if (getExitCodeIfStopped(dockerId) != null) {+ return;+ }+ try {+ lifecycleManager.getDockerClient().killContainerCmd(dockerId).exec();+ } catch (NotFoundException ignored) {+ return; // already gone, and its exit code is whatever the earlier inspect saw+ } catch (Exception e) {+ LOG.warnv("Error killing ECS container {0}: {1}", dockerId, e.getMessage());+ return;+ }+ long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(KILL_SETTLE_SECONDS);+ while (System.nanoTime() < deadline && getExitCodeIfStopped(dockerId) == null) {+ try {+ TimeUnit.MILLISECONDS.sleep(DEPENDENCY_POLL_MILLIS);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ return;+ }+ }+ }+private void removeFirelensVolume(EcsTaskHandle handle) {if (handle == null || handle.getFirelensVolumeName() == null) {return;@@ -856,10 +1192,14 @@ public class EcsContainerManager {}return "127.0.0.1";}+ /**+ * Tears down the firewall registration of a protected task. The ENI itself outlives this:+ * it belongs to the task, not to its containers, and {@link #releaseTaskNetwork} frees it when+ * the task reaches STOPPED.+ */private void cleanupProtectedNetwork(EcsTaskHandle handle) {if (firewallManager != null && handle.getNetworkInterfaceId() != null) {firewallManager.unregister(handle.getNetworkInterfaceId());- ec2Service.deleteNetworkInterface(handle.getRegion(), handle.getNetworkInterfaceId());}}@@ -1108,6 +1448,17 @@ public class EcsContainerManager {container.setLastStatus("RUNNING");container.setNetworkBindings(networkBindings);container.setDockerId(dockerId);+ container.setRuntimeId(dockerId);+ container.setHealthStatus(def.getHealthCheck() != null ? "UNKNOWN" : null);+ if (def.getCpu() != null) {+ container.setCpu(String.valueOf(def.getCpu()));+ }+ if (def.getMemory() != null) {+ container.setMemory(String.valueOf(def.getMemory()));+ }+ if (def.getMemoryReservation() != null) {+ container.setMemoryReservation(String.valueOf(def.getMemoryReservation()));+ }container.setContainerArn(regionResolver.buildArn("ecs", region,"container/" + extractTaskId(taskArn) + "/" + def.getName()));return container;diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskHandle.java b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskHandle.javaindex e1db6786c8..deb19ccd0f 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskHandle.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskHandle.java@@ -10,12 +10,24 @@ import java.util.Map;*/public class EcsTaskHandle {+ /**+ * The grace period a container gets when its definition does not ask for one.+ *+ * <p>ECS defaults to 30 seconds. Floci answers StopTask synchronously, and a container that+ * ignores SIGTERM (anything running as PID 1 without a signal handler, which is most of them)+ * would hold the caller for the whole period, so the implicit default stays short. A+ * {@code stopTimeout} the task definition asks for is honoured as given.+ */+ public static final int DEFAULT_STOP_TIMEOUT_SECONDS = 5;+private final String taskArn;private final Map<String, String> containerIds; // containerName → dockerIdprivate final Map<String, Closeable> logStreamsByContainerId;private final String firelensVolumeName;private final String networkInterfaceId;private final String region;+ /** Per-container {@code stopTimeout}, so teardown waits as long as the task definition asked. */+ private final Map<String, Integer> stopTimeouts;public EcsTaskHandle(String taskArn, Map<String, String> containerIds,Map<String, Closeable> logStreamsByContainerId) {@@ -25,12 +37,21 @@ public class EcsTaskHandle {public EcsTaskHandle(String taskArn, Map<String, String> containerIds,Map<String, Closeable> logStreamsByContainerId,String firelensVolumeName, String networkInterfaceId, String region) {+ this(taskArn, containerIds, logStreamsByContainerId, firelensVolumeName,+ networkInterfaceId, region, Map.of());+ }++ public EcsTaskHandle(String taskArn, Map<String, String> containerIds,+ Map<String, Closeable> logStreamsByContainerId,+ String firelensVolumeName, String networkInterfaceId, String region,+ Map<String, Integer> stopTimeouts) {this.taskArn = taskArn;this.containerIds = new LinkedHashMap<>(containerIds);this.logStreamsByContainerId = new LinkedHashMap<>(logStreamsByContainerId);this.firelensVolumeName = firelensVolumeName;this.networkInterfaceId = networkInterfaceId;this.region = region;+ this.stopTimeouts = new LinkedHashMap<>(stopTimeouts);}public String getTaskArn() { return taskArn; }@@ -40,6 +61,12 @@ public class EcsTaskHandle {public String getNetworkInterfaceId() { return networkInterfaceId; }public String getRegion() { return region; }+ /** The container's {@code stopTimeout} in seconds, or {@link #DEFAULT_STOP_TIMEOUT_SECONDS}. */+ public int stopTimeoutFor(String containerName) {+ Integer configured = stopTimeouts.get(containerName);+ return configured != null ? configured : DEFAULT_STOP_TIMEOUT_SECONDS;+ }+/** Removes and returns the log stream that no longer needs task-level ownership. */public Closeable removeLogStream(String containerId) {return logStreamsByContainerId.remove(containerId);diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/CapacityProviderStrategyItem.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/CapacityProviderStrategyItem.javanew file mode 100644index 0000000000..210e7eb9b6--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/CapacityProviderStrategyItem.java@@ -0,0 +1,19 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * One entry of a {@code capacityProviderStrategy}:+ * {@code {"capacityProvider": "FARGATE_SPOT", "weight": 1, "base": 0}}.+ *+ * <p>{@code base} is the number of tasks placed on the provider before any weighting applies, and+ * at most one entry of a strategy may set it. {@code weight} is that provider's share of whatever+ * is left.+ */+@RegisterForReflection+public record CapacityProviderStrategyItem(String capacityProvider, int weight, int base) {++ public CapacityProviderStrategyItem(String capacityProvider) {+ this(capacityProvider, 0, 0);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/Container.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Container.javaindex 5a14e047bd..1a2e3ce270 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/Container.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Container.java@@ -15,6 +15,14 @@ public class Container {private Integer exitCode;private String reason;private List<NetworkBinding> networkBindings;+ private List<TaskNetworkInterface> networkInterfaces;+ private List<ManagedAgent> managedAgents;+ private String healthStatus;+ private String runtimeId;+ private String imageDigest;+ private String cpu;+ private String memory;+ private String memoryReservation;// transient — not persistedprivate transient String dockerId;@@ -43,6 +51,32 @@ public class Container {public List<NetworkBinding> getNetworkBindings() { return networkBindings; }public void setNetworkBindings(List<NetworkBinding> networkBindings) { this.networkBindings = networkBindings; }+ public List<TaskNetworkInterface> getNetworkInterfaces() { return networkInterfaces; }+ public void setNetworkInterfaces(List<TaskNetworkInterface> networkInterfaces) {+ this.networkInterfaces = networkInterfaces;+ }++ public List<ManagedAgent> getManagedAgents() { return managedAgents; }+ public void setManagedAgents(List<ManagedAgent> managedAgents) { this.managedAgents = managedAgents; }++ public String getHealthStatus() { return healthStatus; }+ public void setHealthStatus(String healthStatus) { this.healthStatus = healthStatus; }++ public String getRuntimeId() { return runtimeId; }+ public void setRuntimeId(String runtimeId) { this.runtimeId = runtimeId; }++ public String getImageDigest() { return imageDigest; }+ public void setImageDigest(String imageDigest) { this.imageDigest = imageDigest; }++ public String getCpu() { return cpu; }+ public void setCpu(String cpu) { this.cpu = cpu; }++ public String getMemory() { return memory; }+ public void setMemory(String memory) { this.memory = memory; }++ public String getMemoryReservation() { return memoryReservation; }+ public void setMemoryReservation(String memoryReservation) { this.memoryReservation = memoryReservation; }+public String getDockerId() { return dockerId; }public void setDockerId(String dockerId) { this.dockerId = dockerId; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerDefinition.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerDefinition.javaindex 3b30f13cb5..f5dca15de9 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerDefinition.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerDefinition.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.ecs.model;import io.quarkus.runtime.annotations.RegisterForReflection;import java.util.List;+import java.util.Map;@RegisterForReflectionpublic class ContainerDefinition {@@ -15,14 +16,33 @@ public class ContainerDefinition {private boolean essential = true;private List<PortMapping> portMappings;private List<KeyValuePair> environment;+ private List<EnvironmentFile> environmentFiles;private List<Secret> secrets;private List<String> command;private List<String> entryPoint;private List<MountPoint> mountPoints;private List<VolumeFrom> volumesFrom;+ private List<ContainerDependency> dependsOn;private LogConfiguration logConfiguration;private FirelensConfiguration firelensConfiguration;private HealthCheck healthCheck;+ private Integer startTimeout;+ private Integer stopTimeout;+ private String user;+ private String workingDirectory;+ private String hostname;+ private Boolean readonlyRootFilesystem;+ private Boolean privileged;+ private Boolean disableNetworking;+ private Boolean interactive;+ private Boolean pseudoTerminal;+ private List<String> links;+ private List<String> dnsServers;+ private List<String> dnsSearchDomains;+ private List<String> dockerSecurityOptions;+ private Map<String, String> dockerLabels;+ private String repositoryCredentialsParameter;+ private Map<String, Object> unparsed;public String getName() { return name; }public void setName(String name) { this.name = name; }@@ -72,4 +92,69 @@ public class ContainerDefinition {}public HealthCheck getHealthCheck() { return healthCheck; }public void setHealthCheck(HealthCheck healthCheck) { this.healthCheck = healthCheck; }++ public List<EnvironmentFile> getEnvironmentFiles() { return environmentFiles; }+ public void setEnvironmentFiles(List<EnvironmentFile> environmentFiles) {+ this.environmentFiles = environmentFiles;+ }++ public List<ContainerDependency> getDependsOn() { return dependsOn; }+ public void setDependsOn(List<ContainerDependency> dependsOn) { this.dependsOn = dependsOn; }++ public Integer getStartTimeout() { return startTimeout; }+ public void setStartTimeout(Integer startTimeout) { this.startTimeout = startTimeout; }++ public Integer getStopTimeout() { return stopTimeout; }+ public void setStopTimeout(Integer stopTimeout) { this.stopTimeout = stopTimeout; }++ public String getUser() { return user; }+ public void setUser(String user) { this.user = user; }++ public String getWorkingDirectory() { return workingDirectory; }+ public void setWorkingDirectory(String workingDirectory) { this.workingDirectory = workingDirectory; }++ public String getHostname() { return hostname; }+ public void setHostname(String hostname) { this.hostname = hostname; }++ public Boolean getReadonlyRootFilesystem() { return readonlyRootFilesystem; }+ public void setReadonlyRootFilesystem(Boolean readonlyRootFilesystem) {+ this.readonlyRootFilesystem = readonlyRootFilesystem;+ }++ public Boolean getPrivileged() { return privileged; }+ public void setPrivileged(Boolean privileged) { this.privileged = privileged; }++ public Boolean getDisableNetworking() { return disableNetworking; }+ public void setDisableNetworking(Boolean disableNetworking) { this.disableNetworking = disableNetworking; }++ public Boolean getInteractive() { return interactive; }+ public void setInteractive(Boolean interactive) { this.interactive = interactive; }++ public Boolean getPseudoTerminal() { return pseudoTerminal; }+ public void setPseudoTerminal(Boolean pseudoTerminal) { this.pseudoTerminal = pseudoTerminal; }++ public List<String> getLinks() { return links; }+ public void setLinks(List<String> links) { this.links = links; }++ public List<String> getDnsServers() { return dnsServers; }+ public void setDnsServers(List<String> dnsServers) { this.dnsServers = dnsServers; }++ public List<String> getDnsSearchDomains() { return dnsSearchDomains; }+ public void setDnsSearchDomains(List<String> dnsSearchDomains) { this.dnsSearchDomains = dnsSearchDomains; }++ public List<String> getDockerSecurityOptions() { return dockerSecurityOptions; }+ public void setDockerSecurityOptions(List<String> dockerSecurityOptions) {+ this.dockerSecurityOptions = dockerSecurityOptions;+ }++ public Map<String, String> getDockerLabels() { return dockerLabels; }+ public void setDockerLabels(Map<String, String> dockerLabels) { this.dockerLabels = dockerLabels; }++ public String getRepositoryCredentialsParameter() { return repositoryCredentialsParameter; }+ public void setRepositoryCredentialsParameter(String repositoryCredentialsParameter) {+ this.repositoryCredentialsParameter = repositoryCredentialsParameter;+ }++ public Map<String, Object> getUnparsed() { return unparsed; }+ public void setUnparsed(Map<String, Object> unparsed) { this.unparsed = unparsed; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerDependency.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerDependency.javanew file mode 100644index 0000000000..049d2f08a2--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerDependency.java@@ -0,0 +1,18 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * A {@code dependsOn} entry of an ECS container definition:+ * {@code {"containerName": ..., "condition": "START"|"COMPLETE"|"SUCCESS"|"HEALTHY"}}.+ *+ * <p>The condition decides how far the named container must get before the dependent one starts.+ */+@RegisterForReflection+public record ContainerDependency(String containerName, String condition) {++ public static final String START = "START";+ public static final String COMPLETE = "COMPLETE";+ public static final String SUCCESS = "SUCCESS";+ public static final String HEALTHY = "HEALTHY";+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerOverride.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerOverride.javaindex e6aaec5958..529b88b856 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerOverride.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerOverride.java@@ -16,6 +16,10 @@ public class ContainerOverride {private String name;private List<String> command;private List<KeyValuePair> environment;+ private List<EnvironmentFile> environmentFiles;+ private Integer cpu;+ private Integer memory;+ private Integer memoryReservation;public String getName() { return name; }public void setName(String name) { this.name = name; }@@ -25,4 +29,18 @@ public class ContainerOverride {public List<KeyValuePair> getEnvironment() { return environment; }public void setEnvironment(List<KeyValuePair> environment) { this.environment = environment; }++ public List<EnvironmentFile> getEnvironmentFiles() { return environmentFiles; }+ public void setEnvironmentFiles(List<EnvironmentFile> environmentFiles) {+ this.environmentFiles = environmentFiles;+ }++ public Integer getCpu() { return cpu; }+ public void setCpu(Integer cpu) { this.cpu = cpu; }++ public Integer getMemory() { return memory; }+ public void setMemory(Integer memory) { this.memory = memory; }++ public Integer getMemoryReservation() { return memoryReservation; }+ public void setMemoryReservation(Integer memoryReservation) { this.memoryReservation = memoryReservation; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/CreateClusterRequest.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/CreateClusterRequest.javaindex 758bae3acb..5d0b44efee 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/CreateClusterRequest.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/CreateClusterRequest.java@@ -12,6 +12,8 @@ public class CreateClusterRequest {private String clusterName;private Map<String, String> tags;private List<ClusterSetting> settings;+ private List<String> capacityProviders;+ private List<Map<String, Object>> defaultCapacityProviderStrategy;public String getClusterName() { return clusterName; }public void setClusterName(String clusterName) { this.clusterName = clusterName; }@@ -21,4 +23,15 @@ public class CreateClusterRequest {public List<ClusterSetting> getSettings() { return settings; }public void setSettings(List<ClusterSetting> settings) { this.settings = settings; }++ public List<String> getCapacityProviders() { return capacityProviders; }+ public void setCapacityProviders(List<String> capacityProviders) { this.capacityProviders = capacityProviders; }++ public List<Map<String, Object>> getDefaultCapacityProviderStrategy() {+ return defaultCapacityProviderStrategy;+ }++ public void setDefaultCapacityProviderStrategy(List<Map<String, Object>> strategy) {+ this.defaultCapacityProviderStrategy = strategy;+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/CreateServiceRequest.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/CreateServiceRequest.javaindex b164f83c92..a1d9a8753e 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/CreateServiceRequest.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/CreateServiceRequest.java@@ -14,6 +14,7 @@ public class CreateServiceRequest {private String taskDefinition;private int desiredCount = 1;private LaunchType launchType;+ private List<CapacityProviderStrategyItem> capacityProviderStrategy;private List<EcsLoadBalancer> loadBalancers;private NetworkConfiguration networkConfiguration;private Map<String, String> tags;@@ -37,6 +38,11 @@ public class CreateServiceRequest {public LaunchType getLaunchType() { return launchType; }public void setLaunchType(LaunchType launchType) { this.launchType = launchType; }+ public List<CapacityProviderStrategyItem> getCapacityProviderStrategy() { return capacityProviderStrategy; }+ public void setCapacityProviderStrategy(List<CapacityProviderStrategyItem> capacityProviderStrategy) {+ this.capacityProviderStrategy = capacityProviderStrategy;+ }+public List<EcsLoadBalancer> getLoadBalancers() { return loadBalancers; }public void setLoadBalancers(List<EcsLoadBalancer> loadBalancers) { this.loadBalancers = loadBalancers; }@@ -65,4 +71,5 @@ public class CreateServiceRequest {public void setServiceConnectConfiguration(Map<String, Object> serviceConnectConfiguration) {this.serviceConnectConfiguration = serviceConnectConfiguration;}+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsLoadBalancer.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsLoadBalancer.javaindex afa023baa6..b25febe7d0 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsLoadBalancer.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsLoadBalancer.java@@ -2,6 +2,8 @@ package io.github.hectorvent.floci.services.ecs.model;import io.quarkus.runtime.annotations.RegisterForReflection;+import java.util.Map;+/*** A load balancer association on an ECS service ({@code CreateService}'s* {@code loadBalancers} block). Links a container port on the service's tasks@@ -14,9 +16,16 @@ public class EcsLoadBalancer {private String loadBalancerName;private String containerName;private Integer containerPort;+ /** {@code advancedConfiguration}, kept raw: Floci runs no blue/green traffic shifting. */+ private Map<String, Object> advancedConfiguration;public EcsLoadBalancer() {}+ public Map<String, Object> getAdvancedConfiguration() { return advancedConfiguration; }+ public void setAdvancedConfiguration(Map<String, Object> advancedConfiguration) {+ this.advancedConfiguration = advancedConfiguration;+ }+public String getTargetGroupArn() { return targetGroupArn; }public void setTargetGroupArn(String targetGroupArn) { this.targetGroupArn = targetGroupArn; }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 448bd057b1..a04c05a71f 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@@ -40,6 +40,7 @@ public class EcsServiceModel {* it; the Service shape itself has no member for it.*/private Map<String, Object> serviceConnectConfiguration;+ private List<CapacityProviderStrategyItem> capacityProviderStrategy;public String getServiceArn() { return serviceArn; }public void setServiceArn(String serviceArn) { this.serviceArn = serviceArn; }@@ -112,4 +113,10 @@ public class EcsServiceModel {public void setServiceConnectConfiguration(Map<String, Object> serviceConnectConfiguration) {this.serviceConnectConfiguration = serviceConnectConfiguration;}++ public List<CapacityProviderStrategyItem> getCapacityProviderStrategy() { return capacityProviderStrategy; }+ public void setCapacityProviderStrategy(List<CapacityProviderStrategyItem> capacityProviderStrategy) {+ this.capacityProviderStrategy = capacityProviderStrategy;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsTask.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsTask.javaindex ffdd541925..c5422330e1 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsTask.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsTask.java@@ -41,6 +41,30 @@ public class EcsTask {private NetworkConfiguration networkConfiguration;private String networkInterfaceId;private String privateIpAddress;+ private String macAddress;+ private String privateDnsName;+ private String attachmentId;+ /** {@code ATTACHED} while the task holds its ENI, {@code DELETED} once it has been released. */+ private String attachmentStatus = "ATTACHED";+ private String platformVersion;+ private String platformFamily;+ /** Set instead of {@link #launchType} when the task was placed through a capacity provider. */+ private String capacityProviderName;+ private String connectivity;+ private Instant connectivityAt;+ private String healthStatus;+ private String stopCode;+ private String availabilityZone;+ private Instant pullStartedAt;+ private Instant pullStoppedAt;+ private Instant executionStoppedAt;+ private Instant stoppingAt;+ private EphemeralStorage ephemeralStorage;+ private boolean enableExecuteCommand;+ private TaskOverride overrides;+ private List<Attribute> attributes;+ /** Bumped on every state change, the way AWS advances a task's optimistic-locking version. */+ private long version = 1;public EcsTask() {}@@ -76,6 +100,27 @@ public class EcsTask {this.networkConfiguration = other.networkConfiguration;this.networkInterfaceId = other.networkInterfaceId;this.privateIpAddress = other.privateIpAddress;+ this.macAddress = other.macAddress;+ this.privateDnsName = other.privateDnsName;+ this.attachmentId = other.attachmentId;+ this.attachmentStatus = other.attachmentStatus;+ this.platformVersion = other.platformVersion;+ this.platformFamily = other.platformFamily;+ this.capacityProviderName = other.capacityProviderName;+ this.connectivity = other.connectivity;+ this.connectivityAt = other.connectivityAt;+ this.healthStatus = other.healthStatus;+ this.stopCode = other.stopCode;+ this.availabilityZone = other.availabilityZone;+ this.pullStartedAt = other.pullStartedAt;+ this.pullStoppedAt = other.pullStoppedAt;+ this.executionStoppedAt = other.executionStoppedAt;+ this.stoppingAt = other.stoppingAt;+ this.ephemeralStorage = other.ephemeralStorage;+ this.enableExecuteCommand = other.enableExecuteCommand;+ this.overrides = other.overrides;+ this.attributes = other.attributes;+ this.version = other.version;}public String getTaskArn() { return taskArn; }@@ -136,6 +181,12 @@ public class EcsTask {public String getPrivateIpAddress() { return privateIpAddress; }public void setPrivateIpAddress(String privateIpAddress) { this.privateIpAddress = privateIpAddress; }+ public String getMacAddress() { return macAddress; }+ public void setMacAddress(String macAddress) { this.macAddress = macAddress; }++ public String getPrivateDnsName() { return privateDnsName; }+ public void setPrivateDnsName(String privateDnsName) { this.privateDnsName = privateDnsName; }+public String getStoppedReason() { return stoppedReason; }public void setStoppedReason(String stoppedReason) { this.stoppedReason = stoppedReason; }@@ -153,4 +204,69 @@ public class EcsTask {public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags; }++ public String getAttachmentId() { return attachmentId; }+ public void setAttachmentId(String attachmentId) { this.attachmentId = attachmentId; }++ public String getAttachmentStatus() { return attachmentStatus; }+ public void setAttachmentStatus(String attachmentStatus) { this.attachmentStatus = attachmentStatus; }++ public String getPlatformVersion() { return platformVersion; }+ public void setPlatformVersion(String platformVersion) { this.platformVersion = platformVersion; }++ public String getPlatformFamily() { return platformFamily; }+ public void setPlatformFamily(String platformFamily) { this.platformFamily = platformFamily; }++ public String getCapacityProviderName() { return capacityProviderName; }+ public void setCapacityProviderName(String capacityProviderName) {+ this.capacityProviderName = capacityProviderName;+ }++ public String getConnectivity() { return connectivity; }+ public void setConnectivity(String connectivity) { this.connectivity = connectivity; }++ public Instant getConnectivityAt() { return connectivityAt; }+ public void setConnectivityAt(Instant connectivityAt) { this.connectivityAt = connectivityAt; }++ public String getHealthStatus() { return healthStatus; }+ public void setHealthStatus(String healthStatus) { this.healthStatus = healthStatus; }++ public String getStopCode() { return stopCode; }+ public void setStopCode(String stopCode) { this.stopCode = stopCode; }++ public String getAvailabilityZone() { return availabilityZone; }+ public void setAvailabilityZone(String availabilityZone) { this.availabilityZone = availabilityZone; }++ public Instant getPullStartedAt() { return pullStartedAt; }+ public void setPullStartedAt(Instant pullStartedAt) { this.pullStartedAt = pullStartedAt; }++ public Instant getPullStoppedAt() { return pullStoppedAt; }+ public void setPullStoppedAt(Instant pullStoppedAt) { this.pullStoppedAt = pullStoppedAt; }++ public Instant getExecutionStoppedAt() { return executionStoppedAt; }+ public void setExecutionStoppedAt(Instant executionStoppedAt) { this.executionStoppedAt = executionStoppedAt; }++ /** When the task left RUNNING for STOPPING, which AWS reports alongside {@code stoppedAt}. */+ public Instant getStoppingAt() { return stoppingAt; }+ public void setStoppingAt(Instant stoppingAt) { this.stoppingAt = stoppingAt; }++ public EphemeralStorage getEphemeralStorage() { return ephemeralStorage; }+ public void setEphemeralStorage(EphemeralStorage ephemeralStorage) { this.ephemeralStorage = ephemeralStorage; }++ public boolean isEnableExecuteCommand() { return enableExecuteCommand; }+ public void setEnableExecuteCommand(boolean enableExecuteCommand) {+ this.enableExecuteCommand = enableExecuteCommand;+ }++ public TaskOverride getOverrides() { return overrides; }+ public void setOverrides(TaskOverride overrides) { this.overrides = overrides; }++ public List<Attribute> getAttributes() { return attributes; }+ public void setAttributes(List<Attribute> attributes) { this.attributes = attributes; }++ public long getVersion() { return version; }+ public void setVersion(long version) { this.version = version; }++ /** Advances the version AWS bumps on every task state transition. */+ public void bumpVersion() { this.version++; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EnvironmentFile.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EnvironmentFile.javanew file mode 100644index 0000000000..baa0eb0894--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EnvironmentFile.java@@ -0,0 +1,11 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * An {@code environmentFiles} entry of an ECS container definition:+ * {@code {"value": "<s3 object arn>", "type": "s3"}}.+ */+@RegisterForReflection+public record EnvironmentFile(String value, String type) {+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EphemeralStorage.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EphemeralStorage.javanew file mode 100644index 0000000000..d577bef7bd--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EphemeralStorage.java@@ -0,0 +1,17 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * The {@code ephemeralStorage} of a Fargate task definition or a RunTask override:+ * {@code {"sizeInGiB": 21}}.+ *+ * <p>Floci reports the requested size but does not cap the container's writable layer at it.+ */+@RegisterForReflection+public record EphemeralStorage(int sizeInGiB) {++ /** The storage a Fargate task gets without asking, and the floor for an explicit request. */+ public static final int DEFAULT_SIZE_IN_GIB = 20;+ public static final int MAX_SIZE_IN_GIB = 200;+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/LaunchType.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/LaunchType.javaindex f6a78b80fb..c8e1984ece 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/LaunchType.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/LaunchType.java@@ -4,5 +4,5 @@ import io.quarkus.runtime.annotations.RegisterForReflection;@RegisterForReflectionpublic enum LaunchType {- EC2, FARGATE, EXTERNAL+ EC2, FARGATE, EXTERNAL, MANAGED_INSTANCES}\ No newline at end of filediff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ManagedAgent.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ManagedAgent.javanew file mode 100644index 0000000000..7b7c551b31--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ManagedAgent.java@@ -0,0 +1,24 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++/**+ * A {@code managedAgents} entry of a described container:+ * {@code {"name": "ExecuteCommandAgent", "lastStatus": "RUNNING", "lastStartedAt": ...}}.+ *+ * <p>ECS Exec is gated on this agent reporting {@code RUNNING}, which is what+ * {@code aws ecs execute-command} and the {@code TasksRunning} waiter read.+ */+@RegisterForReflection+public record ManagedAgent(String name, String lastStatus, String reason, Instant lastStartedAt) {++ public static final String EXECUTE_COMMAND_AGENT = "ExecuteCommandAgent";+ public static final String RUNNING = "RUNNING";+ public static final String STOPPED = "STOPPED";++ public static ManagedAgent executeCommandAgent(Instant startedAt) {+ return new ManagedAgent(EXECUTE_COMMAND_AGENT, RUNNING, null, startedAt);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/PortMapping.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/PortMapping.javaindex 7b3eb2863c..b87dca800f 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/PortMapping.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/PortMapping.java@@ -2,10 +2,22 @@ package io.github.hectorvent.floci.services.ecs.model;import io.quarkus.runtime.annotations.RegisterForReflection;+/**+ * A container's port mapping.+ *+ * <p>{@code name} and {@code appProtocol} carry no behaviour here, but they are what a service's+ * {@code serviceConnectConfiguration} and {@code vpcLatticeConfigurations} reference by name, so a+ * definition registered for Service Connect has to read back with them intact.+ */@RegisterForReflection-public record PortMapping(int containerPort, int hostPort, String protocol) {+public record PortMapping(int containerPort, int hostPort, String protocol, String name,+ String appProtocol, String containerPortRange) {public PortMapping(int containerPort) {this(containerPort, 0, "tcp");}++ public PortMapping(int containerPort, int hostPort, String protocol) {+ this(containerPort, hostPort, protocol, null, null, null);+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/RegisterTaskDefinitionRequest.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/RegisterTaskDefinitionRequest.javaindex 96bf12bf17..14a6bddec5 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/RegisterTaskDefinitionRequest.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/RegisterTaskDefinitionRequest.java@@ -26,7 +26,12 @@ public class RegisterTaskDefinitionRequest {private List<String> requiresCompatibilities;private List<Volume> volumes;private RuntimePlatform runtimePlatform;+ private EphemeralStorage ephemeralStorage;+ private String pidMode;+ private String ipcMode;private Map<String, String> tags;+ /** Members Floci does not act on, such as proxyConfiguration and placementConstraints. */+ private Map<String, Object> unparsed;public String getFamily() { return family; }public void setFamily(String family) { this.family = family; }@@ -62,9 +67,23 @@ public class RegisterTaskDefinitionRequest {public RuntimePlatform getRuntimePlatform() { return runtimePlatform; }public void setRuntimePlatform(RuntimePlatform runtimePlatform) { this.runtimePlatform = runtimePlatform; }+ public EphemeralStorage getEphemeralStorage() { return ephemeralStorage; }+ public void setEphemeralStorage(EphemeralStorage ephemeralStorage) {+ this.ephemeralStorage = ephemeralStorage;+ }++ public String getPidMode() { return pidMode; }+ public void setPidMode(String pidMode) { this.pidMode = pidMode; }++ public String getIpcMode() { return ipcMode; }+ public void setIpcMode(String ipcMode) { this.ipcMode = ipcMode; }+public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags; }+ public Map<String, Object> getUnparsed() { return unparsed; }+ public void setUnparsed(Map<String, Object> unparsed) { this.unparsed = unparsed; }+public boolean isFargate() {return requiresCompatibilities != null && requiresCompatibilities.contains("FARGATE");}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/RunTaskRequest.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/RunTaskRequest.javaindex 631f195c50..f02f931fea 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/RunTaskRequest.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/RunTaskRequest.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.ecs.model;import io.quarkus.runtime.annotations.RegisterForReflection;import java.util.List;+import java.util.Map;/*** A parsed {@code RunTask} (or {@code StartTask}) request.@@ -19,10 +20,17 @@ public class RunTaskRequest {private String taskDefinition;private int count = 1;private LaunchType launchType;+ private List<CapacityProviderStrategyItem> capacityProviderStrategy;private String group;private String startedBy;- private List<ContainerOverride> containerOverrides;+ private TaskOverride overrides;private NetworkConfiguration networkConfiguration;+ private String platformVersion;+ private boolean enableExecuteCommand;+ private boolean enableECSManagedTags;+ private String propagateTags;+ private String referenceId;+ private Map<String, String> tags;private List<String> containerInstances;public String getCluster() { return cluster; }@@ -37,15 +45,22 @@ public class RunTaskRequest {public LaunchType getLaunchType() { return launchType; }public void setLaunchType(LaunchType launchType) { this.launchType = launchType; }+ public List<CapacityProviderStrategyItem> getCapacityProviderStrategy() { return capacityProviderStrategy; }+ public void setCapacityProviderStrategy(List<CapacityProviderStrategyItem> capacityProviderStrategy) {+ this.capacityProviderStrategy = capacityProviderStrategy;+ }+public String getGroup() { return group; }public void setGroup(String group) { this.group = group; }public String getStartedBy() { return startedBy; }public void setStartedBy(String startedBy) { this.startedBy = startedBy; }- public List<ContainerOverride> getContainerOverrides() { return containerOverrides; }- public void setContainerOverrides(List<ContainerOverride> containerOverrides) {- this.containerOverrides = containerOverrides;+ public TaskOverride getOverrides() { return overrides; }+ public void setOverrides(TaskOverride overrides) { this.overrides = overrides; }++ public List<ContainerOverride> getContainerOverrides() {+ return overrides == null ? null : overrides.getContainerOverrides();}public NetworkConfiguration getNetworkConfiguration() { return networkConfiguration; }@@ -53,6 +68,28 @@ public class RunTaskRequest {this.networkConfiguration = networkConfiguration;}+ public String getPlatformVersion() { return platformVersion; }+ public void setPlatformVersion(String platformVersion) { this.platformVersion = platformVersion; }++ public boolean isEnableExecuteCommand() { return enableExecuteCommand; }+ public void setEnableExecuteCommand(boolean enableExecuteCommand) {+ this.enableExecuteCommand = enableExecuteCommand;+ }++ public boolean isEnableECSManagedTags() { return enableECSManagedTags; }+ public void setEnableECSManagedTags(boolean enableECSManagedTags) {+ this.enableECSManagedTags = enableECSManagedTags;+ }++ public String getPropagateTags() { return propagateTags; }+ public void setPropagateTags(String propagateTags) { this.propagateTags = propagateTags; }++ public String getReferenceId() { return referenceId; }+ public void setReferenceId(String referenceId) { this.referenceId = referenceId; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+public List<String> getContainerInstances() { return containerInstances; }public void setContainerInstances(List<String> containerInstances) {this.containerInstances = containerInstances;diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskDefinition.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskDefinition.javaindex 3b3e9ae625..0ad3055d21 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskDefinition.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskDefinition.java@@ -1,7 +1,9 @@package io.github.hectorvent.floci.services.ecs.model;+import com.fasterxml.jackson.annotation.JsonIgnore;import io.quarkus.runtime.annotations.RegisterForReflection;+import java.time.Instant;import java.util.HashMap;import java.util.List;import java.util.Map;@@ -23,7 +25,18 @@ public class TaskDefinition {private RuntimePlatform runtimePlatform;private List<String> requiresCompatibilities;private List<String> compatibilities;+ /** The container instance capabilities the definition needs, derived at registration. */+ private List<Attribute> requiresAttributes;+ private EphemeralStorage ephemeralStorage;+ private String pidMode;+ private String ipcMode;+ private Instant registeredAt;+ private String registeredBy;+ private Instant deregisteredAt;+ private Instant deleteRequestedAt;private Map<String, String> tags = new HashMap<>();+ /** Members Floci does not act on, kept verbatim so DescribeTaskDefinition round-trips. */+ private Map<String, Object> unparsed;public String getTaskDefinitionArn() { return taskDefinitionArn; }public void setTaskDefinitionArn(String taskDefinitionArn) { this.taskDefinitionArn = taskDefinitionArn; }@@ -66,9 +79,43 @@ public class TaskDefinition {public List<String> getRequiresCompatibilities() { return requiresCompatibilities; }public void setRequiresCompatibilities(List<String> requiresCompatibilities) { this.requiresCompatibilities = requiresCompatibilities; }+ public List<Attribute> getRequiresAttributes() { return requiresAttributes; }+ public void setRequiresAttributes(List<Attribute> requiresAttributes) { this.requiresAttributes = requiresAttributes; }+public List<String> getCompatibilities() { return compatibilities; }public void setCompatibilities(List<String> compatibilities) { this.compatibilities = compatibilities; }+ public EphemeralStorage getEphemeralStorage() { return ephemeralStorage; }+ public void setEphemeralStorage(EphemeralStorage ephemeralStorage) { this.ephemeralStorage = ephemeralStorage; }++ public String getPidMode() { return pidMode; }+ public void setPidMode(String pidMode) { this.pidMode = pidMode; }++ public String getIpcMode() { return ipcMode; }+ public void setIpcMode(String ipcMode) { this.ipcMode = ipcMode; }++ public Instant getRegisteredAt() { return registeredAt; }+ public void setRegisteredAt(Instant registeredAt) { this.registeredAt = registeredAt; }++ public String getRegisteredBy() { return registeredBy; }+ public void setRegisteredBy(String registeredBy) { this.registeredBy = registeredBy; }++ public Instant getDeregisteredAt() { return deregisteredAt; }+ public void setDeregisteredAt(Instant deregisteredAt) { this.deregisteredAt = deregisteredAt; }++ /** When deletion was asked for, which is when the revision entered DELETE_IN_PROGRESS. */+ public Instant getDeleteRequestedAt() { return deleteRequestedAt; }+ public void setDeleteRequestedAt(Instant deleteRequestedAt) { this.deleteRequestedAt = deleteRequestedAt; }+public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags; }++ public Map<String, Object> getUnparsed() { return unparsed; }+ public void setUnparsed(Map<String, Object> unparsed) { this.unparsed = unparsed; }++ /** Whether the definition declares Fargate compatibility, which gates the Fargate-only rules. */+ @JsonIgnore+ public boolean isFargateCompatible() {+ return requiresCompatibilities != null && requiresCompatibilities.contains("FARGATE");+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskNetworkInterface.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskNetworkInterface.javanew file mode 100644index 0000000000..d428c60654--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskNetworkInterface.java@@ -0,0 +1,14 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * A {@code networkInterfaces} entry of a described container:+ * {@code {"attachmentId": ..., "privateIpv4Address": ...}}.+ *+ * <p>An {@code awsvpc} task reports the same interface on each of its containers, since they+ * share the task ENI.+ */+@RegisterForReflection+public record TaskNetworkInterface(String attachmentId, String privateIpv4Address, String ipv6Address) {+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskOverride.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskOverride.javanew file mode 100644index 0000000000..8e1ab5bebc--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskOverride.java@@ -0,0 +1,53 @@+package io.github.hectorvent.floci.services.ecs.model;++import com.fasterxml.jackson.annotation.JsonIgnore;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++/**+ * The {@code overrides} of a RunTask or StartTask request, echoed back on the task.+ *+ * <p>The task-level members replace the task definition's own {@code cpu}, {@code memory},+ * roles and {@code ephemeralStorage} for this task only; {@code containerOverrides} carries the+ * per-container half.+ */+@RegisterForReflection+public class TaskOverride {++ private List<ContainerOverride> containerOverrides;+ private String cpu;+ private String memory;+ private String taskRoleArn;+ private String executionRoleArn;+ private EphemeralStorage ephemeralStorage;++ public List<ContainerOverride> getContainerOverrides() { return containerOverrides; }+ public void setContainerOverrides(List<ContainerOverride> containerOverrides) {+ this.containerOverrides = containerOverrides;+ }++ public String getCpu() { return cpu; }+ public void setCpu(String cpu) { this.cpu = cpu; }++ public String getMemory() { return memory; }+ public void setMemory(String memory) { this.memory = memory; }++ public String getTaskRoleArn() { return taskRoleArn; }+ public void setTaskRoleArn(String taskRoleArn) { this.taskRoleArn = taskRoleArn; }++ public String getExecutionRoleArn() { return executionRoleArn; }+ public void setExecutionRoleArn(String executionRoleArn) { this.executionRoleArn = executionRoleArn; }++ public EphemeralStorage getEphemeralStorage() { return ephemeralStorage; }+ public void setEphemeralStorage(EphemeralStorage ephemeralStorage) {+ this.ephemeralStorage = ephemeralStorage;+ }++ @JsonIgnore+ public boolean isEmpty() {+ return (containerOverrides == null || containerOverrides.isEmpty())+ && cpu == null && memory == null && taskRoleArn == null+ && executionRoleArn == null && ephemeralStorage == null;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/UpdateServiceRequest.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/UpdateServiceRequest.javaindex 24c385cb59..0f6202ab49 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/UpdateServiceRequest.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/UpdateServiceRequest.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.ecs.model;import io.quarkus.runtime.annotations.RegisterForReflection;+import java.util.List;import java.util.Map;/**@@ -21,6 +22,7 @@ public class UpdateServiceRequest {private String availabilityZoneRebalancing;private boolean forceNewDeployment;private Map<String, Object> serviceConnectConfiguration;+ private List<CapacityProviderStrategyItem> capacityProviderStrategy;public String getCluster() { return cluster; }public void setCluster(String cluster) { this.cluster = cluster; }@@ -51,4 +53,10 @@ public class UpdateServiceRequest {public void setServiceConnectConfiguration(Map<String, Object> serviceConnectConfiguration) {this.serviceConnectConfiguration = serviceConnectConfiguration;}++ public List<CapacityProviderStrategyItem> getCapacityProviderStrategy() { return capacityProviderStrategy; }+ public void setCapacityProviderStrategy(List<CapacityProviderStrategyItem> capacityProviderStrategy) {+ this.capacityProviderStrategy = capacityProviderStrategy;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/Volume.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Volume.javaindex 9b56a49bef..601dc7ca9e 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/Volume.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Volume.java@@ -2,22 +2,35 @@ package io.github.hectorvent.floci.services.ecs.model;import io.quarkus.runtime.annotations.RegisterForReflection;+import java.util.Map;+/*** A task-level volume in an ECS task definition. Two shapes are modelled:* <ul>- * <li>EC2-launch-type {@code host} volume — {@code {"name": ..., "host": {"sourcePath": ...}}};+ * <li>EC2-launch-type {@code host} volume: {@code {"name": ..., "host": {"sourcePath": ...}}};* {@code hostSourcePath} is the absolute path on the Docker host that the volume binds to.</li>- * <li>{@code efsVolumeConfiguration} volume — {@code {"name": ..., "efsVolumeConfiguration": {...}}};+ * <li>{@code efsVolumeConfiguration} volume: {@code {"name": ..., "efsVolumeConfiguration": {...}}};* see {@link EfsVolumeConfiguration}.</li>* </ul>* The two are mutually exclusive. A container references the volume by {@code name} via a* {@link MountPoint}.+ *+ * <p>{@code unparsed} keeps the volume members Floci backs with nothing, which is the rest of+ * AWS's {@code Volume} shape: {@code dockerVolumeConfiguration},+ * {@code fsxWindowsFileServerVolumeConfiguration}, {@code s3filesVolumeConfiguration} and+ * {@code configuredAtLaunch}. They have to survive the round trip or a client that registered one+ * reads the definition back without it and proposes the same change forever.*/@RegisterForReflection-public record Volume(String name, String hostSourcePath, EfsVolumeConfiguration efs) {+public record Volume(String name, String hostSourcePath, EfsVolumeConfiguration efs,+ Map<String, Object> unparsed) {/** Convenience constructor for a {@code host} volume (no EFS configuration). */public Volume(String name, String hostSourcePath) {- this(name, hostSourcePath, null);+ this(name, hostSourcePath, null, null);+ }++ public Volume(String name, String hostSourcePath, EfsVolumeConfiguration efs) {+ this(name, hostSourcePath, efs, null);}}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsDeleteAfterRestoreIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsDeleteAfterRestoreIntegrationTest.javaindex 5f56a8a193..efdb2015ba 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsDeleteAfterRestoreIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsDeleteAfterRestoreIntegrationTest.java@@ -41,7 +41,8 @@ class CloudFormationEcsDeleteAfterRestoreIntegrationTest {// it through the ECS API so ECS no longer has the record the stack still references. These// run unauthenticated, like CreateStack/DeleteStack, so they share the same account namespace.ecs("DeregisterTaskDefinition", "{\"taskDefinition\":\"" + family + "\"}");- ecs("DeleteTaskDefinitions", "{\"taskDefinitions\":[\"" + family + "\"]}");+ // DeleteTaskDefinitions takes a revision, never a bare family.+ ecs("DeleteTaskDefinitions", "{\"taskDefinitions\":[\"" + family + ":1\"]}");deleteStack(stack);@@ -62,7 +63,9 @@ class CloudFormationEcsDeleteAfterRestoreIntegrationTest {// The cluster still has a running task at delete time (a genuine ClusterContainsTasksException),// which must NOT be treated as already-gone. ECS runs in mock mode under test, so the task is// in-memory RUNNING with no container behind it.- ecs("RunTask", "{\"cluster\":\"" + cluster + "\",\"taskDefinition\":\"" + family + "\",\"count\":1}");+ ecs("RunTask", "{\"cluster\":\"" + cluster + "\",\"taskDefinition\":\"" + family + "\",\"count\":1,"+ + "\"networkConfiguration\":{\"awsvpcConfiguration\":"+ + "{\"subnets\":[\"subnet-default-us-east-1-a\"]}}}");deleteStack(stack);diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.javaindex ef4354e7b7..bcbd75fff7 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java@@ -491,6 +491,84 @@ class Ec2ServiceTest {assertEquals(1, retry.getInstances().size());}+ /**+ * An interface a service holds on the caller's behalf, an ECS task's ENI being the one this+ * emulator allocates, is {@code in-use}: DescribeNetworkInterfaces documents an unattached+ * interface as {@code available} and an attached one as {@code in-use}, so left+ * {@code available} it would answer a caller looking for a free interface. No attachment is+ * synthesised, every member AWS documents on one naming an instance the task does not have,+ * and the read-time reconciliation that frees an interface whose instance died therefore has+ * nothing to act on here.+ */+ @Test+ void aServiceHeldInterfaceStaysInUseUntilItIsReleased() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ String subnetId = service.describeSubnets("us-east-1", List.of(), Map.of())+ .getFirst().getSubnetId();+ NetworkInterface eni = service.createNetworkInterface("us-east-1", subnetId, null,+ null, List.of(), List.of(), List.of());+ String eniId = eni.getNetworkInterfaceId();+ assertEquals("available", eni.getStatus());++ service.holdNetworkInterfaceForService("us-east-1", eniId);++ assertEquals("in-use", readInterface(service, eniId).getStatus());+ assertNull(readInterface(service, eniId).getAttachment());+ assertTrue(service.describeNetworkInterfaces("us-east-1", List.of(),+ Map.of("status", List.of("available")), 0, null)+ .networkInterfaces().stream()+ .noneMatch(n -> eniId.equals(n.getNetworkInterfaceId())));++ // AWS does not let the account delete an interface a task holds, so a teardown has to+ // release it first.+ AwsException inUse = assertThrows(AwsException.class,+ () -> service.deleteNetworkInterface("us-east-1", eniId));+ assertEquals("InvalidParameterValue", inUse.getErrorCode());++ service.releaseNetworkInterfaceFromService("us-east-1", eniId);++ assertEquals("available", readInterface(service, eniId).getStatus());+ assertDoesNotThrow(() -> service.deleteNetworkInterface("us-east-1", eniId));+ // Releasing an interface that is already gone is a no-op, so a second teardown is harmless.+ assertDoesNotThrow(() -> service.releaseNetworkInterfaceFromService("us-east-1", eniId));+ }++ /**+ * The service hold must not reach an interface an instance owns: releasing one of those is+ * DetachNetworkInterface's job, and it has an instance-side copy to clear as well.+ */+ @Test+ void aServiceHoldLeavesAnInstanceHeldInterfaceAlone() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ String subnetId = service.describeSubnets("us-east-1", List.of(), Map.of())+ .getFirst().getSubnetId();+ NetworkInterface eni = service.createNetworkInterface("us-east-1", subnetId, null,+ null, List.of(), List.of(), List.of());+ Reservation reservation = service.runInstances("us-east-1", "ami-1234567890abcdef0", "t3.micro",+ 1, 1, null, List.of(), null, null, List.of(), null, null, null,+ eni.getNetworkInterfaceId(), 0);+ String instanceId = reservation.getInstances().getFirst().getInstanceId();++ AwsException held = assertThrows(AwsException.class,+ () -> service.holdNetworkInterfaceForService("us-east-1", eni.getNetworkInterfaceId()));+ assertEquals("InvalidNetworkInterface.InUse", held.getErrorCode());++ service.releaseNetworkInterfaceFromService("us-east-1", eni.getNetworkInterfaceId());++ NetworkInterface after = readInterface(service, eni.getNetworkInterfaceId());+ assertEquals("in-use", after.getStatus());+ assertEquals(instanceId, after.getAttachment().getInstanceId());+ }++ private static NetworkInterface readInterface(Ec2Service service, String networkInterfaceId) {+ return service.describeNetworkInterfaces("us-east-1", List.of(networkInterfaceId), Map.of(), 0, null)+ .networkInterfaces().getFirst();+ }+/*** A NetworkInterface can carry a real GroupIdentifier entry whose groupId is null (a name-only* association). The group-id filter must skip that entry instead of NPE-ing ondiff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateEdgeCaseIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateEdgeCaseIntegrationTest.javanew file mode 100644index 0000000000..f466162fa9--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateEdgeCaseIntegrationTest.java@@ -0,0 +1,609 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasItems;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.nullValue;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * The edges of the Fargate rules: the boundary values of the documented ranges, the parameters+ * that are only invalid in combination, and the limits AWS puts on a single call.+ */+@QuarkusTest+class EcsFargateEdgeCaseIntegrationTest {++ private static final String TARGET = "AmazonEC2ContainerServiceV20141113.";+ private static final String CT = "application/x-amz-json-1.1";+ private static final String CLUSTER = "fargate-edge-cluster";+ private static final String NETWORK =+ "\"networkConfiguration\":{\"awsvpcConfiguration\":{\"subnets\":"+ + "[\"subnet-default-us-east-1-a\"]}}";++ @BeforeAll+ static void configure() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ private static Response call(String action, String body, int expectedStatus) {+ return given().contentType(CT).header("X-Amz-Target", TARGET + action)+ .body(body)+ .when().post("/")+ .then().statusCode(expectedStatus)+ .extract().response();+ }++ private static void registerSize(String family, String cpu, String memory, int expectedStatus) {+ call("RegisterTaskDefinition", "{\"family\":\"" + family + "\","+ + "\"requiresCompatibilities\":[\"FARGATE\"],\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"" + cpu + "\",\"memory\":\"" + memory + "\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}",+ expectedStatus);+ }++ private static String seed(String family) {+ call("CreateCluster", "{\"clusterName\":\"" + CLUSTER + "\"}", 200);+ registerSize(family, "256", "512", 200);+ return family;+ }++ // ── Task size ─────────────────────────────────────────────────────────────++ @Test+ void theEdgesOfEveryFargateSizeRangeAreAccepted() {+ registerSize("edge-256-low", "256", "512", 200);+ registerSize("edge-256-high", "256", "2048", 200);+ registerSize("edge-512-low", "512", "1024", 200);+ registerSize("edge-512-high", "512", "4096", 200);+ registerSize("edge-2048-low", "2048", "4096", 200);+ registerSize("edge-2048-high", "2048", "16384", 200);+ registerSize("edge-4096-high", "4096", "30720", 200);+ registerSize("edge-8192-low", "8192", "16384", 200);+ registerSize("edge-16384-high", "16384", "122880", 200);+ }++ @Test+ void justOutsideEveryFargateSizeRangeIsRejected() {+ registerSize("edge-256-below", "256", "256", 400);+ registerSize("edge-256-above", "256", "3072", 400);+ registerSize("edge-512-below", "512", "512", 400);+ registerSize("edge-512-above", "512", "5120", 400);+ registerSize("edge-4096-above", "4096", "31744", 400);+ registerSize("edge-16384-above", "16384", "131072", 400);+ registerSize("edge-unknown-cpu", "384", "1024", 400);+ }++ @Test+ void theThirtyTwoVcpuSizesAreTheThreeFargateOffers() {+ registerSize("edge-32vcpu-60", "32768", "61440", 200);+ registerSize("edge-32vcpu-120", "32768", "122880", 200);+ registerSize("edge-32vcpu-244", "32768", "249856", 200);+ // 32 vCPU is not a range: anything between the three offers is not a configuration.+ registerSize("edge-32vcpu-between", "32768", "65536", 400);+ }++ @Test+ void theStringFormsOfCpuAndMemoryAreAccepted() {+ registerSize("edge-vcpu-string", "0.5 vCPU", "1 GB", 200);+ registerSize("edge-vcpu-lowercase", "1 vcpu", "2GB", 200);+ }++ // ── Ephemeral storage ─────────────────────────────────────────────────────++ @Test+ void ephemeralStorageIsAcceptedAtBothEndsOfItsRange() {+ String body = "{\"family\":\"edge-storage-%s\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"256\",\"memory\":\"512\","+ + "\"ephemeralStorage\":{\"sizeInGiB\":%d},"+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}";++ call("RegisterTaskDefinition", body.formatted("min", 21), 200);+ call("RegisterTaskDefinition", body.formatted("max", 200), 200);+ call("RegisterTaskDefinition", body.formatted("below", 20), 400);+ call("RegisterTaskDefinition", body.formatted("above", 201), 400);+ }++ // ── Parameters Fargate does not support ───────────────────────────────────++ @Test+ void everyFargateUnsupportedParameterIsRejected() {+ String container = "{\"family\":\"edge-unsupported-%s\","+ + "\"requiresCompatibilities\":[\"FARGATE\"],\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\",\"containerDefinitions\":"+ + "[{\"name\":\"app\",\"image\":\"nginx:latest\",%s}]}";++ call("RegisterTaskDefinition",+ container.formatted("dso", "\"dockerSecurityOptions\":[\"label:user:jdoe\"]"), 400)+ .then().body("message", containsString("dockerSecurityOptions"));+ call("RegisterTaskDefinition",+ container.formatted("hosts", "\"extraHosts\":[{\"hostname\":\"db\",\"ipAddress\":\"10.0.0.9\"}]"), 400)+ .then().body("message", containsString("extraHosts"));+ call("RegisterTaskDefinition",+ container.formatted("gpu", "\"resourceRequirements\":[{\"type\":\"GPU\",\"value\":\"1\"}]"), 400)+ .then().body("message", containsString("gpu"));+ call("RegisterTaskDefinition",+ container.formatted("swap", "\"linuxParameters\":{\"maxSwap\":128}"), 400)+ .then().body("message", containsString("maxSwap"));+ call("RegisterTaskDefinition",+ container.formatted("swappiness", "\"linuxParameters\":{\"swappiness\":10}"), 400)+ .then().body("message", containsString("swappiness"));++ call("RegisterTaskDefinition", "{\"family\":\"edge-unsupported-placement\","+ + "\"requiresCompatibilities\":[\"FARGATE\"],\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\","+ + "\"placementConstraints\":[{\"type\":\"memberOf\",\"expression\":\"attribute:ecs.os-type==linux\"}],"+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 400)+ .then().body("message", containsString("placementConstraints"));+ }++ @Test+ void pidModeTaskIsTheOnlyOneFargateAccepts() {+ String body = "{\"family\":\"edge-pidmode-%s\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"256\",\"memory\":\"512\",\"pidMode\":\"%s\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}";++ call("RegisterTaskDefinition", body.formatted("task", "task"), 200);+ call("RegisterTaskDefinition", body.formatted("host", "host"), 400)+ .then().body("message", containsString("pidMode"));+ }++ @Test+ void aDependencyCycleIsRejectedAtRegistration() {+ call("RegisterTaskDefinition", "{\"family\":\"edge-cycle\","+ + "\"requiresCompatibilities\":[\"FARGATE\"],\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\",\"containerDefinitions\":["+ + "{\"name\":\"a\",\"image\":\"busybox\","+ + "\"dependsOn\":[{\"containerName\":\"b\",\"condition\":\"START\"}]},"+ + "{\"name\":\"b\",\"image\":\"busybox\","+ + "\"dependsOn\":[{\"containerName\":\"a\",\"condition\":\"START\"}]}]}", 400)+ .then().body("message", containsString("cycle"));+ }++ // ── RunTask limits ────────────────────────────────────────────────────────++ @Test+ void runTaskPlacesAtMostTenTasksPerCall() {+ String family = seed("edge-count");++ Response ten = call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\""+ + family + "\",\"count\":10,\"launchType\":\"FARGATE\"," + NETWORK + "}", 200);+ ten.then().body("tasks", hasSize(10));++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"count\":11,\"launchType\":\"FARGATE\"," + NETWORK + "}", 400)+ .then().body("message", containsString("between 1 and 10"));+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"count\":0,\"launchType\":\"FARGATE\"," + NETWORK + "}", 400);++ ten.jsonPath().getList("tasks.taskArn", String.class).forEach(taskArn ->+ call("StopTask", "{\"cluster\":\"" + CLUSTER + "\",\"task\":\"" + taskArn + "\"}", 200));+ }++ @Test+ void propagatingServiceTagsIsRefusedForAStandaloneTask() {+ String family = seed("edge-propagate");++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"FARGATE\"," + NETWORK + ",\"propagateTags\":\"SERVICE\"}", 400)+ .then().body("message", containsString("SERVICE"));+ }++ @Test+ void propagatingTaskDefinitionTagsCopiesThemOntoTheTask() {+ call("CreateCluster", "{\"clusterName\":\"" + CLUSTER + "\"}", 200);+ call("RegisterTaskDefinition", "{\"family\":\"edge-td-tags\","+ + "\"requiresCompatibilities\":[\"FARGATE\"],\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\",\"tags\":[{\"key\":\"owner\",\"value\":\"platform\"}],"+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 200);++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"edge-td-tags\","+ + "\"launchType\":\"FARGATE\"," + NETWORK + ",\"propagateTags\":\"TASK_DEFINITION\"}", 200)+ .then()+ .body("tasks[0].tags[0].key", equalTo("owner"))+ .body("tasks[0].tags[0].value", equalTo("platform"));+ }++ /**+ * The ENI allocation reaches into EC2, whose not-found codes RunTask does not declare. An SDK+ * given {@code InvalidSubnetID.NotFound} sees an unmodelled failure instead of the+ * InvalidParameterException AWS returns for a subnet that is not there.+ */+ @Test+ void runTaskRejectsAnUnknownSubnetAsAnInvalidParameter() {+ String family = seed("edge-unknown-subnet");++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"FARGATE\",\"networkConfiguration\":{\"awsvpcConfiguration\":"+ + "{\"subnets\":[\"subnet-does-not-exist\"]}}}", 400)+ .then()+ .body("__type", containsString("InvalidParameterException"))+ .body("message", containsString("subnet-does-not-exist"));+ }++ @Test+ void runTaskRejectsAnUnknownSecurityGroupAsAnInvalidParameter() {+ String family = seed("edge-unknown-sg");++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"FARGATE\",\"networkConfiguration\":{\"awsvpcConfiguration\":"+ + "{\"subnets\":[\"subnet-default-us-east-1-a\"],\"securityGroups\":[\"sg-nope\"]}}}", 400)+ .then()+ .body("__type", containsString("InvalidParameterException"))+ .body("message", containsString("sg-nope"));+ }++ /**+ * MANAGED_INSTANCES joined LaunchType and Compatibility in the ECS model. Rejecting it would+ * 400 a request the SDK considers valid.+ */+ @Test+ void managedInstancesIsAcceptedAsACompatibilityAndALaunchType() {+ call("CreateCluster", "{\"clusterName\":\"" + CLUSTER + "\"}", 200);+ call("RegisterTaskDefinition", "{\"family\":\"edge-managed-instances\","+ + "\"requiresCompatibilities\":[\"EC2\",\"MANAGED_INSTANCES\"],"+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\","+ + "\"memory\":512}]}", 200)+ .then().body("taskDefinition.requiresCompatibilities", hasItems("MANAGED_INSTANCES"));++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"edge-managed-instances\","+ + "\"launchType\":\"MANAGED_INSTANCES\"}", 200)+ .then().body("tasks[0].launchType", equalTo("MANAGED_INSTANCES"));+ }++ // ── Capacity provider strategy ────────────────────────────────────────────++ @Test+ void aStrategyWithTwoBasesIsRejected() {+ String family = seed("edge-two-bases");++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\","+ + NETWORK + ",\"capacityProviderStrategy\":["+ + "{\"capacityProvider\":\"FARGATE\",\"base\":1,\"weight\":1},"+ + "{\"capacityProvider\":\"FARGATE_SPOT\",\"base\":1,\"weight\":1}]}", 400)+ .then().body("message", containsString("base"));+ }++ @Test+ void aLoneProviderOfWeightZeroStillPlacesEveryTask() {+ String family = seed("edge-zero-weight");++ Response response = call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\""+ + family + "\",\"count\":3," + NETWORK + ",\"capacityProviderStrategy\":"+ + "[{\"capacityProvider\":\"FARGATE_SPOT\",\"weight\":0}]}", 200);++ List<String> providers = response.jsonPath().getList("tasks.capacityProviderName");+ assertEquals(3, providers.size(), "a weightless strategy must still place every task");+ assertTrue(providers.stream().allMatch("FARGATE_SPOT"::equals), providers.toString());+ }++ @Test+ void aStrategyWhoseProvidersAllWeighZeroIsRejected() {+ String family = seed("edge-all-zero-weights");++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\","+ + NETWORK + ",\"capacityProviderStrategy\":["+ + "{\"capacityProvider\":\"FARGATE\",\"weight\":0},"+ + "{\"capacityProvider\":\"FARGATE_SPOT\",\"weight\":0}]}", 400)+ .then().body("message", containsString("weight greater than zero"));+ }++ @Test+ void aStrategyEntryOutsideTheWeightAndBaseRangesIsRejected() {+ String family = seed("edge-strategy-ranges");++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\","+ + NETWORK + ",\"capacityProviderStrategy\":"+ + "[{\"capacityProvider\":\"FARGATE\",\"weight\":1001}]}", 400)+ .then().body("message", containsString("between 0 and 1000"));+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\","+ + NETWORK + ",\"capacityProviderStrategy\":"+ + "[{\"capacityProvider\":\"FARGATE\",\"weight\":1,\"base\":100001}]}", 400)+ .then().body("message", containsString("between 0 and 100000"));++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\","+ + NETWORK + ",\"capacityProviderStrategy\":"+ + "[{\"capacityProvider\":\"FARGATE\",\"weight\":1000,\"base\":100000}]}", 200)+ .then().body("tasks[0].capacityProviderName", equalTo("FARGATE"));+ }++ @Test+ void aStrategyOfMoreThanTwentyProvidersIsRejected() {+ String family = seed("edge-strategy-size");+ StringBuilder strategy = new StringBuilder();+ for (int i = 0; i < 21; i++) {+ strategy.append(i == 0 ? "" : ",")+ .append("{\"capacityProvider\":\"FARGATE\",\"weight\":1}");+ }++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\","+ + NETWORK + ",\"capacityProviderStrategy\":[" + strategy + "]}", 400)+ .then().body("message", containsString("maximum of 20 capacity providers"));+ }++ @Test+ void anEmptyStrategyFallsBackToTheLaunchType() {+ String family = seed("edge-empty-strategy");++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"FARGATE\"," + NETWORK + ",\"capacityProviderStrategy\":[]}", 200)+ .then().body("tasks[0].launchType", equalTo("FARGATE"));+ }++ // ── Task shape ────────────────────────────────────────────────────────────++ @Test+ void aStoppedTaskReportsTheTimestampsAndCodesAwsReports() {+ String family = seed("edge-stopped-shape");+ String taskArn = call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\""+ + family + "\",\"launchType\":\"FARGATE\"," + NETWORK + "}", 200)+ .jsonPath().getString("tasks[0].taskArn");++ Response stopped = call("StopTask", "{\"cluster\":\"" + CLUSTER + "\",\"task\":\""+ + taskArn + "\",\"reason\":\"edge\"}", 200);++ stopped.then()+ .body("task.stopCode", equalTo("UserInitiated"))+ .body("task.lastStatus", equalTo("STOPPED"));+ assertTrue(stopped.jsonPath().getDouble("task.stoppingAt") > 0,+ "stoppingAt must be reported for a task that went through STOPPING");+ assertTrue(stopped.jsonPath().getDouble("task.executionStoppedAt") > 0,+ "executionStoppedAt must be reported");+ }++ @Test+ void aFargateTaskReportsBothEphemeralStorageMembersAndZeroCpuContainers() {+ String family = seed("edge-storage-members");++ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"FARGATE\"," + NETWORK + "}", 200)+ .then()+ .body("tasks[0].ephemeralStorage.sizeInGiB", equalTo(20))+ .body("tasks[0].fargateEphemeralStorage.sizeInGiB", equalTo(20))+ // A container definition without cpu units reports zero, not nothing.+ .body("tasks[0].containers[0].cpu", equalTo("0"));+ }++ @Test+ void describeTasksReportsTagsOnlyWhenTheyAreAskedFor() {+ String family = seed("edge-describe-tags");+ String taskArn = call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\""+ + family + "\",\"launchType\":\"FARGATE\"," + NETWORK+ + ",\"tags\":[{\"key\":\"owner\",\"value\":\"platform\"}]}", 200)+ .jsonPath().getString("tasks[0].taskArn");++ call("DescribeTasks", "{\"cluster\":\"" + CLUSTER + "\",\"tasks\":[\"" + taskArn + "\"]}", 200)+ .then().body("tasks[0].tags", nullValue());++ call("DescribeTasks", "{\"cluster\":\"" + CLUSTER + "\",\"tasks\":[\"" + taskArn+ + "\"],\"include\":[\"TAGS\"]}", 200)+ .then().body("tasks[0].tags[0].key", equalTo("owner"));+ }++ @Test+ void aTaskAlwaysReportsAnOverrideEntryPerContainer() {+ call("CreateCluster", "{\"clusterName\":\"" + CLUSTER + "\"}", 200);+ call("RegisterTaskDefinition", "{\"family\":\"edge-overrides\","+ + "\"requiresCompatibilities\":[\"FARGATE\"],\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\",\"containerDefinitions\":["+ + "{\"name\":\"app\",\"image\":\"nginx:latest\"},"+ + "{\"name\":\"sidecar\",\"image\":\"busybox\",\"essential\":false}]}", 200);++ // Nothing was overridden, and AWS still lists every container under overrides.+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"edge-overrides\","+ + "\"launchType\":\"FARGATE\"," + NETWORK + "}", 200)+ .then()+ .body("tasks[0].overrides.containerOverrides", hasSize(2))+ .body("tasks[0].overrides.containerOverrides[0].name", equalTo("app"))+ .body("tasks[0].overrides.containerOverrides[1].name", equalTo("sidecar"));+ }++ @Test+ void anAwsvpcTaskReportsTheAttachmentDetailsAwsReports() {+ String family = seed("edge-attachment-details");+ Response response = call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\""+ + family + "\",\"launchType\":\"FARGATE\"," + NETWORK + "}", 200);++ List<String> names = response.jsonPath().getList("tasks[0].attachments[0].details.name");+ assertTrue(names.containsAll(List.of("subnetId", "networkInterfaceId", "macAddress",+ "privateDnsName", "privateIPv4Address")),+ "the attachment must carry the details AWS reports, got: " + names);+ }++ // ── Service updates ──────────────────────────────────────────────────────++ private static String deploymentId(String serviceName) {+ return call("DescribeServices", "{\"cluster\":\"" + CLUSTER + "\",\"services\":[\""+ + serviceName + "\"]}", 200)+ .jsonPath().getString("services[0].deployments[0].id");+ }++ // ── Task definition lifecycle ─────────────────────────────────────────────++ @Test+ void aDeletedRevisionStaysDescribableAsDeleteInProgress() {+ registerSize("edge-delete-lifecycle", "256", "512", 200);++ // Deleting before deregistering is refused, and a family without a revision is not a+ // reference this API takes.+ call("DeleteTaskDefinitions", "{\"taskDefinitions\":[\"edge-delete-lifecycle:1\"]}", 400)+ .then().body("message", containsString("INACTIVE"));+ call("DeregisterTaskDefinition", "{\"taskDefinition\":\"edge-delete-lifecycle:1\"}", 200)+ .then().body("taskDefinition.status", equalTo("INACTIVE"));+ call("DeleteTaskDefinitions", "{\"taskDefinitions\":[\"edge-delete-lifecycle\"]}", 400)+ .then().body("message", containsString("revision"));++ call("DeleteTaskDefinitions", "{\"taskDefinitions\":[\"edge-delete-lifecycle:1\"]}", 200)+ .then().body("taskDefinitions[0].status", equalTo("DELETE_IN_PROGRESS"));++ // The revision is still describable, and carries the lifecycle timestamps.+ Response described = call("DescribeTaskDefinition",+ "{\"taskDefinition\":\"edge-delete-lifecycle:1\"}", 200);+ described.then().body("taskDefinition.status", equalTo("DELETE_IN_PROGRESS"));+ assertTrue(described.jsonPath().getDouble("taskDefinition.deregisteredAt") > 0,+ "a deregistered revision reports deregisteredAt");+ assertTrue(described.jsonPath().getDouble("taskDefinition.deleteRequestedAt") > 0,+ "a revision being deleted reports deleteRequestedAt");++ // And it can no longer start anything new.+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"edge-delete-lifecycle:1\","+ + "\"launchType\":\"FARGATE\"," + NETWORK + "}", 400)+ .then().body("message", containsString("being deleted"));+ }++ @Test+ void describeTasksReportsAnUnknownTaskAsMissingRatherThanDroppingIt() {+ call("CreateCluster", "{\"clusterName\":\"" + CLUSTER + "\"}", 200);++ call("DescribeTasks", "{\"cluster\":\"" + CLUSTER + "\",\"tasks\":[\"00000000000000000000000000000000\"]}", 200)+ .then()+ .body("tasks", hasSize(0))+ .body("failures", hasSize(1))+ .body("failures[0].reason", equalTo("MISSING"));+ }++ // ── Derived compatibilities and requiresAttributes ────────────────────────++ @Test+ void compatibilitiesAreDerivedFromTheDefinitionNotJustEchoed() {+ // Fargate-valid but never asked for FARGATE: ECS still reports the launch types it works on.+ call("RegisterTaskDefinition", "{\"family\":\"edge-compat-implicit\",\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\",\"containerDefinitions\":"+ + "[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 200)+ .then().body("taskDefinition.compatibilities", equalTo(List.of("EC2", "FARGATE")));++ // awsvpc rules out EXTERNAL; bridge rules out FARGATE and allows EXTERNAL.+ call("RegisterTaskDefinition", "{\"family\":\"edge-compat-bridge\",\"networkMode\":\"bridge\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\",\"memory\":128}]}", 200)+ .then().body("taskDefinition.compatibilities", equalTo(List.of("EC2", "EXTERNAL")));++ // awsvpc without a Fargate size pair is EC2 only.+ call("RegisterTaskDefinition", "{\"family\":\"edge-compat-nosize\",\"networkMode\":\"awsvpc\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\",\"memory\":128}]}", 200)+ .then().body("taskDefinition.compatibilities", equalTo(List.of("EC2")));+ }++ @Test+ void requiresAttributesNamesTheCapabilitiesTheDefinitionUses() {+ call("RegisterTaskDefinition", "{\"family\":\"edge-attrs\",\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\","+ + "\"taskRoleArn\":\"arn:aws:iam::000000000000:role/task\","+ + "\"containerDefinitions\":[{\"name\":\"app\","+ + "\"image\":\"000000000000.dkr.ecr.us-east-1.amazonaws.com/app:1\","+ + "\"logConfiguration\":{\"logDriver\":\"awslogs\",\"options\":{}}}]}", 200)+ .then()+ .body("taskDefinition.requiresAttributes.name", hasItems(+ "com.amazonaws.ecs.capability.docker-remote-api.1.18",+ "ecs.capability.task-eni",+ "com.amazonaws.ecs.capability.task-iam-role",+ "com.amazonaws.ecs.capability.ecr-auth",+ "com.amazonaws.ecs.capability.logging-driver.awslogs"));++ // A task role under host networking has its own capability name.+ call("RegisterTaskDefinition", "{\"family\":\"edge-attrs-host\",\"networkMode\":\"host\","+ + "\"taskRoleArn\":\"arn:aws:iam::000000000000:role/task\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\",\"memory\":128}]}", 200)+ .then()+ .body("taskDefinition.requiresAttributes.name", hasItems(+ "com.amazonaws.ecs.capability.task-iam-role-network-host"))+ .body("taskDefinition.requiresAttributes.name", not(hasItems("ecs.capability.task-eni")));+ }++ @Test+ void startTaskRequiresContainerInstances() {+ String family = seed("edge-start-task");++ call("StartTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\"}", 400)+ .then().body("message", containsString("containerInstances"));+ }++ // ── Capacity providers ───────────────────────────────────────────────────++ // ── Round trips the parser used to drop ──────────────────────────────────++ @Test+ void aPortMappingRoundTripsItsServiceConnectMembers() {+ call("CreateCluster", "{\"clusterName\":\"" + CLUSTER + "\"}", 200);+ call("RegisterTaskDefinition", "{\"family\":\"edge-portmapping\","+ + "\"requiresCompatibilities\":[\"FARGATE\"],\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\","+ + "\"portMappings\":[{\"containerPort\":8080,\"protocol\":\"tcp\","+ + "\"name\":\"api\",\"appProtocol\":\"http\"}]}]}", 200);++ // name and appProtocol are what a service's serviceConnectConfiguration references, so+ // losing them on the round trip breaks Service Connect.+ call("DescribeTaskDefinition", "{\"taskDefinition\":\"edge-portmapping\"}", 200)+ .then()+ .body("taskDefinition.containerDefinitions[0].portMappings[0].name", equalTo("api"))+ .body("taskDefinition.containerDefinitions[0].portMappings[0].appProtocol",+ equalTo("http"))+ .body("taskDefinition.containerDefinitions[0].portMappings[0].containerPort",+ equalTo(8080));+ }++ @Test+ void aVolumeRoundTripsTheConfigurationsFlociDoesNotBack() {+ call("CreateCluster", "{\"clusterName\":\"" + CLUSTER + "\"}", 200);+ call("RegisterTaskDefinition", "{\"family\":\"edge-volume-roundtrip\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}],"+ + "\"volumes\":[{\"name\":\"docker-vol\",\"configuredAtLaunch\":false,"+ + "\"dockerVolumeConfiguration\":{\"scope\":\"shared\",\"autoprovision\":true,"+ + "\"driver\":\"local\"}}]}", 200);++ call("DescribeTaskDefinition", "{\"taskDefinition\":\"edge-volume-roundtrip\"}", 200)+ .then()+ .body("taskDefinition.volumes[0].name", equalTo("docker-vol"))+ .body("taskDefinition.volumes[0].dockerVolumeConfiguration.scope", equalTo("shared"))+ .body("taskDefinition.volumes[0].dockerVolumeConfiguration.driver", equalTo("local"))+ .body("taskDefinition.volumes[0].configuredAtLaunch", equalTo(false));+ }++ // ── Request validation ───────────────────────────────────────────────────++ @Test+ void anEnumValueTheApiDoesNotHaveIsRejectedRatherThanIgnored() {+ String family = seed("edge-bad-enum");++ // Silently treating this as absent would place the task on Floci's default launch type,+ // which is not what the caller asked for.+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"EC22\"," + NETWORK + "}", 400)+ .then().body("message", containsString("launchType"));++ call("RegisterTaskDefinition", "{\"family\":\"edge-bad-network-mode\","+ + "\"networkMode\":\"AWSVPC\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 400)+ .then().body("message", containsString("networkMode"));+ }++ @Test+ void aResourceTakesAtMostFiftyTags() {+ StringBuilder tags = new StringBuilder();+ for (int i = 0; i < 51; i++) {+ tags.append(i > 0 ? "," : "")+ .append("{\"key\":\"k").append(i).append("\",\"value\":\"v\"}");+ }+ call("CreateCluster", "{\"clusterName\":\"edge-too-many-tags\",\"tags\":[" + tags + "]}", 400)+ .then().body("message", containsString("50"));++ call("CreateCluster", "{\"clusterName\":\"edge-empty-tag-key\","+ + "\"tags\":[{\"key\":\"\",\"value\":\"v\"}]}", 400)+ .then().body("message", containsString("Tag keys"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateTaskDefinitionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateTaskDefinitionIntegrationTest.javanew file mode 100644index 0000000000..469970c161--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateTaskDefinitionIntegrationTest.java@@ -0,0 +1,220 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+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.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * RegisterTaskDefinition for the Fargate launch type: the members a Fargate task definition+ * carries must survive a round trip, and the ones Fargate has no equivalent for must be rejected+ * at registration rather than at launch.+ */+@QuarkusTest+class EcsFargateTaskDefinitionIntegrationTest {++ 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, int expectedStatus) {+ return given().contentType(CT).header("X-Amz-Target", TARGET + action)+ .body(body)+ .when().post("/")+ .then().statusCode(expectedStatus)+ .extract().response();+ }++ private static Response register(String body, int expectedStatus) {+ return call("RegisterTaskDefinition", body, expectedStatus);+ }++ /** A Fargate-compatible definition with everything filled in but the named members replaced. */+ private static String fargateTaskDefinition(String family, String extraMembers) {+ return "{\"family\":\"" + family + "\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"256\",\"memory\":\"512\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]"+ + extraMembers + "}";+ }++ @Test+ void registerTaskDefinitionRoundTripsEphemeralStorageAndPidMode() {+ register(fargateTaskDefinition("fargate-ephemeral",+ ",\"ephemeralStorage\":{\"sizeInGiB\":50},\"pidMode\":\"task\""), 200);++ call("DescribeTaskDefinition", "{\"taskDefinition\":\"fargate-ephemeral\"}", 200)+ .then()+ .body("taskDefinition.ephemeralStorage.sizeInGiB", equalTo(50))+ .body("taskDefinition.pidMode", equalTo("task"));+ }++ @Test+ void registerTaskDefinitionRoundTripsMembersFlociDoesNotActOn() {+ // proxyConfiguration and the container's ulimits, linuxParameters and resourceRequirements+ // have no local behaviour, but a client that wrote them reads them back or sees drift.+ register("{\"family\":\"fargate-passthrough\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"512\",\"memory\":\"1024\","+ + "\"proxyConfiguration\":{\"type\":\"APPMESH\",\"containerName\":\"envoy\","+ + "\"properties\":[{\"name\":\"AppPorts\",\"value\":\"8080\"}]},"+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\","+ + "\"ulimits\":[{\"name\":\"nofile\",\"softLimit\":1024,\"hardLimit\":4096}],"+ + "\"linuxParameters\":{\"initProcessEnabled\":true},"+ + "\"systemControls\":[{\"namespace\":\"net.core.somaxconn\",\"value\":\"1024\"}]}]}", 200);++ call("DescribeTaskDefinition", "{\"taskDefinition\":\"fargate-passthrough\"}", 200)+ .then()+ .body("taskDefinition.proxyConfiguration.type", equalTo("APPMESH"))+ .body("taskDefinition.proxyConfiguration.properties[0].name", equalTo("AppPorts"))+ .body("taskDefinition.containerDefinitions[0].ulimits[0].name", equalTo("nofile"))+ .body("taskDefinition.containerDefinitions[0].ulimits[0].softLimit", equalTo(1024))+ .body("taskDefinition.containerDefinitions[0].linuxParameters.initProcessEnabled",+ equalTo(true))+ .body("taskDefinition.containerDefinitions[0].systemControls[0].namespace",+ equalTo("net.core.somaxconn"));+ }++ @Test+ void registerTaskDefinitionRoundTripsTypedContainerMembers() {+ register("{\"family\":\"fargate-container-members\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"256\",\"memory\":\"512\","+ + "\"containerDefinitions\":["+ + "{\"name\":\"init\",\"image\":\"busybox\",\"essential\":false},"+ + "{\"name\":\"app\",\"image\":\"nginx:latest\",\"user\":\"1000:1000\","+ + "\"workingDirectory\":\"/srv\",\"readonlyRootFilesystem\":true,\"stopTimeout\":30,"+ + "\"startTimeout\":120,\"dockerLabels\":{\"team\":\"platform\"},"+ + "\"environmentFiles\":[{\"value\":\"arn:aws:s3:::cfg/app.env\",\"type\":\"s3\"}],"+ + "\"repositoryCredentials\":{\"credentialsParameter\":\"arn:aws:secretsmanager:us-east-1:"+ + "000000000000:secret:registry\"},"+ + "\"dependsOn\":[{\"containerName\":\"init\",\"condition\":\"SUCCESS\"}]}]}", 200);++ call("DescribeTaskDefinition", "{\"taskDefinition\":\"fargate-container-members\"}", 200)+ .then()+ .body("taskDefinition.containerDefinitions[1].user", equalTo("1000:1000"))+ .body("taskDefinition.containerDefinitions[1].workingDirectory", equalTo("/srv"))+ .body("taskDefinition.containerDefinitions[1].readonlyRootFilesystem", equalTo(true))+ .body("taskDefinition.containerDefinitions[1].stopTimeout", equalTo(30))+ .body("taskDefinition.containerDefinitions[1].startTimeout", equalTo(120))+ .body("taskDefinition.containerDefinitions[1].dockerLabels.team", equalTo("platform"))+ .body("taskDefinition.containerDefinitions[1].environmentFiles", hasSize(1))+ .body("taskDefinition.containerDefinitions[1].environmentFiles[0].type", equalTo("s3"))+ .body("taskDefinition.containerDefinitions[1].repositoryCredentials.credentialsParameter",+ containsString("secret:registry"))+ .body("taskDefinition.containerDefinitions[1].dependsOn[0].containerName", equalTo("init"))+ .body("taskDefinition.containerDefinitions[1].dependsOn[0].condition", equalTo("SUCCESS"));+ }++ @Test+ void registerTaskDefinitionReportsRegistrationMetadata() {+ Response response = register(fargateTaskDefinition("fargate-registered-at", ""), 200);+ assertTrue(response.jsonPath().getDouble("taskDefinition.registeredAt") > 0,+ "registeredAt must be reported as an epoch timestamp");+ assertTrue(response.jsonPath().getString("taskDefinition.registeredBy").startsWith("arn:"),+ "registeredBy must be an ARN");+ }++ @Test+ void registerTaskDefinitionRejectsEphemeralStorageOutsideTheFargateRange() {+ register(fargateTaskDefinition("fargate-storage-small", ",\"ephemeralStorage\":{\"sizeInGiB\":10}"), 400)+ .then().body("message", containsString("ephemeral storage"));+ register(fargateTaskDefinition("fargate-storage-large", ",\"ephemeralStorage\":{\"sizeInGiB\":300}"), 400)+ .then().body("message", containsString("ephemeral storage"));+ }++ @Test+ void registerTaskDefinitionRejectsParametersFargateDoesNotSupport() {+ String prefix = "{\"family\":\"fargate-unsupported\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"256\",\"memory\":\"512\",\"containerDefinitions\":"+ + "[{\"name\":\"app\",\"image\":\"nginx:latest\",";++ register(prefix + "\"privileged\":true}]}", 400)+ .then().body("message", containsString("privileged"));+ register(prefix + "\"links\":[\"other\"]}]}", 400)+ .then().body("message", containsString("links"));+ register(prefix + "\"disableNetworking\":true}]}", 400)+ .then().body("message", containsString("disableNetworking"));+ register(prefix + "\"dnsServers\":[\"10.0.0.2\"]}]}", 400)+ .then().body("message", containsString("dnsServers"));+ register(fargateTaskDefinition("fargate-ipc", ",\"ipcMode\":\"host\""), 400)+ .then().body("message", containsString("ipcMode"));+ register(fargateTaskDefinition("fargate-host-volume",+ ",\"volumes\":[{\"name\":\"data\",\"host\":{\"sourcePath\":\"/srv/data\"}}]"), 400);+ }++ @Test+ void registerTaskDefinitionAllowsThoseParametersOnEc2() {+ // The same members are legal on an EC2-compatible definition, so the rejection above must+ // be scoped to Fargate rather than applied to every task definition.+ register("{\"family\":\"ec2-unsupported-on-fargate\",\"networkMode\":\"bridge\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\","+ + "\"privileged\":true,\"dnsServers\":[\"10.0.0.2\"],"+ + "\"resourceRequirements\":[{\"type\":\"GPU\",\"value\":\"1\"}]}]}", 200)+ .then()+ .body("taskDefinition.containerDefinitions[0].privileged", equalTo(true))+ .body("taskDefinition.containerDefinitions[0].dnsServers[0]", equalTo("10.0.0.2"))+ .body("taskDefinition.containerDefinitions[0].resourceRequirements[0].type",+ equalTo("GPU"));+ }++ @Test+ void registerTaskDefinitionRejectsADependencyOnAContainerThatIsNotThere() {+ register("{\"family\":\"fargate-bad-dependency\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"256\",\"memory\":\"512\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\","+ + "\"dependsOn\":[{\"containerName\":\"sidecar\",\"condition\":\"START\"}]}]}", 400)+ .then().body("message", containsString("sidecar"));+ }++ @Test+ void registerTaskDefinitionRejectsAnUnknownDependencyCondition() {+ register("{\"family\":\"fargate-bad-condition\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"256\",\"memory\":\"512\","+ + "\"containerDefinitions\":[{\"name\":\"init\",\"image\":\"busybox\"},"+ + "{\"name\":\"app\",\"image\":\"nginx:latest\","+ + "\"dependsOn\":[{\"containerName\":\"init\",\"condition\":\"READY\"}]}]}", 400)+ .then().body("message", containsString("READY"));+ }++ @Test+ void registerTaskDefinitionAcceptsTheLargestFargateTaskSize() {+ register("{\"family\":\"fargate-16vcpu\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"16384\",\"memory\":\"122880\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 200);+ }++ @Test+ void registerTaskDefinitionRejectsAMemorySizeOffTheFargateStep() {+ // 8 vCPU goes from 16 GB up in 4 GB steps, so 18 GB is not a configuration that exists.+ Response response = register("{\"family\":\"fargate-8vcpu-bad\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"8192\",\"memory\":\"18432\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 400);+ assertEquals("No Fargate configuration exists for given values.",+ response.jsonPath().getString("message"));+ }++ @Test+ void registerTaskDefinitionRejectsSubVcpuSizesForWindowsOnFargate() {+ register("{\"family\":\"fargate-windows\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"512\",\"memory\":\"1024\","+ + "\"runtimePlatform\":{\"operatingSystemFamily\":\"WINDOWS_SERVER_2019_CORE\","+ + "\"cpuArchitecture\":\"X86_64\"},"+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 400);++ register("{\"family\":\"fargate-windows-ok\",\"requiresCompatibilities\":[\"FARGATE\"],"+ + "\"networkMode\":\"awsvpc\",\"cpu\":\"1024\",\"memory\":\"2048\","+ + "\"runtimePlatform\":{\"operatingSystemFamily\":\"WINDOWS_SERVER_2019_CORE\","+ + "\"cpuArchitecture\":\"X86_64\"},"+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 200);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateTaskIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateTaskIntegrationTest.javanew file mode 100644index 0000000000..3fa89e6928--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsFargateTaskIntegrationTest.java@@ -0,0 +1,264 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.List;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.nullValue;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * RunTask and DescribeTasks for the Fargate launch type: the members an SDK client, a waiter or+ * the CLI reads off a task, and the placement rules that decide whether a task runs on FARGATE or+ * FARGATE_SPOT.+ */+@QuarkusTest+class EcsFargateTaskIntegrationTest {++ private static final String TARGET = "AmazonEC2ContainerServiceV20141113.";+ private static final String CT = "application/x-amz-json-1.1";+ private static final String CLUSTER = "fargate-task-cluster";+ private static final String SUBNET = "subnet-default-us-east-1-a";+ private static final String NETWORK =+ "\"networkConfiguration\":{\"awsvpcConfiguration\":{\"subnets\":[\"" + SUBNET + "\"]}}";++ @BeforeAll+ static void configure() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ private static Response call(String action, String body, int expectedStatus) {+ return given().contentType(CT).header("X-Amz-Target", TARGET + action)+ .body(body)+ .when().post("/")+ .then().statusCode(expectedStatus)+ .extract().response();+ }++ private static String seed(String family) {+ call("CreateCluster", "{\"clusterName\":\"" + CLUSTER + "\"}", 200);+ call("RegisterTaskDefinition", "{\"family\":\"" + family + "\","+ + "\"requiresCompatibilities\":[\"FARGATE\"],\"networkMode\":\"awsvpc\","+ + "\"cpu\":\"256\",\"memory\":\"512\","+ + "\"containerDefinitions\":[{\"name\":\"app\",\"image\":\"nginx:latest\"}]}", 200);+ return family;+ }++ private static Response runTask(String family, String extraMembers) {+ return call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\","+ + "\"launchType\":\"FARGATE\"," + NETWORK + extraMembers + "}", 200);+ }++ @Test+ void runTaskReportsThePlatformAndConnectivityMembersOfAFargateTask() {+ String family = seed("fargate-task-platform");+ Response response = runTask(family, "");++ response.then()+ .body("tasks", hasSize(1))+ .body("tasks[0].launchType", equalTo("FARGATE"))+ .body("tasks[0].platformVersion", equalTo("1.4.0"))+ .body("tasks[0].platformFamily", equalTo("Linux"))+ .body("tasks[0].connectivity", equalTo("CONNECTED"))+ .body("tasks[0].healthStatus", equalTo("UNKNOWN"))+ .body("tasks[0].enableExecuteCommand", equalTo(false))+ .body("tasks[0].ephemeralStorage.sizeInGiB", equalTo(20))+ .body("tasks[0].group", equalTo("family:" + family))+ .body("tasks[0].cpu", equalTo("256"))+ .body("tasks[0].memory", equalTo("512"))+ .body("tasks[0].attributes[0].name", equalTo("ecs.cpu-architecture"));+ assertTrue(response.jsonPath().getLong("tasks[0].version") >= 1, "version must be reported");+ assertTrue(response.jsonPath().getDouble("tasks[0].connectivityAt") > 0,+ "connectivityAt must be reported");+ }++ @Test+ void runTaskGivesAnAwsvpcTaskItsOwnEni() {+ String family = seed("fargate-task-eni");+ Response response = runTask(family, "");++ // The ENI is what a client waits on to find a Fargate task's address, so it is reported+ // whether or not security-group enforcement is on and whether or not Docker is in play.+ response.then()+ .body("tasks[0].attachments", hasSize(1))+ .body("tasks[0].attachments[0].type", equalTo("ElasticNetworkInterface"))+ .body("tasks[0].attachments[0].status", equalTo("ATTACHED"))+ .body("tasks[0].availabilityZone", equalTo("us-east-1a"));++ String eniId = attachmentDetail(response, "networkInterfaceId");+ String privateIp = attachmentDetail(response, "privateIPv4Address");+ assertTrue(eniId != null && eniId.startsWith("eni-"), "the task must report its ENI id");+ assertTrue(privateIp != null && !privateIp.isBlank(), "the task must report a private address");+ assertEquals(SUBNET, attachmentDetail(response, "subnetId"));++ // The ENI is a real one in EC2, in the subnet the task asked for, and the running task+ // holds it: DescribeNetworkInterfaces reports an interface that is not attached as+ // available and one that is as in-use, and a task's is not free for a caller to take.+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeNetworkInterfaces")+ .formParam("Version", "2016-11-15")+ .formParam("NetworkInterfaceId.1", eniId)+ .when().post("/")+ .then().statusCode(200)+ .body(containsString(SUBNET))+ .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.status",+ equalTo("in-use"))+ // No attachment is reported: every member of one names an instance, and a Fargate+ // task has none in the account.+ .body(not(containsString("<attachment>")));++ String taskArn = response.jsonPath().getString("tasks[0].taskArn");+ call("StopTask", "{\"cluster\":\"" + CLUSTER + "\",\"task\":\"" + taskArn + "\"}", 200)+ .then().body("task.attachments[0].status", equalTo("DELETED"));++ // Stopping the task releases the interface rather than leaving it behind in the account.+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeNetworkInterfaces")+ .formParam("Version", "2016-11-15")+ .formParam("NetworkInterfaceId.1", eniId)+ .when().post("/")+ .then().statusCode(400)+ .body(containsString("InvalidNetworkInterfaceID.NotFound"));+ }++ private static String attachmentDetail(Response response, String name) {+ List<String> values = response.jsonPath()+ .getList("tasks[0].attachments[0].details.findAll { it.name == '" + name + "' }.value");+ return values.isEmpty() ? null : values.getFirst();+ }++ @Test+ void runTaskRejectsASubnetThatDoesNotExist() {+ String family = seed("fargate-task-bad-subnet");+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"FARGATE\",\"networkConfiguration\":{\"awsvpcConfiguration\":"+ + "{\"subnets\":[\"subnet-does-not-exist\"]}}}", 400)+ .then().body("message", containsString("subnet-does-not-exist"));+ }++ @Test+ void runTaskResolvesTheLatestPlatformVersionToAConcreteOne() {+ String family = seed("fargate-task-latest");+ runTask(family, ",\"platformVersion\":\"LATEST\"").then()+ .body("tasks[0].platformVersion", equalTo("1.4.0"));+ runTask(family, ",\"platformVersion\":\"1.3.0\"").then()+ .body("tasks[0].platformVersion", equalTo("1.3.0"));+ }++ @Test+ void runTaskEchoesTheOverridesItWasGiven() {+ String family = seed("fargate-task-overrides");+ runTask(family, ",\"overrides\":{\"cpu\":\"512\",\"memory\":\"1024\","+ + "\"ephemeralStorage\":{\"sizeInGiB\":40},"+ + "\"containerOverrides\":[{\"name\":\"app\",\"command\":[\"sleep\",\"1\"],"+ + "\"environment\":[{\"name\":\"MODE\",\"value\":\"test\"}]}]}").then()+ .body("tasks[0].cpu", equalTo("512"))+ .body("tasks[0].memory", equalTo("1024"))+ .body("tasks[0].ephemeralStorage.sizeInGiB", equalTo(40))+ .body("tasks[0].overrides.cpu", equalTo("512"))+ .body("tasks[0].overrides.ephemeralStorage.sizeInGiB", equalTo(40))+ .body("tasks[0].overrides.containerOverrides[0].name", equalTo("app"))+ .body("tasks[0].overrides.containerOverrides[0].command[0]", equalTo("sleep"))+ .body("tasks[0].overrides.containerOverrides[0].environment[0].name", equalTo("MODE"));+ }++ @Test+ void runTaskCarriesEnableExecuteCommandAndTags() {+ String family = seed("fargate-task-exec");+ runTask(family, ",\"enableExecuteCommand\":true,\"tags\":[{\"key\":\"owner\",\"value\":\"platform\"}]")+ .then()+ .body("tasks[0].enableExecuteCommand", equalTo(true))+ .body("tasks[0].tags[0].key", equalTo("owner"))+ .body("tasks[0].tags[0].value", equalTo("platform"));+ }++ @Test+ void stopTaskReportsTheStopCodeAndAdvancesTheVersion() {+ String family = seed("fargate-task-stop");+ Response launched = runTask(family, "");+ String taskArn = launched.jsonPath().getString("tasks[0].taskArn");+ long versionWhenRunning = launched.jsonPath().getLong("tasks[0].version");++ call("StopTask", "{\"cluster\":\"" + CLUSTER + "\",\"task\":\"" + taskArn+ + "\",\"reason\":\"done\"}", 200).then()+ .body("task.stopCode", equalTo("UserInitiated"))+ .body("task.stoppedReason", equalTo("done"));++ Response described = call("DescribeTasks", "{\"cluster\":\"" + CLUSTER + "\",\"tasks\":[\""+ + taskArn + "\"]}", 200);+ described.then()+ .body("tasks[0].lastStatus", equalTo("STOPPED"))+ .body("tasks[0].stopCode", equalTo("UserInitiated"));+ assertTrue(described.jsonPath().getLong("tasks[0].version") > versionWhenRunning,+ "stopping a task must advance its version");+ assertTrue(described.jsonPath().getDouble("tasks[0].executionStoppedAt") > 0,+ "executionStoppedAt must be reported once the task has stopped");+ }++ @Test+ void runTaskPlacesThroughACapacityProviderStrategyByBaseThenWeight() {+ String family = seed("fargate-task-strategy");+ Response response = call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\""+ + family + "\",\"count\":5," + NETWORK + ",\"capacityProviderStrategy\":["+ + "{\"capacityProvider\":\"FARGATE\",\"base\":1,\"weight\":1},"+ + "{\"capacityProvider\":\"FARGATE_SPOT\",\"weight\":3}]}", 200);++ List<String> providers = response.jsonPath().getList("tasks.capacityProviderName");+ assertEquals(5, providers.size());+ assertEquals(2, providers.stream().filter("FARGATE"::equals).count(),+ "one task for the base plus its quarter of the remaining four");+ assertEquals(3, providers.stream().filter("FARGATE_SPOT"::equals).count(),+ "three quarters of the remaining four");+ // A task reports both the provider it was placed through and the launch type that+ // provider resolves to, unlike a service, which reports only one of the two.+ response.then().body("tasks[0].launchType", equalTo("FARGATE"));+ }++ @Test+ void runTaskRejectsALaunchTypeAndACapacityProviderStrategyTogether() {+ String family = seed("fargate-task-both");+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"FARGATE\"," + NETWORK + ",\"capacityProviderStrategy\":"+ + "[{\"capacityProvider\":\"FARGATE_SPOT\",\"weight\":1}]}", 400)+ .then().body("message", containsString("cannot specify both"));+ }++ @Test+ void runTaskRejectsAnUnknownCapacityProvider() {+ String family = seed("fargate-task-unknown-provider");+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family + "\","+ + NETWORK + ",\"capacityProviderStrategy\":"+ + "[{\"capacityProvider\":\"NOT_A_PROVIDER\",\"weight\":1}]}", 400)+ .then().body("message", containsString("NOT_A_PROVIDER"));+ }++ @Test+ void runTaskRejectsAnAwsvpcTaskWithNoNetworkConfiguration() {+ String family = seed("fargate-task-no-network");+ call("RunTask", "{\"cluster\":\"" + CLUSTER + "\",\"taskDefinition\":\"" + family+ + "\",\"launchType\":\"FARGATE\"}", 400)+ .then().body("message", containsString("Network Configuration must be provided"));+ }++ @Test+ void createServiceOnACapacityProviderStrategyReportsItInsteadOfALaunchType() {+ String family = seed("fargate-service-strategy");+ call("CreateService", "{\"cluster\":\"" + CLUSTER + "\",\"serviceName\":\"fargate-spot-svc\","+ + "\"taskDefinition\":\"" + family + "\",\"desiredCount\":0," + NETWORK + ","+ + "\"capacityProviderStrategy\":[{\"capacityProvider\":\"FARGATE_SPOT\",\"weight\":1}]}", 200)+ .then()+ .body("service.capacityProviderStrategy[0].capacityProvider", equalTo("FARGATE_SPOT"))+ .body("service.capacityProviderStrategy[0].weight", equalTo(1))+ .body("service.launchType", nullValue());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsIntegrationTest.javaindex eab2f56b0d..fd1bb6d2f6 100644--- a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsIntegrationTest.java@@ -452,6 +452,7 @@ class EcsIntegrationTest {"cluster": "%s","taskDefinition": "%s","launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}},"count": 1}""".formatted(CLUSTER_NAME, TASK_DEF_FAMILY))@@ -541,6 +542,7 @@ class EcsIntegrationTest {"cluster": "%s","taskDefinition": "empty-containers-task","launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}},"count": 1}""".formatted(CLUSTER_NAME))@@ -694,6 +696,7 @@ class EcsIntegrationTest {"taskDefinition": "%s","desiredCount": 1,"launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}},"tags": [{"key": "Environment", "value": "dev"},{"key": "Project", "value": "project1"}@@ -787,7 +790,8 @@ class EcsIntegrationTest {"serviceName": "%s","taskDefinition": "%s","desiredCount": 2,- "launchType": "FARGATE"+ "launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}}}""".formatted(CLUSTER_NAME, SERVICE_NAME, TASK_DEF_FAMILY)).when()@@ -808,7 +812,8 @@ class EcsIntegrationTest {"serviceName": "%s","taskDefinition": "%s","desiredCount": 99,- "launchType": "FARGATE"+ "launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}}}""".formatted(CLUSTER_NAME, SERVICE_NAME, TASK_DEF_FAMILY)).when()@@ -831,7 +836,8 @@ class EcsIntegrationTest {"serviceName": "negative-count-svc","taskDefinition": "%s","desiredCount": -5,- "launchType": "FARGATE"+ "launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}}}""".formatted(CLUSTER_NAME, TASK_DEF_FAMILY)).when()@@ -873,7 +879,8 @@ class EcsIntegrationTest {"serviceName": "zero-count-svc","taskDefinition": "%s","desiredCount": 0,- "launchType": "FARGATE"+ "launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}}}""".formatted(CLUSTER_NAME, TASK_DEF_FAMILY)).when()@@ -1074,7 +1081,8 @@ class EcsIntegrationTest {"serviceName": "%s","taskDefinition": "review-td","desiredCount": 1,- "launchType": "FARGATE"+ "launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}}}""".formatted(REVIEW_CLUSTER, REVIEW_SERVICE)).when()@@ -1160,6 +1168,7 @@ class EcsIntegrationTest {"taskDefinition": "review-td","desiredCount": 1,"launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}},"loadBalancers": [{"targetGroupArn": "arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/tg-a/1234",@@ -1184,6 +1193,7 @@ class EcsIntegrationTest {"taskDefinition": "review-td","desiredCount": 1,"launchType": "FARGATE",+ "networkConfiguration": {"awsvpcConfiguration": {"subnets": ["subnet-default-us-east-1-a"]}},"loadBalancers": [{"targetGroupArn": "arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/tg-DIFFERENT/9999",diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsServicePersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsServicePersistenceTest.javaindex 5b79f18388..abd7b960a9 100644--- a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsServicePersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsServicePersistenceTest.java@@ -7,12 +7,15 @@ import io.github.hectorvent.floci.core.storage.InMemoryStorage;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.ec2.Ec2Service;import io.github.hectorvent.floci.services.ecs.container.EcsContainerManager;import io.github.hectorvent.floci.services.ecs.model.Attribute;+import io.github.hectorvent.floci.services.ecs.model.AwsVpcConfiguration;import io.github.hectorvent.floci.services.ecs.model.ContainerDefinition;import io.github.hectorvent.floci.services.ecs.model.EcsCluster;import io.github.hectorvent.floci.services.ecs.model.EcsServiceModel;import io.github.hectorvent.floci.services.ecs.model.LaunchType;+import io.github.hectorvent.floci.services.ecs.model.NetworkConfiguration;import io.github.hectorvent.floci.services.ecs.model.NetworkMode;import io.github.hectorvent.floci.services.ecs.model.TaskDefinition;import org.junit.jupiter.api.Test;@@ -47,7 +50,7 @@ class EcsServicePersistenceTest {NetworkMode.awsvpc, "256", "512", null, null, List.of("FARGATE"),Map.of("tier", "web"), REGION);EcsServiceModel svc = first.createService("app-cluster", "web-svc", td.getTaskDefinitionArn(),- 0, LaunchType.FARGATE, List.of(), null, Map.of("team", "payments"), REGION);+ 0, LaunchType.FARGATE, List.of(), awsvpcConfiguration(), Map.of("team", "payments"), REGION);first.putAttributes("app-cluster",List.of(new Attribute("stack", "prod", "container-instance", "ci-1")), REGION);first.putAccountSetting("containerInsights", "enabled");@@ -104,6 +107,15 @@ class EcsServicePersistenceTest {return cd;}+ /** An awsvpc service needs the subnets its tasks get an ENI in, as it does on AWS. */+ private static NetworkConfiguration awsvpcConfiguration() {+ AwsVpcConfiguration awsvpc = new AwsVpcConfiguration();+ awsvpc.setSubnets(List.of(Ec2Service.defaultSubnetId(REGION, "a")));+ NetworkConfiguration networkConfiguration = new NetworkConfiguration();+ networkConfiguration.setAwsvpcConfiguration(awsvpc);+ return networkConfiguration;+ }+private static EcsService serviceWithStorage(StorageFactory storage) {EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);when(config.services().ecs().mock()).thenReturn(true);diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManagerSecurityGroupTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManagerSecurityGroupTest.javaindex b307de3174..1f8fcbe9f0 100644--- a/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManagerSecurityGroupTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManagerSecurityGroupTest.java@@ -36,6 +36,7 @@ import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyInt;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.atLeastOnce;import static org.mockito.Mockito.RETURNS_DEEP_STUBS;import static org.mockito.Mockito.RETURNS_SELF;import static org.mockito.Mockito.mock;@@ -141,7 +142,7 @@ class EcsContainerManagerSecurityGroupTest {}@Test- void stopTaskUnregistersEni() {+ void stopTaskUnregistersEniAndReleasingTheTaskNetworkDeletesIt() {when(containerDetector.isRunningInContainer()).thenReturn(false);when(firewallManager.enabled()).thenReturn(true);when(firewallManager.createNamespace(eq("ecs"), eq("abc123"), any(), any(), any(), any()))@@ -162,11 +163,17 @@ class EcsContainerManagerSecurityGroupTest {DockerClient stopClient = mock(DockerClient.class, RETURNS_DEEP_STUBS);when(lifecycleManager.getDockerClient()).thenReturn(dockerClient, dockerClient, stopClient);- EcsTaskHandle handle = manager.startTask(awsvpcTask(), awsvpcTaskDef(List.of()),+ EcsTask task = awsvpcTask();+ EcsTaskHandle handle = manager.startTask(task, awsvpcTaskDef(List.of()),List.of(), "us-east-1");manager.stopTaskAndCollectExitCodes(handle);- verify(firewallManager).unregister("eni-1");+ // Stopping the containers tears down their firewall registration, but the ENI belongs to+ // the task: it lives until the task itself is released.+ verify(firewallManager, atLeastOnce()).unregister("eni-1");+ verify(ec2Service, never()).deleteNetworkInterface(any(), any());++ manager.releaseTaskNetwork(task, "us-east-1");verify(ec2Service).deleteNetworkInterface("us-east-1", "eni-1");}diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeEcsRunTaskIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeEcsRunTaskIntegrationTest.javaindex 7a7cc19c57..cddf994fb7 100644--- a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeEcsRunTaskIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeEcsRunTaskIntegrationTest.java@@ -69,8 +69,8 @@ class EventBridgeEcsRunTaskIntegrationTest {"Group": "eb-ecs-group-%s","NetworkConfiguration": {"awsvpcConfiguration": {- "Subnets": ["subnet-1", "subnet-2"],- "SecurityGroups": ["sg-1"],+ "Subnets": ["subnet-default-us-east-1-a", "subnet-default-us-east-1-b"],+ "SecurityGroups": ["sg-default-us-east-1"],"AssignPublicIp": "ENABLED"}}@@ -100,9 +100,9 @@ class EventBridgeEcsRunTaskIntegrationTest {.body("Targets[0].EcsParameters.LaunchType", equalTo("FARGATE")).body("Targets[0].EcsParameters.Group", equalTo("eb-ecs-group-" + suffix)).body("Targets[0].EcsParameters.NetworkConfiguration.awsvpcConfiguration.Subnets",- hasItem("subnet-1"))+ hasItem("subnet-default-us-east-1-a")).body("Targets[0].EcsParameters.NetworkConfiguration.awsvpcConfiguration.SecurityGroups",- hasItem("sg-1"))+ hasItem("sg-default-us-east-1")).body("Targets[0].EcsParameters.NetworkConfiguration.awsvpcConfiguration.AssignPublicIp",equalTo("ENABLED"));