Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ecs): adding ecs service (#209)
Hector Ventura07a7a97b4747
diff --git a/README.md b/README.mdindex 081978f498..199c1101bd 100644--- a/README.md+++ b/README.md@@ -50,9 +50,10 @@| STS (all 7 operations) | ✅ | ⚠️ Partial || Kinesis (streams, shards, fan-out) | ✅ | ⚠️ Partial || KMS (sign, verify, re-encrypt) | ✅ | ⚠️ Partial |+| ECS (clusters, services, tasks) | ✅ | ❌ || Native binary | ✅ ~40 MB | ❌ |-**25 services. 1,873 automated compatibility tests. Free forever.**+**26 services. 1,873 automated compatibility tests. Free forever.**## Architecture Overview@@ -72,7 +73,7 @@ flowchart LRendsubgraph Containers ["Container Services 🐳"]- C["Lambda\nElastiCache\nRDS"]+ C["Lambda\nElastiCache\nRDS\nECS"]endRouter --> Stateless@@ -112,11 +113,12 @@ flowchart LR| **CloudWatch Metrics** | 5 | In-process | Custom metrics, statistics, alarms || **ElastiCache** | 9 | **Real Docker containers** | Redis / Valkey, IAM auth, SigV4 validation || **RDS** | 14 | **Real Docker containers** | PostgreSQL & MySQL, IAM auth, JDBC-compatible |+| **ECS** | 58 | **Real Docker containers** | Clusters, task definitions, tasks, services, capacity providers, task sets || **ACM** | 8 | In-process | Certificate issuance, validation lifecycle || **SES** | 14 | In-process | Send email / raw email, identity verification, DKIM attributes || **OpenSearch** | 24 | In-process | Domain CRUD, tags, versions, instance types, upgrade stubs |-> **Lambda, ElastiCache, and RDS** spin up real Docker containers and support IAM authentication and SigV4 request signing — the same auth flow as production AWS.+> **Lambda, ElastiCache, RDS, and ECS** spin up real Docker containers and support IAM authentication and SigV4 request signing — the same auth flow as production AWS.## Quick Startdiff --git a/docs/configuration/application-yml.md b/docs/configuration/application-yml.mdindex 62bf4ca997..5c11455c01 100644--- a/docs/configuration/application-yml.md+++ b/docs/configuration/application-yml.md@@ -137,6 +137,13 @@ floci:default-image: "opensearchproject/opensearch:2"proxy-base-port: 9400proxy-max-port: 9499++ ecs:+ enabled: true+ mock: false # true = tasks go to RUNNING without Docker (useful for CI)+ docker-network: "" # Docker network for task containers+ default-memory-mb: 512+ default-cpu-units: 256```## Service Limits@@ -152,6 +159,10 @@ floci:| `FLOCI_SERVICES_S3_DEFAULT_PRESIGN_EXPIRY_SECONDS` | `3600` | Pre-signed URL expiry || `FLOCI_SERVICES_DYNAMODB_MAX_ITEM_SIZE` | `400000` | Max item size (bytes) || `FLOCI_SERVICES_DOCKER_NETWORK` | | Shared Docker network for Lambda, RDS, ElastiCache containers |+| `FLOCI_SERVICES_ECS_MOCK` | `false` | Skip Docker; tasks go straight to RUNNING (useful for CI) |+| `FLOCI_SERVICES_ECS_DOCKER_NETWORK` | | Docker network for ECS task containers |+| `FLOCI_SERVICES_ECS_DEFAULT_MEMORY_MB` | `512` | Default memory (MB) when task definition omits it |+| `FLOCI_SERVICES_ECS_DEFAULT_CPU_UNITS` | `256` | Default CPU units when task definition omits it |## Disabling Servicesdiff --git a/docs/services/ecs.md b/docs/services/ecs.mdnew file mode 100644index 0000000000..2e44e2736a--- /dev/null+++ b/docs/services/ecs.md@@ -0,0 +1,284 @@+# ECS (Elastic Container Service)++**Protocol:** JSON 1.1+**Endpoint:** `POST /` + `X-Amz-Target: AmazonEC2ContainerServiceV20141113.<Action>`++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.++## Supported Operations++### Clusters++| Operation | Description |+|---|---|+| `CreateCluster` | Create a cluster (idempotent) |+| `DescribeClusters` | Describe one or more clusters |+| `ListClusters` | List cluster ARNs |+| `UpdateCluster` | Update cluster settings |+| `UpdateClusterSettings` | Update `containerInsights` and other settings |+| `PutClusterCapacityProviders` | Associate capacity providers with a cluster |+| `DeleteCluster` | Delete an empty cluster |++### Task Definitions++| Operation | Description |+|---|---|+| `RegisterTaskDefinition` | Register a new revision of a task definition |+| `DescribeTaskDefinition` | Describe a task definition by family:revision or ARN |+| `ListTaskDefinitions` | List task definition ARNs |+| `ListTaskDefinitionFamilies` | List task definition family names |+| `DeregisterTaskDefinition` | Mark a revision INACTIVE |+| `DeleteTaskDefinitions` | Delete one or more task definitions |++### Tasks++| Operation | Description |+|---|---|+| `RunTask` | Launch one or more task instances |+| `StartTask` | Start a task on specific container instances |+| `StopTask` | Stop a running task |+| `DescribeTasks` | Describe one or more tasks |+| `ListTasks` | List task ARNs (filterable by cluster, family, service, status) |+| `UpdateTaskProtection` | Set scale-in protection for tasks |+| `GetTaskProtection` | Get current task protection state |++### Services++| Operation | Description |+|---|---|+| `CreateService` | Create a long-running service |+| `UpdateService` | Update desired count, task definition, or deployment config |+| `DeleteService` | Delete a service (supports `force`) |+| `DescribeServices` | Describe one or more services |+| `ListServices` | List service ARNs in a cluster |+| `ListServicesByNamespace` | List services filtered by Cloud Map namespace |++### Task Sets++| Operation | Description |+|---|---|+| `CreateTaskSet` | Create a task set inside a service |+| `UpdateTaskSet` | Update a task set's scale |+| `DeleteTaskSet` | Delete a task set |+| `DescribeTaskSets` | Describe task sets for a service |+| `UpdateServicePrimaryTaskSet` | Promote a task set to primary |++### Container Instances++| Operation | Description |+|---|---|+| `RegisterContainerInstance` | Register a container instance with a cluster |+| `DeregisterContainerInstance` | Deregister a container instance |+| `DescribeContainerInstances` | Describe container instances |+| `ListContainerInstances` | List container instance ARNs |+| `UpdateContainerAgent` | Trigger agent update (stub) |+| `UpdateContainerInstancesState` | Drain or activate container instances |++### Capacity Providers++| Operation | Description |+|---|---|+| `CreateCapacityProvider` | Create a custom capacity provider |+| `UpdateCapacityProvider` | Update a capacity provider |+| `DeleteCapacityProvider` | Delete a capacity provider |+| `DescribeCapacityProviders` | Describe capacity providers (includes FARGATE built-ins) |++### Service Deployments & Revisions++| Operation | Description |+|---|---|+| `DescribeServiceDeployments` | Describe service deployments |+| `ListServiceDeployments` | List service deployment ARNs |+| `DescribeServiceRevisions` | Describe service revisions |++### Tags++| Operation | Description |+|---|---|+| `TagResource` | Add tags to a cluster, service, task, or task definition |+| `UntagResource` | Remove tags from a resource |+| `ListTagsForResource` | List tags on a resource |++### Account Settings & Attributes++| Operation | Description |+|---|---|+| `PutAccountSetting` | Set an account-level setting for the calling user |+| `PutAccountSettingDefault` | Set the default account-level setting |+| `DeleteAccountSetting` | Delete an account setting |+| `ListAccountSettings` | List account settings |+| `PutAttributes` | Set custom key-value attributes on resources |+| `DeleteAttributes` | Remove attributes from resources |+| `ListAttributes` | List resources with a given attribute |++### Agent / State Change Stubs++| Operation | Description |+|---|---|+| `SubmitTaskStateChange` | Agent callback stub |+| `SubmitContainerStateChange` | Agent callback stub |+| `SubmitAttachmentStateChanges` | Agent callback stub |+| `DiscoverPollEndpoint` | Returns the agent polling endpoint |++## Configuration++```yaml+floci:+ services:+ ecs:+ enabled: true+ mock: false # Set true to skip Docker and run tasks as in-process stubs+ docker-network: "" # Docker network for task containers+ default-memory-mb: 512+ default-cpu-units: 256+```++### Environment Variables++| Variable | Default | Description |+|---|---|---|+| `FLOCI_SERVICES_ECS_ENABLED` | `true` | Enable or disable the ECS service |+| `FLOCI_SERVICES_ECS_MOCK` | `false` | Skip Docker; tasks go straight to `RUNNING` (useful for CI) |+| `FLOCI_SERVICES_ECS_DOCKER_NETWORK` | *(unset)* | Docker network for task containers |+| `FLOCI_SERVICES_ECS_DEFAULT_MEMORY_MB` | `512` | Default memory (MB) when the task definition omits it |+| `FLOCI_SERVICES_ECS_DEFAULT_CPU_UNITS` | `256` | Default CPU units when the task definition omits it |++### 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.++```yaml+# docker-compose.yml — CI / test environment+services:+ floci:+ image: hectorvent/floci:latest+ environment:+ FLOCI_SERVICES_ECS_MOCK: "true"+```++```yaml+# docker-compose.yml — local development (real containers)+services:+ floci:+ image: hectorvent/floci:latest+ volumes:+ - /var/run/docker.sock:/var/run/docker.sock+ environment:+ FLOCI_SERVICES_ECS_MOCK: "false"+ FLOCI_SERVICES_ECS_DOCKER_NETWORK: my_network+```++### Docker socket requirement++When `mock: false` (the default), ECS launches real Docker containers and requires the Docker socket. Mount it and set the network so containers can reach each other:++```yaml+services:+ floci:+ image: hectorvent/floci:latest+ volumes:+ - /var/run/docker.sock:/var/run/docker.sock+ environment:+ FLOCI_SERVICES_ECS_DOCKER_NETWORK: aws-local_default+```++## Examples++```bash+export AWS_ENDPOINT_URL=http://localhost:4566+export AWS_DEFAULT_REGION=us-east-1+export AWS_ACCESS_KEY_ID=test+export AWS_SECRET_ACCESS_KEY=test++# Create a cluster+aws ecs create-cluster --cluster-name my-cluster \+ --endpoint-url $AWS_ENDPOINT_URL++# Register a task definition+aws ecs register-task-definition \+ --family my-task \+ --container-definitions '[+ {+ "name": "app",+ "image": "nginx:latest",+ "cpu": 256,+ "memory": 512,+ "essential": true,+ "portMappings": [{"containerPort": 80, "protocol": "tcp"}]+ }+ ]' \+ --requires-compatibilities FARGATE \+ --cpu 256 --memory 512 \+ --network-mode awsvpc \+ --endpoint-url $AWS_ENDPOINT_URL++# Run a task+aws ecs run-task \+ --cluster my-cluster \+ --task-definition my-task \+ --launch-type FARGATE \+ --endpoint-url $AWS_ENDPOINT_URL++# Create a service+aws ecs create-service \+ --cluster my-cluster \+ --service-name my-service \+ --task-definition my-task \+ --desired-count 1 \+ --launch-type FARGATE \+ --endpoint-url $AWS_ENDPOINT_URL++# List running tasks+aws ecs list-tasks --cluster my-cluster \+ --endpoint-url $AWS_ENDPOINT_URL++# Stop a task+aws ecs stop-task \+ --cluster my-cluster \+ --task <task-arn> \+ --endpoint-url $AWS_ENDPOINT_URL++# Delete a service+aws ecs delete-service \+ --cluster my-cluster \+ --service my-service \+ --force \+ --endpoint-url $AWS_ENDPOINT_URL+```++## Java SDK Example++```java+EcsClient ecs = EcsClient.builder()+ .endpointOverride(URI.create("http://localhost:4566"))+ .region(Region.US_EAST_1)+ .credentialsProvider(StaticCredentialsProvider.create(+ AwsBasicCredentials.create("test", "test")))+ .build();++// Create cluster+ecs.createCluster(r -> r.clusterName("my-cluster"));++// Register task definition+ecs.registerTaskDefinition(r -> r+ .family("my-task")+ .containerDefinitions(c -> c+ .name("app")+ .image("nginx:latest")+ .cpu(256)+ .memory(512)+ .essential(true))+ .requiresCompatibilities(Compatibility.FARGATE)+ .cpu("256")+ .memory("512")+ .networkMode(NetworkMode.AWSVPC));++// Run a task+RunTaskResponse response = ecs.runTask(r -> r+ .cluster("my-cluster")+ .taskDefinition("my-task")+ .launchType(LaunchType.FARGATE)+ .count(1));++String taskArn = response.tasks().get(0).taskArn();+```diff --git a/docs/services/index.md b/docs/services/index.mdindex 3198ad4b5f..c08ab29a4b 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -1,6 +1,6 @@# Services Overview-Floci emulates 25 AWS services on a single port (`4566`). All services use the real AWS wire protocol — your existing AWS CLI commands and SDK clients work without modification.+Floci emulates 26 AWS services on a single port (`4566`). All services use the real AWS wire protocol — your existing AWS CLI commands and SDK clients work without modification.## Service Matrix@@ -30,6 +30,7 @@ Floci emulates 25 AWS services on a single port (`4566`). All services use the r| [CloudWatch Logs](cloudwatch.md) | `POST /` + `X-Amz-Target: Logs.*` | JSON 1.1 | 14 || [CloudWatch Metrics](cloudwatch.md#metrics) | `POST /` with `Action=` or JSON 1.1 | Query / JSON | 8 || [ACM](acm.md) | `POST /` + `X-Amz-Target: CertificateManager.*` | JSON 1.1 | 12 |+| [ECS](ecs.md) | `POST /` + `X-Amz-Target: AmazonEC2ContainerServiceV20141113.*` | JSON 1.1 | 58 || [SES](ses.md) | `POST /` with `Action=` param | Query | 14 || [OpenSearch](opensearch.md) | `/2021-01-01/opensearch/...` | REST JSON | 24 |diff --git a/mkdocs.yml b/mkdocs.ymlindex aacea05edd..a7cd2cda5f 100644--- a/mkdocs.yml+++ b/mkdocs.yml@@ -88,5 +88,6 @@ nav:- EventBridge: services/eventbridge.md- CloudWatch: services/cloudwatch.md- ACM: services/acm.md+ - ECS: services/ecs.md- OpenSearch: services/opensearch.md- Contributing: contributing.md\ No newline at end of filediff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex ba5dc65330..349340fd9a 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -190,6 +190,7 @@ public interface EmulatorConfig {AcmServiceConfig acm();SesServiceConfig ses();OpenSearchServiceConfig opensearch();+ EcsServiceConfig ecs();}interface SsmServiceConfig {@@ -368,6 +369,23 @@ public interface EmulatorConfig {Optional<String> dockerNetwork();}+ interface EcsServiceConfig {+ @WithDefault("true")+ boolean enabled();++ /** When true, tasks go straight to RUNNING without starting real Docker containers. */+ @WithDefault("false")+ boolean mock();++ Optional<String> dockerNetwork();++ @WithDefault("512")+ int defaultMemoryMb();++ @WithDefault("256")+ int defaultCpuUnits();+ }+interface LambdaServiceConfig {@WithDefault("true")boolean enabled();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.javaindex 9aeacb97d3..27109b5d05 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.core.common;import io.github.hectorvent.floci.services.acm.AcmJsonHandler;+import io.github.hectorvent.floci.services.ecs.EcsJsonHandler;import io.github.hectorvent.floci.services.apigatewayv2.ApiGatewayV2JsonHandler;import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsHandler;import io.github.hectorvent.floci.services.cognito.CognitoJsonHandler;@@ -42,6 +43,7 @@ public class AwsJson11Controller {private static final String KMS_TARGET_PREFIX = "TrentService.";private static final String COGNITO_TARGET_PREFIX = "AWSCognitoIdentityProviderService.";private static final String ACM_TARGET_PREFIX = "CertificateManager.";+ private static final String ECS_TARGET_PREFIX = "AmazonEC2ContainerServiceV20141113.";private final ObjectMapper objectMapper;private final RegionResolver regionResolver;@@ -54,6 +56,7 @@ public class AwsJson11Controller {private final KmsJsonHandler kmsJsonHandler;private final CognitoJsonHandler cognitoJsonHandler;private final AcmJsonHandler acmJsonHandler;+ private final EcsJsonHandler ecsJsonHandler;@Injectpublic AwsJson11Controller(ObjectMapper objectMapper, RegionResolver regionResolver,@@ -63,7 +66,7 @@ public class AwsJson11Controller {KinesisJsonHandler kinesisJsonHandler,ApiGatewayV2JsonHandler apigwV2JsonHandler,KmsJsonHandler kmsJsonHandler, CognitoJsonHandler cognitoJsonHandler,- AcmJsonHandler acmJsonHandler) {+ AcmJsonHandler acmJsonHandler, EcsJsonHandler ecsJsonHandler) {this.objectMapper = objectMapper;this.regionResolver = regionResolver;this.ssmJsonHandler = ssmJsonHandler;@@ -75,6 +78,7 @@ public class AwsJson11Controller {this.kmsJsonHandler = kmsJsonHandler;this.cognitoJsonHandler = cognitoJsonHandler;this.acmJsonHandler = acmJsonHandler;+ this.ecsJsonHandler = ecsJsonHandler;}@POST@@ -119,6 +123,9 @@ public class AwsJson11Controller {} else if (target.startsWith(ACM_TARGET_PREFIX)) {prefix = ACM_TARGET_PREFIX;serviceName = "ACM";+ } else if (target.startsWith(ECS_TARGET_PREFIX)) {+ prefix = ECS_TARGET_PREFIX;+ serviceName = "ECS";} else {return Response.status(400).entity(new AwsErrorResponse("UnknownOperationException",@@ -143,6 +150,7 @@ public class AwsJson11Controller {case "KMS" -> kmsJsonHandler.handle(action, request, region);case "Cognito" -> cognitoJsonHandler.handle(action, request, region);case "ACM" -> acmJsonHandler.handle(action, request, region);+ case "ECS" -> ecsJsonHandler.handle(action, request, region);default -> null;};} catch (AwsException e) {diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ServiceRegistry.java b/src/main/java/io/github/hectorvent/floci/core/common/ServiceRegistry.javaindex a53334add8..f9dc5c1edd 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/ServiceRegistry.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/ServiceRegistry.java@@ -50,6 +50,7 @@ public class ServiceRegistry {case "acm" -> config.services().acm().enabled();case "email" -> config.services().ses().enabled();case "es" -> config.services().opensearch().enabled();+ case "ecs" -> config.services().ecs().enabled();default -> true;};}@@ -79,6 +80,7 @@ public class ServiceRegistry {if (config.services().acm().enabled()) enabled.add("acm");if (config.services().ses().enabled()) enabled.add("email");if (config.services().opensearch().enabled()) enabled.add("es");+ if (config.services().ecs().enabled()) enabled.add("ecs");return enabled;}@@ -110,6 +112,7 @@ public class ServiceRegistry {services.put("acm", status(config.services().acm().enabled()));services.put("email", status(config.services().ses().enabled()));services.put("es", status(config.services().opensearch().enabled()));+ services.put("ecs", status(config.services().ecs().enabled()));return services;}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.javanew file mode 100644index 0000000000..e4ab4d4abb--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java@@ -0,0 +1,1212 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.core.common.AwsErrorResponse;+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.ClusterSetting;+import io.github.hectorvent.floci.services.ecs.model.ContainerDefinition;+import io.github.hectorvent.floci.services.ecs.model.ContainerInstance;+import io.github.hectorvent.floci.services.ecs.model.EcsCluster;+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.KeyValuePair;+import io.github.hectorvent.floci.services.ecs.model.LaunchType;+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.ProtectedTask;+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.TaskSet;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import jakarta.ws.rs.core.Response;++import java.util.ArrayList;+import java.util.HashMap;+import java.util.List;+import java.util.Map;++@ApplicationScoped+public class EcsJsonHandler {++ private final EcsService service;+ private final ObjectMapper objectMapper;++ @Inject+ public EcsJsonHandler(EcsService service, ObjectMapper objectMapper) {+ this.service = service;+ this.objectMapper = objectMapper;+ }++ public Response handle(String action, JsonNode request, String region) {+ return switch (action) {+ // Clusters+ case "CreateCluster" -> handleCreateCluster(request, region);+ case "DescribeClusters" -> handleDescribeClusters(request, region);+ case "ListClusters" -> handleListClusters(request, region);+ case "DeleteCluster" -> handleDeleteCluster(request, region);+ 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);+ case "DescribeTasks" -> handleDescribeTasks(request, region);+ 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."))+ .build();+ };+ }++ // ── Clusters ──────────────────────────────────────────────────────────────++ private Response handleCreateCluster(JsonNode req, String region) {+ String name = req.path("clusterName").asText(null);+ EcsCluster cluster = service.createCluster(name, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("cluster", clusterNode(cluster));+ return Response.ok(resp).build();+ }++ private Response handleDescribeClusters(JsonNode req, String region) {+ List<String> ids = jsonArrayToList(req.path("clusters"));+ List<EcsCluster> found = service.describeClusters(ids, region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ found.forEach(c -> arr.add(clusterNode(c)));+ resp.set("clusters", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ private Response handleListClusters(JsonNode req, String region) {+ List<String> arns = service.listClusters(region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ arns.forEach(arr::add);+ resp.set("clusterArns", arr);+ return Response.ok(resp).build();+ }++ private Response handleDeleteCluster(JsonNode req, String region) {+ String clusterId = req.path("cluster").asText();+ EcsCluster cluster = service.deleteCluster(clusterId, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("cluster", clusterNode(cluster));+ return Response.ok(resp).build();+ }++ private Response handleUpdateCluster(JsonNode req, String region) {+ String clusterRef = req.path("cluster").asText();+ List<ClusterSetting> settings = parseClusterSettings(req.path("settings"));+ EcsCluster cluster = service.updateCluster(clusterRef, settings, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("cluster", clusterNode(cluster));+ return Response.ok(resp).build();+ }++ private Response handleUpdateClusterSettings(JsonNode req, String region) {+ String clusterRef = req.path("cluster").asText();+ List<ClusterSetting> settings = parseClusterSettings(req.path("settings"));+ EcsCluster cluster = service.updateClusterSettings(clusterRef, settings, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("cluster", clusterNode(cluster));+ return Response.ok(resp).build();+ }++ private Response handlePutClusterCapacityProviders(JsonNode req, String region) {+ String clusterRef = 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);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("cluster", clusterNode(cluster));+ return Response.ok(resp).build();+ }++ // ── Task Definitions ──────────────────────────────────────────────────────++ private Response handleRegisterTaskDefinition(JsonNode req, String region) {+ String family = req.path("family").asText();+ List<ContainerDefinition> containerDefs = parseContainerDefinitions(req.path("containerDefinitions"));+ NetworkMode networkMode = parseEnum(req, "networkMode", NetworkMode.class);+ String cpu = req.has("cpu") ? req.path("cpu").asText() : null;+ String memory = req.has("memory") ? req.path("memory").asText() : null;++ TaskDefinition td = service.registerTaskDefinition(family, containerDefs, networkMode, cpu, memory, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("taskDefinition", taskDefinitionNode(td));+ return Response.ok(resp).build();+ }++ private Response handleDescribeTaskDefinition(JsonNode req, String region) {+ String tdRef = req.path("taskDefinition").asText();+ TaskDefinition td = service.describeTaskDefinition(tdRef, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("taskDefinition", taskDefinitionNode(td));+ return Response.ok(resp).build();+ }++ private Response handleListTaskDefinitions(JsonNode req, String region) {+ String familyPrefix = req.has("familyPrefix") ? req.path("familyPrefix").asText() : null;+ String status = req.has("status") ? req.path("status").asText() : null;+ List<String> arns = service.listTaskDefinitions(familyPrefix, status);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ arns.forEach(arr::add);+ resp.set("taskDefinitionArns", arr);+ return Response.ok(resp).build();+ }++ private Response handleListTaskDefinitionFamilies(JsonNode req, String region) {+ String familyPrefix = req.has("familyPrefix") ? req.path("familyPrefix").asText() : null;+ List<String> families = service.listTaskDefinitionFamilies(familyPrefix);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ families.forEach(arr::add);+ resp.set("families", arr);+ return Response.ok(resp).build();+ }++ private Response handleDeregisterTaskDefinition(JsonNode req, String region) {+ String tdRef = req.path("taskDefinition").asText();+ TaskDefinition td = service.deregisterTaskDefinition(tdRef, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("taskDefinition", taskDefinitionNode(td));+ return Response.ok(resp).build();+ }++ private Response handleDeleteTaskDefinitions(JsonNode req, String region) {+ List<String> refs = jsonArrayToList(req.path("taskDefinitions"));+ List<TaskDefinition> deleted = service.deleteTaskDefinitions(refs, region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ deleted.forEach(td -> arr.add(taskDefinitionNode(td)));+ resp.set("taskDefinitions", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ // ── Tasks ─────────────────────────────────────────────────────────────────++ private Response handleRunTask(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String taskDefinition = req.path("taskDefinition").asText();+ int count = req.path("count").asInt(1);+ LaunchType launchType = parseEnum(req, "launchType", LaunchType.class);+ String group = req.has("group") ? req.path("group").asText() : null;+ String startedBy = req.has("startedBy") ? req.path("startedBy").asText() : null;++ List<EcsTask> launched = service.runTask(cluster, taskDefinition, count,+ launchType, group, startedBy, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ launched.forEach(t -> arr.add(taskNode(t)));+ resp.set("tasks", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ private Response handleStartTask(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<String> instances = jsonArrayToList(req.path("containerInstances"));+ String taskDefinition = req.path("taskDefinition").asText();+ String group = req.has("group") ? req.path("group").asText() : null;+ String startedBy = req.has("startedBy") ? req.path("startedBy").asText() : null;++ List<EcsTask> launched = service.startTask(cluster, instances, taskDefinition, group, startedBy, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ launched.forEach(t -> arr.add(taskNode(t)));+ resp.set("tasks", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ private Response handleStopTask(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String task = req.path("task").asText();+ String reason = req.has("reason") ? req.path("reason").asText() : null;++ EcsTask stopped = service.stopTask(cluster, task, reason, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("task", taskNode(stopped));+ return Response.ok(resp).build();+ }++ 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);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ found.forEach(t -> arr.add(taskNode(t)));+ resp.set("tasks", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ private Response handleListTasks(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String family = req.has("family") ? req.path("family").asText() : null;+ String desiredStatus = req.has("desiredStatus") ? req.path("desiredStatus").asText() : null;+ String serviceName = req.has("serviceName") ? req.path("serviceName").asText() : null;++ List<String> arns = service.listTasks(cluster, family, desiredStatus, serviceName, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ arns.forEach(arr::add);+ resp.set("taskArns", arr);+ return Response.ok(resp).build();+ }++ private Response handleUpdateTaskProtection(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<String> taskRefs = jsonArrayToList(req.path("tasks"));+ boolean protectionEnabled = req.path("protectionEnabled").asBoolean(false);+ Integer expiresInMinutes = req.has("expiresInMinutes") ? req.path("expiresInMinutes").asInt() : null;++ List<ProtectedTask> result = service.updateTaskProtection(cluster, taskRefs, protectionEnabled,+ expiresInMinutes, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ result.forEach(pt -> arr.add(protectedTaskNode(pt)));+ resp.set("protectedTasks", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ private Response handleGetTaskProtection(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<String> taskRefs = jsonArrayToList(req.path("tasks"));++ List<ProtectedTask> result = service.getTaskProtection(cluster, taskRefs, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ result.forEach(pt -> arr.add(protectedTaskNode(pt)));+ resp.set("protectedTasks", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ // ── Services ──────────────────────────────────────────────────────────────++ private Response handleCreateService(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String serviceName = req.path("serviceName").asText();+ String taskDefinition = req.path("taskDefinition").asText();+ int desiredCount = req.path("desiredCount").asInt(1);+ LaunchType launchType = parseEnum(req, "launchType", LaunchType.class);++ EcsServiceModel svc = service.createService(cluster, serviceName, taskDefinition,+ desiredCount, launchType, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("service", serviceNode(svc));+ return Response.ok(resp).build();+ }++ private Response handleUpdateService(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String serviceName = req.path("service").asText();+ String taskDefinition = req.has("taskDefinition") ? req.path("taskDefinition").asText() : null;+ Integer desiredCount = req.has("desiredCount") ? req.path("desiredCount").asInt() : null;++ EcsServiceModel svc = service.updateService(cluster, serviceName, taskDefinition, desiredCount, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("service", 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();++ EcsServiceModel svc = service.deleteService(cluster, serviceName, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("service", serviceNode(svc));+ return Response.ok(resp).build();+ }++ private Response handleDescribeServices(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<String> serviceIds = jsonArrayToList(req.path("services"));++ List<EcsServiceModel> found = service.describeServices(cluster, serviceIds, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ found.forEach(s -> arr.add(serviceNode(s)));+ resp.set("services", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ private Response handleListServices(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<String> arns = service.listServices(cluster, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ arns.forEach(arr::add);+ resp.set("serviceArns", arr);+ return Response.ok(resp).build();+ }++ private Response handleListServicesByNamespace(JsonNode req, String region) {+ String namespace = req.path("namespace").asText();+ List<String> arns = service.listServicesByNamespace(namespace, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ arns.forEach(arr::add);+ resp.set("serviceArns", arr);+ return Response.ok(resp).build();+ }++ // ── Tags ──────────────────────────────────────────────────────────────────++ private Response handleTagResource(JsonNode req, String region) {+ String resourceArn = req.path("resourceArn").asText();+ Map<String, String> tags = parseTagMap(req.path("tags"));+ service.tagResource(resourceArn, tags);+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleUntagResource(JsonNode req, String region) {+ String resourceArn = req.path("resourceArn").asText();+ List<String> tagKeys = jsonArrayToList(req.path("tagKeys"));+ service.untagResource(resourceArn, tagKeys);+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleListTagsForResource(JsonNode req, String region) {+ String resourceArn = req.path("resourceArn").asText();+ Map<String, String> tags = service.listTagsForResource(resourceArn);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("tags", tagsNode(tags));+ return Response.ok(resp).build();+ }++ // ── Account Settings ──────────────────────────────────────────────────────++ private Response handlePutAccountSetting(JsonNode req, String region) {+ String name = req.path("name").asText();+ String value = req.path("value").asText();+ var entry = service.putAccountSetting(name, value);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("setting", settingNode(entry.getKey(), entry.getValue()));+ return Response.ok(resp).build();+ }++ private Response handlePutAccountSettingDefault(JsonNode req, String region) {+ String name = req.path("name").asText();+ String value = req.path("value").asText();+ var entry = service.putAccountSettingDefault(name, value);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("setting", settingNode(entry.getKey(), entry.getValue()));+ return Response.ok(resp).build();+ }++ private Response handleDeleteAccountSetting(JsonNode req, String region) {+ String name = req.path("name").asText();+ var entry = service.deleteAccountSetting(name);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("setting", settingNode(entry.getKey(), entry.getValue()));+ return Response.ok(resp).build();+ }++ private Response handleListAccountSettings(JsonNode req, String region) {+ String filterName = req.has("name") ? req.path("name").asText() : null;+ String filterValue = req.has("value") ? req.path("value").asText() : null;+ var settings = service.listAccountSettings(filterName, filterValue);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ settings.forEach(e -> arr.add(settingNode(e.getKey(), e.getValue())));+ resp.set("settings", arr);+ return Response.ok(resp).build();+ }++ // ── Attributes ────────────────────────────────────────────────────────────++ private Response handlePutAttributes(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<Attribute> attrs = parseAttributes(req.path("attributes"));+ List<Attribute> stored = service.putAttributes(cluster, attrs, region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ stored.forEach(a -> arr.add(attributeNode(a)));+ resp.set("attributes", arr);+ return Response.ok(resp).build();+ }++ private Response handleDeleteAttributes(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<Attribute> attrs = parseAttributes(req.path("attributes"));+ List<Attribute> deleted = service.deleteAttributes(cluster, attrs, region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ deleted.forEach(a -> arr.add(attributeNode(a)));+ resp.set("attributes", arr);+ return Response.ok(resp).build();+ }++ private Response handleListAttributes(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String targetType = req.has("targetType") ? req.path("targetType").asText() : null;+ String attributeName = req.has("attributeName") ? req.path("attributeName").asText() : null;+ String attributeValue = req.has("attributeValue") ? req.path("attributeValue").asText() : null;+ List<Attribute> result = service.listAttributes(cluster, targetType, attributeName, attributeValue, region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ result.forEach(a -> arr.add(attributeNode(a)));+ resp.set("attributes", arr);+ return Response.ok(resp).build();+ }++ // ── Container Instances ───────────────────────────────────────────────────++ private Response handleRegisterContainerInstance(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String instanceIdentityDocument = req.has("instanceIdentityDocument")+ ? req.path("instanceIdentityDocument").asText() : null;+ List<Attribute> attrs = parseAttributes(req.path("attributes"));+ ContainerInstance instance = service.registerContainerInstance(cluster, instanceIdentityDocument, attrs, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("containerInstance", containerInstanceNode(instance));+ return Response.ok(resp).build();+ }++ private Response handleDeregisterContainerInstance(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String containerInstance = req.path("containerInstance").asText();+ boolean force = req.path("force").asBoolean(false);+ ContainerInstance instance = service.deregisterContainerInstance(cluster, containerInstance, force, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("containerInstance", containerInstanceNode(instance));+ return Response.ok(resp).build();+ }++ private Response handleDescribeContainerInstances(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<String> instanceRefs = jsonArrayToList(req.path("containerInstances"));+ List<ContainerInstance> found = service.describeContainerInstances(cluster, instanceRefs, region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ found.forEach(ci -> arr.add(containerInstanceNode(ci)));+ resp.set("containerInstances", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ private Response handleListContainerInstances(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String status = req.has("status") ? req.path("status").asText() : null;+ List<String> arns = service.listContainerInstances(cluster, status, region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ arns.forEach(arr::add);+ resp.set("containerInstanceArns", arr);+ return Response.ok(resp).build();+ }++ private Response handleUpdateContainerAgent(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String containerInstance = req.path("containerInstance").asText();+ ContainerInstance instance = service.updateContainerAgent(cluster, containerInstance, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("containerInstance", containerInstanceNode(instance));+ return Response.ok(resp).build();+ }++ private Response handleUpdateContainerInstancesState(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<String> instanceRefs = jsonArrayToList(req.path("containerInstances"));+ String status = req.path("status").asText();+ List<ContainerInstance> updated = service.updateContainerInstancesState(cluster, instanceRefs, status, region);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ updated.forEach(ci -> arr.add(containerInstanceNode(ci)));+ resp.set("containerInstances", arr);+ resp.set("failures", objectMapper.createArrayNode());+ return Response.ok(resp).build();+ }++ // ── Capacity Providers ────────────────────────────────────────────────────++ private Response handleCreateCapacityProvider(JsonNode req, String region) {+ String name = req.path("name").asText();+ Map<String, Object> asgProvider = parseRawObject(req.path("autoScalingGroupProvider"));+ Map<String, String> tags = parseTagMap(req.path("tags"));+ CapacityProvider cp = service.createCapacityProvider(name, asgProvider, tags, region);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("capacityProvider", capacityProviderNode(cp));+ return Response.ok(resp).build();+ }++ private Response handleUpdateCapacityProvider(JsonNode req, String region) {+ String name = req.path("name").asText();+ Map<String, Object> asgProvider = parseRawObject(req.path("autoScalingGroupProvider"));+ CapacityProvider cp = service.updateCapacityProvider(name, asgProvider);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("capacityProvider", capacityProviderNode(cp));+ return Response.ok(resp).build();+ }++ private Response handleDeleteCapacityProvider(JsonNode req, String region) {+ String nameOrArn = req.path("capacityProvider").asText();+ CapacityProvider cp = service.deleteCapacityProvider(nameOrArn);+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("capacityProvider", capacityProviderNode(cp));+ return Response.ok(resp).build();+ }++ private Response handleDescribeCapacityProviders(JsonNode req, String region) {+ List<String> providers = req.has("capacityProviders") ? jsonArrayToList(req.path("capacityProviders")) : null;+ List<CapacityProvider> found = service.describeCapacityProviders(providers);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ found.forEach(cp -> arr.add(capacityProviderNode(cp)));+ resp.set("capacityProviders", arr);+ return Response.ok(resp).build();+ }++ // ── Task Sets ─────────────────────────────────────────────────────────────++ private Response handleCreateTaskSet(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String service = req.path("service").asText();+ String taskDefinition = req.path("taskDefinition").asText();+ LaunchType launchType = parseEnum(req, "launchType", LaunchType.class);+ double scaleValue = req.path("scale").path("value").asDouble(100.0);+ String scaleUnit = req.path("scale").path("unit").asText("PERCENT");+ String externalId = req.has("externalId") ? req.path("externalId").asText() : null;++ TaskSet ts = this.service.createTaskSet(cluster, service, taskDefinition, launchType,+ scaleValue, scaleUnit, externalId, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("taskSet", taskSetNode(ts));+ return Response.ok(resp).build();+ }++ private Response handleUpdateTaskSet(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String svc = req.path("service").asText();+ String taskSet = req.path("taskSet").asText();+ double scaleValue = req.path("scale").path("value").asDouble(100.0);+ String scaleUnit = req.path("scale").path("unit").asText("PERCENT");++ TaskSet ts = service.updateTaskSet(cluster, svc, taskSet, scaleValue, scaleUnit, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("taskSet", taskSetNode(ts));+ return Response.ok(resp).build();+ }++ private Response handleDeleteTaskSet(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String svc = req.path("service").asText();+ String taskSet = req.path("taskSet").asText();+ boolean force = req.path("force").asBoolean(false);++ TaskSet ts = service.deleteTaskSet(cluster, svc, taskSet, force, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("taskSet", taskSetNode(ts));+ return Response.ok(resp).build();+ }++ private Response handleDescribeTaskSets(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String svc = req.path("service").asText();+ List<String> taskSetRefs = req.has("taskSets") ? jsonArrayToList(req.path("taskSets")) : null;++ List<TaskSet> found = service.describeTaskSets(cluster, svc, taskSetRefs, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ found.forEach(ts -> arr.add(taskSetNode(ts)));+ resp.set("taskSets", arr);+ return Response.ok(resp).build();+ }++ private Response handleUpdateServicePrimaryTaskSet(JsonNode req, String region) {+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ String svc = req.path("service").asText();+ String primaryTaskSet = req.path("primaryTaskSet").asText();++ TaskSet ts = service.updateServicePrimaryTaskSet(cluster, svc, primaryTaskSet, region);++ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("taskSet", taskSetNode(ts));+ return Response.ok(resp).build();+ }++ // ── Service Deployments & Revisions ───────────────────────────────────────++ private Response handleDescribeServiceDeployments(JsonNode req, String region) {+ List<String> arns = jsonArrayToList(req.path("serviceDeploymentArns"));+ List<ServiceDeployment> found = service.describeServiceDeployments(arns);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ found.forEach(d -> arr.add(serviceDeploymentNode(d)));+ resp.set("serviceDeployments", arr);+ return Response.ok(resp).build();+ }++ private Response handleListServiceDeployments(JsonNode req, String region) {+ String svc = req.path("service").asText();+ String cluster = req.has("cluster") ? req.path("cluster").asText() : null;+ List<String> statusFilter = req.has("status") ? jsonArrayToList(req.path("status")) : null;++ List<ServiceDeployment> deployments = service.listServiceDeploymentsDetailed(svc, cluster, statusFilter, region);++ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ deployments.forEach(d -> {+ ObjectNode brief = objectMapper.createObjectNode();+ brief.put("serviceDeploymentArn", d.getServiceDeploymentArn());+ brief.put("serviceArn", d.getServiceArn());+ brief.put("clusterArn", d.getClusterArn());+ brief.put("status", d.getStatus());+ if (d.getCreatedAt() != null) { brief.put("createdAt", d.getCreatedAt().toEpochMilli() / 1000.0); }+ if (d.getUpdatedAt() != null) { brief.put("finishedAt", d.getUpdatedAt().toEpochMilli() / 1000.0); }+ arr.add(brief);+ });+ resp.set("serviceDeployments", arr);+ return Response.ok(resp).build();+ }++ private Response handleDescribeServiceRevisions(JsonNode req, String region) {+ List<String> arns = jsonArrayToList(req.path("serviceRevisionArns"));+ List<ServiceRevision> found = service.describeServiceRevisions(arns);+ ObjectNode resp = objectMapper.createObjectNode();+ ArrayNode arr = objectMapper.createArrayNode();+ found.forEach(r -> arr.add(serviceRevisionNode(r)));+ resp.set("serviceRevisions", arr);+ return Response.ok(resp).build();+ }++ // ── Stubs ─────────────────────────────────────────────────────────────────++ private Response handleSubmitTaskStateChange(JsonNode req, String region) {+ String ack = service.submitTaskStateChange();+ ObjectNode resp = objectMapper.createObjectNode();+ resp.put("acknowledgment", ack);+ return Response.ok(resp).build();+ }++ private Response handleSubmitContainerStateChange(JsonNode req, String region) {+ String ack = service.submitContainerStateChange();+ ObjectNode resp = objectMapper.createObjectNode();+ resp.put("acknowledgment", ack);+ return Response.ok(resp).build();+ }++ private Response handleSubmitAttachmentStateChanges(JsonNode req, String region) {+ String ack = service.submitAttachmentStateChanges();+ ObjectNode resp = objectMapper.createObjectNode();+ resp.put("acknowledgment", ack);+ return Response.ok(resp).build();+ }++ private Response handleDiscoverPollEndpoint(JsonNode req, String region) {+ String baseUrl = service.getBaseUrl();+ ObjectNode resp = objectMapper.createObjectNode();+ resp.put("endpoint", baseUrl);+ resp.put("telemetryEndpoint", baseUrl);+ resp.put("serviceConnectEndpoint", baseUrl);+ return Response.ok(resp).build();+ }++ // ── JSON serialization ────────────────────────────────────────────────────++ private ObjectNode clusterNode(EcsCluster c) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("clusterArn", c.getClusterArn());+ n.put("clusterName", c.getClusterName());+ n.put("status", c.getStatus());+ n.put("registeredContainerInstancesCount", c.getRegisteredContainerInstancesCount());+ n.put("runningTasksCount", c.getRunningTasksCount());+ n.put("pendingTasksCount", c.getPendingTasksCount());+ n.put("activeServicesCount", c.getActiveServicesCount());+ if (c.getSettings() != null && !c.getSettings().isEmpty()) {+ ArrayNode settings = objectMapper.createArrayNode();+ c.getSettings().forEach(s -> {+ ObjectNode sn = objectMapper.createObjectNode();+ sn.put("name", s.name());+ sn.put("value", s.value());+ settings.add(sn);+ });+ n.set("settings", settings);+ }+ if (c.getCapacityProviders() != null) {+ ArrayNode cp = objectMapper.createArrayNode();+ c.getCapacityProviders().forEach(cp::add);+ n.set("capacityProviders", cp);+ }+ if (c.getTags() != null && !c.getTags().isEmpty()) {+ n.set("tags", tagsNode(c.getTags()));+ }+ return n;+ }++ private ObjectNode taskDefinitionNode(TaskDefinition td) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("taskDefinitionArn", td.getTaskDefinitionArn());+ n.put("family", td.getFamily());+ n.put("revision", td.getRevision());+ n.put("status", td.getStatus());+ if (td.getNetworkMode() != null) {+ n.put("networkMode", td.getNetworkMode().name());+ }+ if (td.getCpu() != null) { n.put("cpu", td.getCpu()); }+ if (td.getMemory() != null) { n.put("memory", td.getMemory()); }++ ArrayNode containers = objectMapper.createArrayNode();+ if (td.getContainerDefinitions() != null) {+ for (var def : td.getContainerDefinitions()) {+ containers.add(containerDefinitionNode(def));+ }+ }+ n.set("containerDefinitions", containers);+ if (td.getTags() != null && !td.getTags().isEmpty()) {+ n.set("tags", tagsNode(td.getTags()));+ }+ return n;+ }++ private ObjectNode containerDefinitionNode(ContainerDefinition def) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("name", def.getName());+ n.put("image", def.getImage());+ 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.getPortMappings() != null && !def.getPortMappings().isEmpty()) {+ ArrayNode pms = objectMapper.createArrayNode();+ for (PortMapping pm : def.getPortMappings()) {+ ObjectNode pmNode = objectMapper.createObjectNode();+ pmNode.put("containerPort", pm.containerPort());+ pmNode.put("hostPort", pm.hostPort());+ pmNode.put("protocol", pm.protocol());+ pms.add(pmNode);+ }+ n.set("portMappings", pms);+ }++ if (def.getEnvironment() != null && !def.getEnvironment().isEmpty()) {+ ArrayNode envArr = objectMapper.createArrayNode();+ for (KeyValuePair kv : def.getEnvironment()) {+ ObjectNode kvNode = objectMapper.createObjectNode();+ kvNode.put("name", kv.name());+ kvNode.put("value", kv.value());+ envArr.add(kvNode);+ }+ n.set("environment", envArr);+ }++ return n;+ }++ private ObjectNode taskNode(EcsTask t) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("taskArn", t.getTaskArn());+ n.put("clusterArn", t.getClusterArn());+ 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()); }+ if (t.getCpu() != null) { n.put("cpu", t.getCpu()); }+ if (t.getMemory() != null) { n.put("memory", t.getMemory()); }+ 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.getStoppedReason() != null) { n.put("stoppedReason", t.getStoppedReason()); }++ ArrayNode containers = objectMapper.createArrayNode();+ if (t.getContainers() != null) {+ for (var c : t.getContainers()) {+ ObjectNode cn = objectMapper.createObjectNode();+ cn.put("containerArn", c.getContainerArn());+ cn.put("taskArn", c.getTaskArn());+ cn.put("name", c.getName());+ cn.put("image", c.getImage());+ cn.put("lastStatus", c.getLastStatus());+ if (c.getExitCode() != null) { cn.put("exitCode", c.getExitCode()); }+ if (c.getReason() != null) { cn.put("reason", c.getReason()); }++ ArrayNode bindings = objectMapper.createArrayNode();+ if (c.getNetworkBindings() != null) {+ for (NetworkBinding nb : c.getNetworkBindings()) {+ ObjectNode bn = objectMapper.createObjectNode();+ bn.put("bindIP", nb.bindIP());+ bn.put("containerPort", nb.containerPort());+ bn.put("hostPort", nb.hostPort());+ bn.put("protocol", nb.protocol());+ bindings.add(bn);+ }+ }+ cn.set("networkBindings", bindings);+ containers.add(cn);+ }+ }+ n.set("containers", containers);+ if (t.getTags() != null && !t.getTags().isEmpty()) {+ n.set("tags", tagsNode(t.getTags()));+ }+ return n;+ }++ private ObjectNode serviceNode(EcsServiceModel s) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("serviceArn", s.getServiceArn());+ n.put("serviceName", s.getServiceName());+ n.put("clusterArn", s.getClusterArn());+ n.put("taskDefinition", s.getTaskDefinition());+ n.put("desiredCount", s.getDesiredCount());+ 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.getNamespace() != null) { n.put("namespace", s.getNamespace()); }+ if (s.getTags() != null && !s.getTags().isEmpty()) {+ n.set("tags", tagsNode(s.getTags()));+ }+ return n;+ }++ private ObjectNode containerInstanceNode(ContainerInstance ci) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("containerInstanceArn", ci.getContainerInstanceArn());+ n.put("ec2InstanceId", ci.getEc2InstanceId());+ n.put("status", ci.getStatus());+ n.put("runningTasksCount", ci.getRunningTasksCount());+ n.put("pendingTasksCount", ci.getPendingTasksCount());+ n.put("agentVersion", ci.getAgentVersion());+ n.put("agentConnected", ci.isAgentConnected());+ if (ci.getAttributes() != null && !ci.getAttributes().isEmpty()) {+ ArrayNode attrs = objectMapper.createArrayNode();+ ci.getAttributes().forEach(a -> attrs.add(attributeNode(a)));+ n.set("attributes", attrs);+ }+ if (ci.getTags() != null && !ci.getTags().isEmpty()) {+ n.set("tags", tagsNode(ci.getTags()));+ }+ return n;+ }++ private ObjectNode capacityProviderNode(CapacityProvider cp) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("name", cp.getName());+ n.put("status", cp.getStatus());+ if (cp.getCapacityProviderArn() != null) { n.put("capacityProviderArn", cp.getCapacityProviderArn()); }+ if (cp.getTags() != null && !cp.getTags().isEmpty()) {+ n.set("tags", tagsNode(cp.getTags()));+ }+ return n;+ }++ private ObjectNode taskSetNode(TaskSet ts) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("id", ts.getId());+ n.put("taskSetArn", ts.getTaskSetArn());+ n.put("serviceArn", ts.getServiceArn());+ n.put("clusterArn", ts.getClusterArn());+ n.put("taskDefinition", ts.getTaskDefinition());+ n.put("status", ts.getStatus());+ n.put("computedDesiredCount", ts.getComputedDesiredCount());+ n.put("pendingCount", ts.getPendingCount());+ n.put("runningCount", ts.getRunningCount());+ n.put("stabilityStatus", ts.getStabilityStatus());+ if (ts.getLaunchType() != null) { n.put("launchType", ts.getLaunchType().name()); }+ if (ts.getExternalId() != null) { n.put("externalId", ts.getExternalId()); }+ ObjectNode scale = objectMapper.createObjectNode();+ scale.put("value", ts.getScaleValue());+ scale.put("unit", ts.getScaleUnit());+ n.set("scale", scale);+ if (ts.getCreatedAt() != null) { n.put("createdAt", ts.getCreatedAt().toEpochMilli() / 1000.0); }+ if (ts.getUpdatedAt() != null) { n.put("updatedAt", ts.getUpdatedAt().toEpochMilli() / 1000.0); }+ if (ts.getTags() != null && !ts.getTags().isEmpty()) {+ n.set("tags", tagsNode(ts.getTags()));+ }+ return n;+ }++ private ObjectNode serviceDeploymentNode(ServiceDeployment d) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("serviceDeploymentArn", d.getServiceDeploymentArn());+ n.put("serviceArn", d.getServiceArn());+ n.put("clusterArn", d.getClusterArn());+ n.put("taskDefinition", d.getTaskDefinition());+ n.put("status", d.getStatus());+ if (d.getCreatedAt() != null) { n.put("createdAt", d.getCreatedAt().toEpochMilli() / 1000.0); }+ if (d.getUpdatedAt() != null) { n.put("updatedAt", d.getUpdatedAt().toEpochMilli() / 1000.0); }+ return n;+ }++ private ObjectNode serviceRevisionNode(ServiceRevision r) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("serviceRevisionArn", r.getServiceRevisionArn());+ n.put("serviceArn", r.getServiceArn());+ n.put("clusterArn", r.getClusterArn());+ n.put("taskDefinition", r.getTaskDefinition());+ if (r.getLaunchType() != null) { n.put("launchType", r.getLaunchType().name()); }+ if (r.getCreatedAt() != null) { n.put("createdAt", r.getCreatedAt().toEpochMilli() / 1000.0); }+ return n;+ }++ private 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);+ }+ return n;+ }++ private ObjectNode attributeNode(Attribute a) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("name", a.name());+ if (a.value() != null) { n.put("value", a.value()); }+ if (a.targetType() != null) { n.put("targetType", a.targetType()); }+ if (a.targetId() != null) { n.put("targetId", a.targetId()); }+ return n;+ }++ private ObjectNode settingNode(String name, String value) {+ ObjectNode n = objectMapper.createObjectNode();+ n.put("name", name);+ n.put("value", value);+ return n;+ }++ private ArrayNode tagsNode(Map<String, String> tags) {+ ArrayNode arr = objectMapper.createArrayNode();+ tags.forEach((k, v) -> {+ ObjectNode tag = objectMapper.createObjectNode();+ tag.put("key", k);+ tag.put("value", v);+ arr.add(tag);+ });+ return arr;+ }++ // ── Parsing helpers ───────────────────────────────────────────────────────++ private List<ContainerDefinition> parseContainerDefinitions(JsonNode node) {+ List<ContainerDefinition> result = new ArrayList<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ ContainerDefinition def = new ContainerDefinition();+ def.setName(item.path("name").asText());+ def.setImage(item.path("image").asText());+ def.setEssential(item.path("essential").asBoolean(true));+ if (item.has("cpu")) { def.setCpu(item.path("cpu").asInt()); }+ if (item.has("memory")) { def.setMemory(item.path("memory").asInt()); }+ if (item.has("memoryReservation")) { def.setMemoryReservation(item.path("memoryReservation").asInt()); }++ def.setPortMappings(parsePortMappings(item.path("portMappings")));+ def.setEnvironment(parseKeyValuePairs(item.path("environment")));++ 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);+ }+ 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);+ }++ result.add(def);+ }+ return result;+ }++ private List<PortMapping> parsePortMappings(JsonNode node) {+ List<PortMapping> result = new ArrayList<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ 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));+ }+ return result;+ }++ private List<KeyValuePair> parseKeyValuePairs(JsonNode node) {+ List<KeyValuePair> result = new ArrayList<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ result.add(new KeyValuePair(item.path("name").asText(), item.path("value").asText()));+ }+ return result;+ }++ private List<ClusterSetting> parseClusterSettings(JsonNode node) {+ List<ClusterSetting> result = new ArrayList<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ result.add(new ClusterSetting(item.path("name").asText(), item.path("value").asText()));+ }+ return result;+ }++ private List<Attribute> parseAttributes(JsonNode node) {+ List<Attribute> result = new ArrayList<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ result.add(new Attribute(+ item.path("name").asText(),+ item.has("value") ? item.path("value").asText() : null,+ item.has("targetType") ? item.path("targetType").asText() : null,+ item.has("targetId") ? item.path("targetId").asText() : null+ ));+ }+ return result;+ }++ private Map<String, String> parseTagMap(JsonNode node) {+ Map<String, String> result = new HashMap<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ result.put(item.path("key").asText(), item.path("value").asText());+ }+ return result;+ }++ private Map<String, Object> parseRawObject(JsonNode node) {+ if (node == null || node.isMissingNode()) {+ return null;+ }+ return objectMapper.convertValue(node, Map.class);+ }++ private List<Map<String, Object>> parseRawObjectList(JsonNode node) {+ List<Map<String, Object>> result = new ArrayList<>();+ if (!node.isArray()) {+ return result;+ }+ for (JsonNode item : node) {+ result.add(objectMapper.convertValue(item, Map.class));+ }+ return result;+ }++ private List<String> jsonArrayToList(JsonNode node) {+ List<String> result = new ArrayList<>();+ if (node.isArray()) {+ node.forEach(n -> result.add(n.asText()));+ }+ return result;+ }++ private <T extends Enum<T>> T parseEnum(JsonNode req, String field, Class<T> enumClass) {+ if (!req.has(field)) {+ return null;+ }+ String val = req.path(field).asText();+ try {+ return Enum.valueOf(enumClass, val);+ } catch (IllegalArgumentException e) {+ return null;+ }+ }+}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.javanew file mode 100644index 0000000000..e06d72ec83--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.java@@ -0,0 +1,1181 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+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.ClusterSetting;+import io.github.hectorvent.floci.services.ecs.model.ContainerDefinition;+import io.github.hectorvent.floci.services.ecs.model.ContainerInstance;+import io.github.hectorvent.floci.services.ecs.model.EcsCluster;+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.LaunchType;+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.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.TaskSet;+import io.github.hectorvent.floci.services.ecs.model.TaskStatus;+import jakarta.annotation.PostConstruct;+import jakarta.annotation.PreDestroy;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.time.Instant;+import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.UUID;+import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.Executors;+import java.util.concurrent.ScheduledExecutorService;+import java.util.concurrent.TimeUnit;+import java.util.stream.Stream;++@ApplicationScoped+public class EcsService {++ private static final Logger LOG = Logger.getLogger(EcsService.class);+ private static final String DEFAULT_CLUSTER = "default";++ private final RegionResolver regionResolver;+ private final EcsContainerManager containerManager;+ private final boolean dockerMode;+ private final String baseUrl;+ private final ScheduledExecutorService reconciler = Executors.newSingleThreadScheduledExecutor(+ r -> { Thread t = new Thread(r, "ecs-reconciler"); t.setDaemon(true); return t; });++ // region::clusterName → EcsCluster+ private final Map<String, EcsCluster> clusters = new ConcurrentHashMap<>();+ // family:revision → TaskDefinition+ private final Map<String, TaskDefinition> taskDefinitions = new ConcurrentHashMap<>();+ // family → latest revision number+ private final Map<String, Integer> latestRevisions = new ConcurrentHashMap<>();+ // taskArn → EcsTask+ private final Map<String, EcsTask> tasks = new ConcurrentHashMap<>();+ // taskArn → EcsTaskHandle (running containers)+ private final Map<String, EcsTaskHandle> taskHandles = new ConcurrentHashMap<>();+ // region::clusterName/serviceName → EcsServiceModel+ private final Map<String, EcsServiceModel> services = new ConcurrentHashMap<>();+ // region::clusterArn/instanceArn → ContainerInstance+ private final Map<String, ContainerInstance> containerInstances = new ConcurrentHashMap<>();+ // name → CapacityProvider (excludes built-ins FARGATE, FARGATE_SPOT)+ private final Map<String, CapacityProvider> capacityProviders = new ConcurrentHashMap<>();+ // taskSetArn → TaskSet+ private final Map<String, TaskSet> taskSets = new ConcurrentHashMap<>();+ // serviceDeploymentArn → ServiceDeployment+ private final Map<String, ServiceDeployment> serviceDeployments = new ConcurrentHashMap<>();+ // serviceRevisionArn → ServiceRevision+ private final Map<String, ServiceRevision> serviceRevisions = new ConcurrentHashMap<>();+ // targetArn → List<Attribute>+ private final Map<String, List<Attribute>> attributes = new ConcurrentHashMap<>();+ // name → value (account-level settings)+ private final Map<String, String> accountSettings = new ConcurrentHashMap<>();++ @Inject+ public EcsService(RegionResolver regionResolver, EcsContainerManager containerManager,+ EmulatorConfig config) {+ this(regionResolver, containerManager, !config.services().ecs().mock(),+ config.effectiveBaseUrl());+ }++ EcsService(RegionResolver regionResolver, EcsContainerManager containerManager) {+ this(regionResolver, containerManager, false, "http://localhost:4566");+ }++ EcsService(RegionResolver regionResolver, EcsContainerManager containerManager, boolean dockerMode,+ String baseUrl) {+ this.regionResolver = regionResolver;+ this.containerManager = containerManager;+ this.dockerMode = dockerMode;+ this.baseUrl = baseUrl;+ }++ @PostConstruct+ void init() {+ reconciler.scheduleAtFixedRate(this::reconcileServices, 5, 5, TimeUnit.SECONDS);+ }++ @PreDestroy+ void shutdown() {+ reconciler.shutdownNow();+ }++ // ── Clusters ─────────────────────────────────────────────────────────────++ public EcsCluster createCluster(String clusterName, String region) {+ String name = (clusterName == null || clusterName.isBlank()) ? DEFAULT_CLUSTER : clusterName;+ String key = clusterKey(region, name);+ if (clusters.containsKey(key)) {+ return clusters.get(key);+ }+ EcsCluster cluster = new EcsCluster();+ cluster.setClusterName(name);+ cluster.setClusterArn(regionResolver.buildArn("ecs", region, "cluster/" + name));+ cluster.setStatus("ACTIVE");+ clusters.put(key, cluster);+ LOG.infov("Created ECS cluster: {0} in {1}", name, region);+ return cluster;+ }++ public List<EcsCluster> describeClusters(List<String> clusterIds, String region) {+ if (clusterIds == null || clusterIds.isEmpty()) {+ return List.of(getOrCreateDefaultCluster(region));+ }+ List<EcsCluster> result = new ArrayList<>();+ for (String id : clusterIds) {+ EcsCluster cluster = resolveCluster(id, region);+ if (cluster != null) {+ result.add(cluster);+ }+ }+ return result;+ }++ public List<String> listClusters(String region) {+ String prefix = region + "::";+ return clusters.entrySet().stream()+ .filter(e -> e.getKey().startsWith(prefix))+ .map(e -> e.getValue().getClusterArn())+ .toList();+ }++ public EcsCluster deleteCluster(String clusterId, String region) {+ EcsCluster cluster = resolveClusterOrThrow(clusterId, region);+ long runningTasks = tasks.values().stream()+ .filter(t -> t.getClusterArn().equals(cluster.getClusterArn()))+ .filter(t -> !TaskStatus.STOPPED.name().equals(t.getLastStatus()))+ .count();+ if (runningTasks > 0) {+ throw new AwsException("ClusterContainsTasksException",+ "The cluster cannot be deleted because it contains running tasks.", 400);+ }+ clusters.remove(clusterKey(region, cluster.getClusterName()));+ cluster.setStatus("INACTIVE");+ return cluster;+ }++ public EcsCluster updateCluster(String clusterRef, List<ClusterSetting> settings, String region) {+ EcsCluster cluster = resolveClusterOrThrow(clusterRef, region);+ if (settings != null) {+ cluster.setSettings(settings);+ }+ return cluster;+ }++ public EcsCluster updateClusterSettings(String clusterRef, List<ClusterSetting> settings, String region) {+ EcsCluster cluster = resolveClusterOrThrow(clusterRef, region);+ cluster.setSettings(settings);+ return cluster;+ }++ public EcsCluster putClusterCapacityProviders(String clusterRef, List<String> providers,+ List<Map<String, Object>> defaultStrategy, String region) {+ EcsCluster cluster = resolveClusterOrThrow(clusterRef, region);+ cluster.setCapacityProviders(providers);+ cluster.setDefaultCapacityProviderStrategy(defaultStrategy);+ return cluster;+ }++ // ── Task Definitions ──────────────────────────────────────────────────────++ public TaskDefinition registerTaskDefinition(String family, List<ContainerDefinition> containerDefs,+ NetworkMode networkMode, String cpu, String memory,+ String region) {+ int revision = latestRevisions.merge(family, 1, Integer::sum);++ TaskDefinition td = new TaskDefinition();+ td.setFamily(family);+ td.setRevision(revision);+ td.setStatus("ACTIVE");+ td.setNetworkMode(networkMode != null ? networkMode : NetworkMode.bridge);+ td.setCpu(cpu);+ td.setMemory(memory);+ td.setContainerDefinitions(containerDefs != null ? containerDefs : List.of());+ td.setTaskDefinitionArn(regionResolver.buildArn("ecs", region,+ "task-definition/" + family + ":" + revision));++ taskDefinitions.put(family + ":" + revision, td);+ LOG.infov("Registered task definition: {0}:{1}", family, revision);+ return td;+ }++ public TaskDefinition describeTaskDefinition(String taskDefinitionRef, String region) {+ return resolveTaskDefinitionOrThrow(taskDefinitionRef, region);+ }++ public List<String> listTaskDefinitions(String familyPrefix, String status) {+ return taskDefinitions.values().stream()+ .filter(td -> familyPrefix == null || td.getFamily().startsWith(familyPrefix))+ .filter(td -> status == null || status.equals(td.getStatus()))+ .map(TaskDefinition::getTaskDefinitionArn)+ .sorted()+ .toList();+ }++ public List<String> listTaskDefinitionFamilies(String familyPrefix) {+ return latestRevisions.keySet().stream()+ .filter(f -> familyPrefix == null || f.startsWith(familyPrefix))+ .sorted()+ .toList();+ }++ public TaskDefinition deregisterTaskDefinition(String taskDefinitionRef, String region) {+ TaskDefinition td = resolveTaskDefinitionOrThrow(taskDefinitionRef, region);+ td.setStatus("INACTIVE");+ return td;+ }++ public List<TaskDefinition> deleteTaskDefinitions(List<String> taskDefinitionRefs, String region) {+ List<TaskDefinition> deleted = new ArrayList<>();+ for (String ref : taskDefinitionRefs) {+ TaskDefinition td = resolveTaskDefinitionOrThrow(ref, region);+ if (!"INACTIVE".equals(td.getStatus())) {+ throw new AwsException("InvalidParameterException",+ "Task definition " + ref + " must be INACTIVE before deletion.", 400);+ }+ taskDefinitions.remove(td.getFamily() + ":" + td.getRevision());+ deleted.add(td);+ }+ return deleted;+ }++ // ── Tasks ─────────────────────────────────────────────────────────────────++ public List<EcsTask> runTask(String clusterRef, String taskDefinitionRef, int count,+ LaunchType launchType, String group, String startedBy, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ TaskDefinition taskDef = resolveTaskDefinitionOrThrow(taskDefinitionRef, region);+ return launchTasks(cluster, taskDef, count, launchType, group, startedBy, null, region);+ }++ public List<EcsTask> startTask(String clusterRef, List<String> containerInstanceRefs,+ String taskDefinitionRef, String group, String startedBy, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ TaskDefinition taskDef = resolveTaskDefinitionOrThrow(taskDefinitionRef, region);+ List<EcsTask> result = new ArrayList<>();+ for (String instanceRef : containerInstanceRefs) {+ ContainerInstance instance = resolveContainerInstanceOrThrow(cluster.getClusterArn(), instanceRef);+ List<EcsTask> launched = launchTasks(cluster, taskDef, 1, LaunchType.EC2,+ group, startedBy, instance.getContainerInstanceArn(), region);+ result.addAll(launched);+ }+ return result;+ }++ private List<EcsTask> launchTasks(EcsCluster cluster, TaskDefinition taskDef, int count,+ LaunchType launchType, String group, String startedBy,+ String containerInstanceArn, String region) {+ 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);++ 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.setLastStatus(TaskStatus.PENDING.name());+ task.setDesiredStatus(TaskStatus.RUNNING.name());+ task.setCpu(taskDef.getCpu());+ task.setMemory(taskDef.getMemory());+ task.setCreatedAt(Instant.now());+ task.setContainers(List.of());+ task.setContainerInstanceArn(containerInstanceArn);++ tasks.put(taskArn, task);++ if (dockerMode) {+ try {+ EcsTaskHandle handle = containerManager.startTask(task, taskDef, region);+ taskHandles.put(taskArn, handle);+ cluster.setRunningTasksCount(cluster.getRunningTasksCount() + 1);+ LOG.infov("Started ECS task (docker): {0}", taskArn);+ } catch (Exception e) {+ LOG.errorv("Failed to start ECS task {0}: {1}", taskArn, e.getMessage());+ task.setLastStatus(TaskStatus.STOPPED.name());+ task.setDesiredStatus(TaskStatus.STOPPED.name());+ task.setStoppedReason("Failed to start: " + e.getMessage());+ task.setStoppedAt(Instant.now());+ }+ } else {+ task.setLastStatus(TaskStatus.RUNNING.name());+ task.setStartedAt(Instant.now());+ cluster.setRunningTasksCount(cluster.getRunningTasksCount() + 1);+ LOG.infov("Started ECS task (mock): {0}", taskArn);+ }++ launched.add(task);+ }+ return launched;+ }++ public EcsTask stopTask(String clusterRef, String taskRef, String reason, String region) {+ EcsTask task = resolveTaskOrThrow(taskRef, region);+ task.setDesiredStatus(TaskStatus.STOPPED.name());+ task.setLastStatus(TaskStatus.STOPPING.name());+ task.setStoppedReason(reason != null ? reason : "Stopped by user");++ if (dockerMode) {+ EcsTaskHandle handle = taskHandles.remove(task.getTaskArn());+ containerManager.stopTask(handle);+ }++ task.setLastStatus(TaskStatus.STOPPED.name());+ task.setStoppedAt(Instant.now());+ if (task.getContainers() != null) {+ task.getContainers().forEach(c -> c.setLastStatus("STOPPED"));+ }++ EcsCluster cluster = resolveClusterByArn(task.getClusterArn());+ if (cluster != null && cluster.getRunningTasksCount() > 0) {+ cluster.setRunningTasksCount(cluster.getRunningTasksCount() - 1);+ }++ LOG.infov("Stopped ECS task: {0}", task.getTaskArn());+ return task;+ }++ public List<EcsTask> describeTasks(String clusterRef, List<String> taskRefs, String region) {+ List<EcsTask> result = new ArrayList<>();+ for (String ref : taskRefs) {+ EcsTask task = resolveTask(ref, region);+ if (task != null) {+ result.add(task);+ }+ }+ return result;+ }++ public List<String> listTasks(String clusterRef, String family, String desiredStatus,+ String serviceName, String region) {+ String clusterArn = clusterRef != null+ ? resolveClusterOrDefault(clusterRef, region).getClusterArn()+ : null;++ return tasks.values().stream()+ .filter(t -> clusterArn == null || t.getClusterArn().equals(clusterArn))+ .filter(t -> family == null || t.getTaskDefinitionArn().contains("/" + family + ":"))+ .filter(t -> desiredStatus == null || desiredStatus.equals(t.getDesiredStatus()))+ .filter(t -> serviceName == null || serviceName.equals(t.getGroup()))+ .map(EcsTask::getTaskArn)+ .toList();+ }++ // ── Task Protection ───────────────────────────────────────────────────────++ public List<ProtectedTask> updateTaskProtection(String clusterRef, List<String> taskRefs,+ boolean protectionEnabled, Integer expiresInMinutes,+ String region) {+ List<ProtectedTask> result = new ArrayList<>();+ for (String ref : taskRefs) {+ EcsTask task = resolveTaskOrThrow(ref, region);+ task.setProtectionEnabled(protectionEnabled);+ Instant expiration = null;+ if (protectionEnabled && expiresInMinutes != null) {+ expiration = Instant.now().plusSeconds(expiresInMinutes * 60L);+ task.setProtectedUntil(expiration);+ } else {+ task.setProtectedUntil(null);+ }+ result.add(new ProtectedTask(task.getTaskArn(), protectionEnabled, expiration));+ }+ return result;+ }++ public List<ProtectedTask> getTaskProtection(String clusterRef, List<String> taskRefs, String region) {+ List<ProtectedTask> result = new ArrayList<>();+ for (String ref : taskRefs) {+ EcsTask task = resolveTaskOrThrow(ref, region);+ result.add(new ProtectedTask(task.getTaskArn(), task.isProtectionEnabled(), task.getProtectedUntil()));+ }+ return result;+ }++ // ── Services ──────────────────────────────────────────────────────────────++ public EcsServiceModel createService(String clusterRef, String serviceName, String taskDefinition,+ int desiredCount, LaunchType launchType, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ resolveTaskDefinitionOrThrow(taskDefinition, region);++ String key = serviceKey(region, cluster.getClusterName(), serviceName);+ if (services.containsKey(key)) {+ throw new AwsException("InvalidParameterException",+ "Creation of service was not idempotent.", 400);+ }++ EcsServiceModel svc = new EcsServiceModel();+ svc.setServiceArn(regionResolver.buildArn("ecs", region,+ "service/" + cluster.getClusterName() + "/" + serviceName));+ svc.setServiceName(serviceName);+ svc.setClusterArn(cluster.getClusterArn());+ svc.setTaskDefinition(taskDefinition);+ svc.setLaunchType(launchType != null ? launchType : LaunchType.FARGATE);+ svc.setDesiredCount(desiredCount);+ svc.setStatus("ACTIVE");+ svc.setCreatedAt(Instant.now());++ services.put(key, svc);+ cluster.setActiveServicesCount(cluster.getActiveServicesCount() + 1);+ recordServiceDeployment(svc, taskDefinition, region);+ LOG.infov("Created ECS service: {0} in cluster {1}", serviceName, cluster.getClusterName());+ return svc;+ }++ public EcsServiceModel updateService(String clusterRef, String serviceName, String taskDefinition,+ Integer desiredCount, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ String key = serviceKey(region, cluster.getClusterName(), serviceName);+ EcsServiceModel svc = services.get(key);+ if (svc == null) {+ throw new AwsException("ServiceNotFoundException", "Service " + serviceName + " not found.", 404);+ }+ if (desiredCount != null) {+ svc.setDesiredCount(desiredCount);+ }+ if (taskDefinition != null) {+ resolveTaskDefinitionOrThrow(taskDefinition, region);+ svc.setTaskDefinition(taskDefinition);+ recordServiceDeployment(svc, taskDefinition, region);+ }+ return svc;+ }++ public EcsServiceModel deleteService(String clusterRef, String serviceName, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ String key = serviceKey(region, cluster.getClusterName(), serviceName);+ EcsServiceModel svc = services.remove(key);+ if (svc == null) {+ throw new AwsException("ServiceNotFoundException", "Service " + serviceName + " not found.", 404);+ }+ svc.setStatus("INACTIVE");+ svc.setDesiredCount(0);+ cluster.setActiveServicesCount(Math.max(0, cluster.getActiveServicesCount() - 1));+ return svc;+ }++ public List<EcsServiceModel> describeServices(String clusterRef, List<String> serviceIds, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ List<EcsServiceModel> result = new ArrayList<>();+ for (String id : serviceIds) {+ EcsServiceModel svc = resolveService(cluster.getClusterName(), id, region);+ if (svc != null) {+ result.add(svc);+ }+ }+ return result;+ }++ public List<String> listServices(String clusterRef, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ String prefix = serviceKeyPrefix(region, cluster.getClusterName());+ return services.entrySet().stream()+ .filter(e -> e.getKey().startsWith(prefix))+ .map(e -> e.getValue().getServiceArn())+ .toList();+ }++ public List<String> listServicesByNamespace(String namespace, String region) {+ return services.values().stream()+ .filter(s -> namespace.equals(s.getNamespace()))+ .map(EcsServiceModel::getServiceArn)+ .toList();+ }++ // ── Tags ──────────────────────────────────────────────────────────────────++ public void tagResource(String resourceArn, Map<String, String> tags) {+ Object resource = findByArn(resourceArn);+ if (resource == null) {+ throw new AwsException("InvalidParameterException", "Resource not found: " + resourceArn, 400);+ }+ mergeTagsOnResource(resource, tags);+ }++ public void untagResource(String resourceArn, List<String> tagKeys) {+ Object resource = findByArn(resourceArn);+ if (resource == null) {+ throw new AwsException("InvalidParameterException", "Resource not found: " + resourceArn, 400);+ }+ removeTagsFromResource(resource, tagKeys);+ }++ public Map<String, String> listTagsForResource(String resourceArn) {+ Object resource = findByArn(resourceArn);+ if (resource == null) {+ throw new AwsException("InvalidParameterException", "Resource not found: " + resourceArn, 400);+ }+ return getTagsFromResource(resource);+ }++ private Object findByArn(String arn) {+ for (EcsCluster c : clusters.values()) {+ if (arn.equals(c.getClusterArn())) { return c; }+ }+ for (TaskDefinition td : taskDefinitions.values()) {+ if (arn.equals(td.getTaskDefinitionArn())) { return td; }+ }+ for (EcsTask t : tasks.values()) {+ if (arn.equals(t.getTaskArn())) { return t; }+ }+ for (EcsServiceModel s : services.values()) {+ if (arn.equals(s.getServiceArn())) { return s; }+ }+ for (ContainerInstance ci : containerInstances.values()) {+ if (arn.equals(ci.getContainerInstanceArn())) { return ci; }+ }+ for (CapacityProvider cp : capacityProviders.values()) {+ if (arn.equals(cp.getCapacityProviderArn())) { return cp; }+ }+ return null;+ }++ private void mergeTagsOnResource(Object resource, Map<String, String> tags) {+ if (resource instanceof EcsCluster c) { c.getTags().putAll(tags); }+ else if (resource instanceof TaskDefinition td) { td.getTags().putAll(tags); }+ else if (resource instanceof EcsTask t) { t.getTags().putAll(tags); }+ else if (resource instanceof EcsServiceModel s) { s.getTags().putAll(tags); }+ else if (resource instanceof ContainerInstance ci) { ci.getTags().putAll(tags); }+ else if (resource instanceof CapacityProvider cp) { cp.getTags().putAll(tags); }+ }++ private void removeTagsFromResource(Object resource, List<String> tagKeys) {+ if (resource instanceof EcsCluster c) { tagKeys.forEach(c.getTags()::remove); }+ else if (resource instanceof TaskDefinition td) { tagKeys.forEach(td.getTags()::remove); }+ else if (resource instanceof EcsTask t) { tagKeys.forEach(t.getTags()::remove); }+ else if (resource instanceof EcsServiceModel s) { tagKeys.forEach(s.getTags()::remove); }+ else if (resource instanceof ContainerInstance ci) { tagKeys.forEach(ci.getTags()::remove); }+ else if (resource instanceof CapacityProvider cp) { tagKeys.forEach(cp.getTags()::remove); }+ }++ private Map<String, String> getTagsFromResource(Object resource) {+ return switch (resource) {+ case EcsCluster c -> c.getTags();+ case TaskDefinition td -> td.getTags();+ case EcsTask t -> t.getTags();+ case EcsServiceModel s -> s.getTags();+ case ContainerInstance ci -> ci.getTags();+ case CapacityProvider cp -> cp.getTags();+ default -> Map.of();+ };+ }++ // ── Account Settings ──────────────────────────────────────────────────────++ public Map.Entry<String, String> putAccountSetting(String name, String value) {+ accountSettings.put(name, value);+ return Map.entry(name, value);+ }++ public Map.Entry<String, String> putAccountSettingDefault(String name, String value) {+ accountSettings.put(name, value);+ return Map.entry(name, value);+ }++ public Map.Entry<String, String> deleteAccountSetting(String name) {+ String removed = accountSettings.remove(name);+ return Map.entry(name, removed != null ? removed : "");+ }++ public List<Map.Entry<String, String>> listAccountSettings(String filterName, String filterValue) {+ return accountSettings.entrySet().stream()+ .filter(e -> filterName == null || filterName.equals(e.getKey()))+ .filter(e -> filterValue == null || filterValue.equals(e.getValue()))+ .toList();+ }++ // ── Attributes ────────────────────────────────────────────────────────────++ public List<Attribute> putAttributes(String clusterRef, List<Attribute> attrs, String region) {+ List<Attribute> stored = new ArrayList<>();+ for (Attribute attr : attrs) {+ String targetId = attr.targetId();+ List<Attribute> existing = attributes.computeIfAbsent(targetId, k -> new ArrayList<>());+ existing.removeIf(a -> a.name().equals(attr.name()));+ existing.add(attr);+ stored.add(attr);+ }+ return stored;+ }++ public List<Attribute> deleteAttributes(String clusterRef, List<Attribute> attrs, String region) {+ List<Attribute> deleted = new ArrayList<>();+ for (Attribute attr : attrs) {+ String targetId = attr.targetId();+ List<Attribute> existing = attributes.get(targetId);+ if (existing != null) {+ existing.removeIf(a -> {+ if (a.name().equals(attr.name())) {+ deleted.add(a);+ return true;+ }+ return false;+ });+ }+ }+ return deleted;+ }++ public List<Attribute> listAttributes(String clusterRef, String targetType,+ String attributeName, String attributeValue, String region) {+ return attributes.values().stream()+ .flatMap(List::stream)+ .filter(a -> targetType == null || targetType.equals(a.targetType()))+ .filter(a -> attributeName == null || attributeName.equals(a.name()))+ .filter(a -> attributeValue == null || attributeValue.equals(a.value()))+ .toList();+ }++ // ── Container Instances ───────────────────────────────────────────────────++ public ContainerInstance registerContainerInstance(String clusterRef, String instanceIdentityDocument,+ List<Attribute> instanceAttributes, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ String instanceId = "i-floci-" + UUID.randomUUID().toString().substring(0, 8);+ String instanceArn = regionResolver.buildArn("ecs", region,+ "container-instance/" + cluster.getClusterName() + "/" + UUID.randomUUID());++ ContainerInstance instance = new ContainerInstance();+ instance.setContainerInstanceArn(instanceArn);+ instance.setEc2InstanceId(instanceId);+ instance.setStatus("ACTIVE");+ instance.setAgentVersion("1.0.0");+ instance.setAgentConnected(true);+ if (instanceAttributes != null) {+ instance.setAttributes(new ArrayList<>(instanceAttributes));+ }++ String key = containerInstanceKey(cluster.getClusterArn(), instanceArn);+ containerInstances.put(key, instance);+ cluster.setRegisteredContainerInstancesCount(cluster.getRegisteredContainerInstancesCount() + 1);+ LOG.infov("Registered container instance: {0} in cluster {1}", instanceArn, cluster.getClusterName());+ return instance;+ }++ public ContainerInstance deregisterContainerInstance(String clusterRef, String instanceRef,+ boolean force, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ ContainerInstance instance = resolveContainerInstanceOrThrow(cluster.getClusterArn(), instanceRef);++ if (!force) {+ long running = tasks.values().stream()+ .filter(t -> instance.getContainerInstanceArn().equals(t.getContainerInstanceArn()))+ .filter(t -> TaskStatus.RUNNING.name().equals(t.getLastStatus()))+ .count();+ if (running > 0) {+ throw new AwsException("InvalidParameterException",+ "Container instance has running tasks. Use force=true to deregister.", 400);+ }+ }++ String key = containerInstanceKey(cluster.getClusterArn(), instance.getContainerInstanceArn());+ containerInstances.remove(key);+ instance.setStatus("INACTIVE");+ cluster.setRegisteredContainerInstancesCount(+ Math.max(0, cluster.getRegisteredContainerInstancesCount() - 1));+ return instance;+ }++ public List<ContainerInstance> describeContainerInstances(String clusterRef,+ List<String> instanceRefs, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ List<ContainerInstance> result = new ArrayList<>();+ for (String ref : instanceRefs) {+ ContainerInstance instance = resolveContainerInstance(cluster.getClusterArn(), ref);+ if (instance != null) {+ result.add(instance);+ }+ }+ return result;+ }++ public List<String> listContainerInstances(String clusterRef, String status, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ String prefix = containerInstanceKey(cluster.getClusterArn(), "");+ return containerInstances.entrySet().stream()+ .filter(e -> e.getKey().startsWith(prefix))+ .filter(e -> status == null || status.equals(e.getValue().getStatus()))+ .map(e -> e.getValue().getContainerInstanceArn())+ .toList();+ }++ public ContainerInstance updateContainerAgent(String clusterRef, String instanceRef, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ return resolveContainerInstanceOrThrow(cluster.getClusterArn(), instanceRef);+ }++ public List<ContainerInstance> updateContainerInstancesState(String clusterRef,+ List<String> instanceRefs,+ String status, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ List<ContainerInstance> updated = new ArrayList<>();+ for (String ref : instanceRefs) {+ ContainerInstance instance = resolveContainerInstanceOrThrow(cluster.getClusterArn(), ref);+ instance.setStatus(status);+ updated.add(instance);+ }+ return updated;+ }++ // ── Capacity Providers ────────────────────────────────────────────────────++ public CapacityProvider createCapacityProvider(String name, Map<String, Object> asgProvider,+ Map<String, String> tags, String region) {+ if (capacityProviders.containsKey(name)) {+ throw new AwsException("InvalidParameterException",+ "A capacity provider with name " + name + " already exists.", 400);+ }+ CapacityProvider cp = new CapacityProvider();+ cp.setName(name);+ cp.setCapacityProviderArn(regionResolver.buildArn("ecs", region, "capacity-provider/" + name));+ cp.setStatus("ACTIVE");+ cp.setAutoScalingGroupProvider(asgProvider);+ if (tags != null) {+ cp.setTags(tags);+ }+ capacityProviders.put(name, cp);+ return cp;+ }++ public CapacityProvider updateCapacityProvider(String name, Map<String, Object> asgProvider) {+ CapacityProvider cp = resolveCapacityProviderOrThrow(name);+ cp.setAutoScalingGroupProvider(asgProvider);+ return cp;+ }++ public CapacityProvider deleteCapacityProvider(String nameOrArn) {+ CapacityProvider cp = resolveCapacityProviderOrThrow(nameOrArn);+ cp.setStatus("DELETE_IN_PROGRESS");+ capacityProviders.remove(cp.getName());+ return cp;+ }++ public List<CapacityProvider> describeCapacityProviders(List<String> providers) {+ if (providers == null || providers.isEmpty()) {+ List<CapacityProvider> result = new ArrayList<>(List.of(builtInFargate(), builtInFargateSpot()));+ result.addAll(capacityProviders.values());+ return result;+ }+ return providers.stream()+ .map(p -> {+ if ("FARGATE".equals(p)) { return builtInFargate(); }+ if ("FARGATE_SPOT".equals(p)) { return builtInFargateSpot(); }+ return capacityProviders.getOrDefault(p,+ capacityProviders.values().stream()+ .filter(cp -> cp.getCapacityProviderArn().equals(p))+ .findFirst().orElse(null));+ })+ .filter(cp -> cp != null)+ .toList();+ }++ private CapacityProvider builtInFargate() {+ CapacityProvider cp = new CapacityProvider();+ cp.setName("FARGATE");+ cp.setStatus("ACTIVE");+ return cp;+ }++ private CapacityProvider builtInFargateSpot() {+ CapacityProvider cp = new CapacityProvider();+ cp.setName("FARGATE_SPOT");+ cp.setStatus("ACTIVE");+ return cp;+ }++ // ── Task Sets ─────────────────────────────────────────────────────────────++ public TaskSet createTaskSet(String clusterRef, String serviceRef, String taskDefinitionRef,+ LaunchType launchType, double scaleValue, String scaleUnit,+ String externalId, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ EcsServiceModel svc = resolveServiceOrThrow(cluster.getClusterName(), serviceRef, region);+ TaskDefinition taskDef = resolveTaskDefinitionOrThrow(taskDefinitionRef, region);++ String setId = "ecs-svc/" + UUID.randomUUID().toString().replace("-", "");+ String taskSetArn = regionResolver.buildArn("ecs", region, "task-set/"+ + cluster.getClusterName() + "/" + svc.getServiceName() + "/" + setId);++ TaskSet ts = new TaskSet();+ ts.setId(setId);+ ts.setTaskSetArn(taskSetArn);+ ts.setServiceArn(svc.getServiceArn());+ ts.setClusterArn(cluster.getClusterArn());+ ts.setTaskDefinition(taskDef.getTaskDefinitionArn());+ ts.setStatus("ACTIVE");+ ts.setScaleValue(scaleValue);+ ts.setScaleUnit(scaleUnit != null ? scaleUnit : "PERCENT");+ ts.setLaunchType(launchType != null ? launchType : LaunchType.FARGATE);+ ts.setExternalId(externalId);+ ts.setStabilityStatus("STEADY_STATE");+ ts.setCreatedAt(Instant.now());+ ts.setUpdatedAt(Instant.now());++ taskSets.put(taskSetArn, ts);+ return ts;+ }++ public TaskSet updateTaskSet(String clusterRef, String serviceRef, String taskSetRef,+ double scaleValue, String scaleUnit, String region) {+ TaskSet ts = resolveTaskSetOrThrow(taskSetRef);+ ts.setScaleValue(scaleValue);+ ts.setScaleUnit(scaleUnit != null ? scaleUnit : "PERCENT");+ ts.setUpdatedAt(Instant.now());+ return ts;+ }++ public TaskSet deleteTaskSet(String clusterRef, String serviceRef, String taskSetRef,+ boolean force, String region) {+ TaskSet ts = resolveTaskSetOrThrow(taskSetRef);+ ts.setStatus("DRAINING");+ taskSets.remove(ts.getTaskSetArn());+ return ts;+ }++ public List<TaskSet> describeTaskSets(String clusterRef, String serviceRef,+ List<String> taskSetRefs, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ EcsServiceModel svc = resolveServiceOrThrow(cluster.getClusterName(), serviceRef, region);+ Stream<TaskSet> stream = taskSets.values().stream()+ .filter(ts -> ts.getServiceArn().equals(svc.getServiceArn()));+ if (taskSetRefs != null && !taskSetRefs.isEmpty()) {+ stream = stream.filter(ts -> taskSetRefs.contains(ts.getTaskSetArn())+ || taskSetRefs.contains(ts.getId()));+ }+ return stream.toList();+ }++ public TaskSet updateServicePrimaryTaskSet(String clusterRef, String serviceRef,+ String primaryTaskSetRef, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ EcsServiceModel svc = resolveServiceOrThrow(cluster.getClusterName(), serviceRef, region);+ TaskSet primary = resolveTaskSetOrThrow(primaryTaskSetRef);++ taskSets.values().stream()+ .filter(ts -> ts.getServiceArn().equals(svc.getServiceArn()))+ .forEach(ts -> ts.setStatus(ts.getTaskSetArn().equals(primary.getTaskSetArn())+ ? "PRIMARY" : "ACTIVE"));++ primary.setUpdatedAt(Instant.now());+ return primary;+ }++ // ── Service Deployments & Revisions ───────────────────────────────────────++ public List<ServiceDeployment> describeServiceDeployments(List<String> deploymentArns) {+ return deploymentArns.stream()+ .map(arn -> serviceDeployments.get(arn))+ .filter(d -> d != null)+ .toList();+ }++ public List<String> listServiceDeployments(String serviceRef, String clusterRef,+ List<String> statusFilter, String region) {+ return listServiceDeploymentsDetailed(serviceRef, clusterRef, statusFilter, region)+ .stream().map(ServiceDeployment::getServiceDeploymentArn).toList();+ }++ public List<ServiceDeployment> listServiceDeploymentsDetailed(String serviceRef, String clusterRef,+ List<String> statusFilter, String region) {+ EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);+ EcsServiceModel svc = resolveServiceOrThrow(cluster.getClusterName(), serviceRef, region);++ return serviceDeployments.values().stream()+ .filter(d -> d.getServiceArn().equals(svc.getServiceArn()))+ .filter(d -> statusFilter == null || statusFilter.isEmpty()+ || statusFilter.contains(d.getStatus()))+ .sorted((a, b) -> b.getCreatedAt().compareTo(a.getCreatedAt()))+ .toList();+ }++ public List<ServiceRevision> describeServiceRevisions(List<String> revisionArns) {+ return revisionArns.stream()+ .map(arn -> serviceRevisions.get(arn))+ .filter(r -> r != null)+ .toList();+ }++ private void recordServiceDeployment(EcsServiceModel svc, String taskDefinition, String region) {+ String deploymentId = UUID.randomUUID().toString().replace("-", "");+ String deploymentArn = regionResolver.buildArn("ecs", region,+ "service-deployment/" + deploymentId);+ String revisionId = UUID.randomUUID().toString().replace("-", "");+ String revisionArn = regionResolver.buildArn("ecs", region,+ "service-revision/" + revisionId);++ ServiceDeployment deployment = new ServiceDeployment();+ deployment.setServiceDeploymentArn(deploymentArn);+ deployment.setServiceArn(svc.getServiceArn());+ deployment.setClusterArn(svc.getClusterArn());+ deployment.setTaskDefinition(taskDefinition);+ deployment.setStatus("SUCCESSFUL");+ deployment.setCreatedAt(Instant.now());+ deployment.setUpdatedAt(Instant.now());+ serviceDeployments.put(deploymentArn, deployment);++ ServiceRevision revision = new ServiceRevision();+ revision.setServiceRevisionArn(revisionArn);+ revision.setServiceArn(svc.getServiceArn());+ revision.setClusterArn(svc.getClusterArn());+ revision.setTaskDefinition(taskDefinition);+ revision.setLaunchType(svc.getLaunchType());+ revision.setCreatedAt(Instant.now());+ serviceRevisions.put(revisionArn, revision);+ }++ // ── Stub operations ────────────────────────────────────────────────────────++ public String submitTaskStateChange() {+ return "ACK_" + UUID.randomUUID().toString().replace("-", "").substring(0, 16);+ }++ public String submitContainerStateChange() {+ return "ACK_" + UUID.randomUUID().toString().replace("-", "").substring(0, 16);+ }++ public String submitAttachmentStateChanges() {+ return "ACK_" + UUID.randomUUID().toString().replace("-", "").substring(0, 16);+ }++ public String getBaseUrl() {+ return baseUrl;+ }++ // ── Service Reconciliation ────────────────────────────────────────────────++ void reconcileServices() {+ for (Map.Entry<String, EcsServiceModel> entry : services.entrySet()) {+ try {+ reconcileService(entry.getKey(), entry.getValue());+ } catch (Exception e) {+ LOG.debugv("Error reconciling ECS service {0}: {1}", entry.getKey(), e.getMessage());+ }+ }+ }++ private void reconcileService(String key, EcsServiceModel svc) {+ if (!"ACTIVE".equals(svc.getStatus())) {+ return;+ }++ String region = extractRegionFromServiceKey(key);+ String clusterName = extractClusterNameFromServiceKey(key);++ long running = tasks.values().stream()+ .filter(t -> t.getClusterArn().endsWith(":cluster/" + clusterName))+ .filter(t -> svc.getServiceArn().equals(t.getGroup())+ || svc.getServiceName().equals(t.getGroup()))+ .filter(t -> TaskStatus.RUNNING.name().equals(t.getLastStatus()))+ .count();++ svc.setRunningCount((int) running);++ if (running < svc.getDesiredCount()) {+ int toStart = svc.getDesiredCount() - (int) running;+ for (int i = 0; i < toStart; i++) {+ try {+ List<EcsTask> launched = runTask(clusterName, svc.getTaskDefinition(), 1,+ svc.getLaunchType(), svc.getServiceName(), "ecs-svc", region);+ LOG.infov("Service reconciler started task {0} for service {1}",+ launched.getFirst().getTaskArn(), svc.getServiceName());+ } catch (Exception e) {+ LOG.warnv("Service reconciler failed to start task for {0}: {1}",+ svc.getServiceName(), e.getMessage());+ }+ }+ } else if (running > svc.getDesiredCount()) {+ int toStop = (int) running - svc.getDesiredCount();+ tasks.values().stream()+ .filter(t -> t.getClusterArn().endsWith(":cluster/" + clusterName))+ .filter(t -> svc.getServiceName().equals(t.getGroup()))+ .filter(t -> TaskStatus.RUNNING.name().equals(t.getLastStatus()))+ .limit(toStop)+ .forEach(t -> {+ try {+ stopTask(clusterName, t.getTaskArn(), "Service scale-in", region);+ } catch (Exception e) {+ LOG.warnv("Service reconciler failed to stop task {0}: {1}",+ t.getTaskArn(), e.getMessage());+ }+ });+ }+ }++ // ── Resolution helpers ────────────────────────────────────────────────────++ private EcsCluster getOrCreateDefaultCluster(String region) {+ String key = clusterKey(region, DEFAULT_CLUSTER);+ return clusters.computeIfAbsent(key, k -> {+ EcsCluster c = new EcsCluster();+ c.setClusterName(DEFAULT_CLUSTER);+ c.setClusterArn(regionResolver.buildArn("ecs", region, "cluster/" + DEFAULT_CLUSTER));+ c.setStatus("ACTIVE");+ return c;+ });+ }++ private EcsCluster resolveClusterOrDefault(String clusterRef, String region) {+ if (clusterRef == null || clusterRef.isBlank() || DEFAULT_CLUSTER.equals(clusterRef)) {+ return getOrCreateDefaultCluster(region);+ }+ EcsCluster cluster = resolveCluster(clusterRef, region);+ if (cluster == null) {+ throw new AwsException("ClusterNotFoundException", "Cluster not found: " + clusterRef, 400);+ }+ return cluster;+ }++ private EcsCluster resolveCluster(String clusterRef, String region) {+ EcsCluster byName = clusters.get(clusterKey(region, clusterRef));+ if (byName != null) {+ return byName;+ }+ return clusters.values().stream()+ .filter(c -> c.getClusterArn().equals(clusterRef))+ .findFirst().orElse(null);+ }++ private EcsCluster resolveClusterOrThrow(String clusterRef, String region) {+ EcsCluster cluster = resolveCluster(clusterRef, region);+ if (cluster == null) {+ throw new AwsException("ClusterNotFoundException", "Cluster not found: " + clusterRef, 400);+ }+ return cluster;+ }++ private EcsCluster resolveClusterByArn(String clusterArn) {+ return clusters.values().stream()+ .filter(c -> c.getClusterArn().equals(clusterArn))+ .findFirst().orElse(null);+ }++ private TaskDefinition resolveTaskDefinitionOrThrow(String ref, String region) {+ TaskDefinition td = taskDefinitions.get(ref);+ if (td != null) { return td; }+ td = taskDefinitions.values().stream()+ .filter(d -> d.getTaskDefinitionArn().equals(ref))+ .findFirst().orElse(null);+ if (td != null) { return td; }+ Integer latest = latestRevisions.get(ref);+ if (latest != null) {+ td = taskDefinitions.get(ref + ":" + latest);+ if (td != null) { return td; }+ }+ throw new AwsException("ClientException", "Unable to describe task definition: " + ref, 400);+ }++ private EcsTask resolveTask(String ref, String region) {+ EcsTask task = tasks.get(ref);+ if (task != null) { return task; }+ return tasks.values().stream()+ .filter(t -> t.getTaskArn().endsWith("/" + ref))+ .findFirst().orElse(null);+ }++ private EcsTask resolveTaskOrThrow(String ref, String region) {+ EcsTask task = resolveTask(ref, region);+ if (task == null) {+ throw new AwsException("InvalidParameterException", "Task not found: " + ref, 400);+ }+ return task;+ }++ private EcsServiceModel resolveService(String clusterName, String serviceId, String region) {+ EcsServiceModel svc = services.get(serviceKey(region, clusterName, serviceId));+ if (svc != null) { return svc; }+ return services.values().stream()+ .filter(s -> s.getServiceArn().equals(serviceId) || s.getServiceName().equals(serviceId))+ .findFirst().orElse(null);+ }++ private EcsServiceModel resolveServiceOrThrow(String clusterName, String serviceId, String region) {+ EcsServiceModel svc = resolveService(clusterName, serviceId, region);+ if (svc == null) {+ throw new AwsException("ServiceNotFoundException", "Service not found: " + serviceId, 404);+ }+ return svc;+ }++ private ContainerInstance resolveContainerInstance(String clusterArn, String ref) {+ String prefix = containerInstanceKey(clusterArn, "");+ return containerInstances.entrySet().stream()+ .filter(e -> e.getKey().startsWith(prefix))+ .map(Map.Entry::getValue)+ .filter(ci -> ci.getContainerInstanceArn().equals(ref)+ || ci.getContainerInstanceArn().endsWith("/" + ref))+ .findFirst().orElse(null);+ }++ private ContainerInstance resolveContainerInstanceOrThrow(String clusterArn, String ref) {+ ContainerInstance instance = resolveContainerInstance(clusterArn, ref);+ if (instance == null) {+ throw new AwsException("InvalidParameterException",+ "Container instance not found: " + ref, 400);+ }+ return instance;+ }++ private CapacityProvider resolveCapacityProviderOrThrow(String nameOrArn) {+ CapacityProvider cp = capacityProviders.get(nameOrArn);+ if (cp != null) { return cp; }+ cp = capacityProviders.values().stream()+ .filter(p -> p.getCapacityProviderArn().equals(nameOrArn))+ .findFirst().orElse(null);+ if (cp == null) {+ throw new AwsException("InvalidParameterException",+ "Capacity provider not found: " + nameOrArn, 400);+ }+ return cp;+ }++ private TaskSet resolveTaskSetOrThrow(String ref) {+ TaskSet ts = taskSets.get(ref);+ if (ts != null) { return ts; }+ ts = taskSets.values().stream()+ .filter(t -> t.getId().equals(ref))+ .findFirst().orElse(null);+ if (ts == null) {+ throw new AwsException("InvalidParameterException", "Task set not found: " + ref, 400);+ }+ return ts;+ }++ // ── Key helpers ───────────────────────────────────────────────────────────++ private static String clusterKey(String region, String clusterName) {+ return region + "::" + clusterName;+ }++ private static String serviceKey(String region, String clusterName, String serviceName) {+ return region + "::" + clusterName + "/" + serviceName;+ }++ private static String serviceKeyPrefix(String region, String clusterName) {+ return region + "::" + clusterName + "/";+ }++ private static String containerInstanceKey(String clusterArn, String instanceArn) {+ return clusterArn + "/" + instanceArn;+ }++ private static String extractRegionFromServiceKey(String key) {+ return key.substring(0, key.indexOf("::"));+ }++ private static String extractClusterNameFromServiceKey(String key) {+ String after = key.substring(key.indexOf("::") + 2);+ int slash = after.indexOf('/');+ return slash >= 0 ? after.substring(0, slash) : after;+ }+}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.javanew file mode 100644index 0000000000..563e6bf2fa--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.java@@ -0,0 +1,313 @@+package io.github.hectorvent.floci.services.ecs.container;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;+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.EcsTask;+import io.github.hectorvent.floci.services.ecs.model.NetworkBinding;+import io.github.hectorvent.floci.services.ecs.model.PortMapping;+import io.github.hectorvent.floci.services.ecs.model.TaskDefinition;+import io.github.hectorvent.floci.services.lambda.launcher.DockerHostResolver;+import io.github.hectorvent.floci.services.lambda.launcher.ImageCacheService;+import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.async.ResultCallback;+import com.github.dockerjava.api.command.CreateContainerResponse;+import com.github.dockerjava.api.model.ExposedPort;+import com.github.dockerjava.api.model.Frame;+import com.github.dockerjava.api.model.HostConfig;+import com.github.dockerjava.api.model.Ports;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.io.Closeable;+import java.nio.charset.StandardCharsets;+import java.time.Instant;+import java.time.LocalDate;+import java.time.format.DateTimeFormatter;+import java.util.ArrayList;+import java.util.HashMap;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/**+ * Manages Docker container lifecycle for ECS tasks.+ * Starts one Docker container per ContainerDefinition in a task and attaches logs to CloudWatch.+ */+@ApplicationScoped+public class EcsContainerManager {++ private static final Logger LOG = Logger.getLogger(EcsContainerManager.class);+ private static final String HOST_DOCKER_INTERNAL = "host.docker.internal";+ private static final DateTimeFormatter LOG_STREAM_DATE_FMT = DateTimeFormatter.ofPattern("yyyy/MM/dd");++ private final DockerClient dockerClient;+ private final ImageCacheService imageCacheService;+ private final DockerHostResolver dockerHostResolver;+ private final EmulatorConfig config;+ private final CloudWatchLogsService cloudWatchLogsService;+ private final RegionResolver regionResolver;++ @Inject+ public EcsContainerManager(DockerClient dockerClient,+ ImageCacheService imageCacheService,+ DockerHostResolver dockerHostResolver,+ EmulatorConfig config,+ CloudWatchLogsService cloudWatchLogsService,+ RegionResolver regionResolver) {+ this.dockerClient = dockerClient;+ this.imageCacheService = imageCacheService;+ this.dockerHostResolver = dockerHostResolver;+ this.config = config;+ this.cloudWatchLogsService = cloudWatchLogsService;+ this.regionResolver = regionResolver;+ }++ /**+ * Starts Docker containers for all container definitions in a task.+ * Updates the task's container list in-place with runtime network bindings and docker IDs.+ */+ public EcsTaskHandle startTask(EcsTask task, TaskDefinition taskDef, String region) {+ String taskId = extractTaskId(task.getTaskArn());+ boolean nativeMode = HOST_DOCKER_INTERNAL.equals(dockerHostResolver.resolve());++ Map<String, String> containerIds = new LinkedHashMap<>();+ List<Closeable> logStreams = new ArrayList<>();+ List<Container> runtimeContainers = new ArrayList<>();++ for (ContainerDefinition def : taskDef.getContainerDefinitions()) {+ imageCacheService.ensureImageExists(def.getImage());++ List<ExposedPort> exposedPorts = buildExposedPorts(def);+ HostConfig hostConfig = buildHostConfig(nativeMode, def, exposedPorts);++ applyDockerNetwork(hostConfig);++ List<String> envVars = buildEnvVars(def);+ String containerName = "floci-ecs-" + taskId + "-" + def.getName();++ var createCmd = dockerClient.createContainerCmd(def.getImage())+ .withName(containerName)+ .withEnv(envVars)+ .withHostConfig(hostConfig);++ if (!exposedPorts.isEmpty()) {+ createCmd.withExposedPorts(exposedPorts);+ }+ if (def.getCommand() != null && !def.getCommand().isEmpty()) {+ createCmd.withCmd(def.getCommand());+ }+ if (def.getEntryPoint() != null && !def.getEntryPoint().isEmpty()) {+ createCmd.withEntrypoint(def.getEntryPoint());+ }++ CreateContainerResponse created = createCmd.exec();+ String dockerId = created.getId();+ LOG.infov("Created ECS container {0} for task {1} container {2}", dockerId, taskId, def.getName());++ dockerClient.startContainerCmd(dockerId).exec();+ LOG.infov("Started ECS container {0}", dockerId);++ List<NetworkBinding> networkBindings = resolveNetworkBindings(dockerId, def, nativeMode);++ Container container = buildContainer(task.getTaskArn(), def, dockerId, networkBindings, region);+ runtimeContainers.add(container);+ containerIds.put(def.getName(), dockerId);++ Closeable logStream = attachLogStream(dockerId, def.getName(), taskDef.getFamily(), taskId, region);+ if (logStream != null) {+ logStreams.add(logStream);+ }+ }++ task.setContainers(runtimeContainers);+ task.setLastStatus(TaskStatus.RUNNING.name());+ task.setDesiredStatus(TaskStatus.RUNNING.name());+ task.setStartedAt(Instant.now());++ return new EcsTaskHandle(task.getTaskArn(), containerIds, logStreams);+ }++ /**+ * Stops and removes all Docker containers for a task.+ */+ public void stopTask(EcsTaskHandle handle) {+ if (handle == null) {+ return;+ }++ for (Closeable logStream : handle.getLogStreams()) {+ try { logStream.close(); } catch (Exception ignored) {}+ }++ for (Map.Entry<String, String> entry : handle.getContainerIds().entrySet()) {+ String dockerId = entry.getValue();+ try {+ dockerClient.stopContainerCmd(dockerId).withTimeout(5).exec();+ } catch (Exception e) {+ LOG.warnv("Error stopping ECS container {0}: {1}", dockerId, e.getMessage());+ }+ try {+ dockerClient.removeContainerCmd(dockerId).withForce(true).exec();+ } catch (Exception e) {+ LOG.warnv("Error removing ECS container {0}: {1}", dockerId, e.getMessage());+ }+ }+ }++ private List<ExposedPort> buildExposedPorts(ContainerDefinition def) {+ List<ExposedPort> exposed = new ArrayList<>();+ if (def.getPortMappings() != null) {+ for (PortMapping pm : def.getPortMappings()) {+ exposed.add(ExposedPort.tcp(pm.containerPort()));+ }+ }+ return exposed;+ }++ private HostConfig buildHostConfig(boolean nativeMode, ContainerDefinition def, List<ExposedPort> exposedPorts) {+ HostConfig hostConfig = HostConfig.newHostConfig();++ if (def.getMemory() != null) {+ hostConfig.withMemory((long) def.getMemory() * 1024 * 1024);+ }++ if (nativeMode && !exposedPorts.isEmpty()) {+ Ports portBindings = new Ports();+ for (ExposedPort ep : exposedPorts) {+ portBindings.bind(ep, Ports.Binding.bindPort(0)); // 0 = dynamic host port+ }+ hostConfig.withPortBindings(portBindings);+ }++ return hostConfig;+ }++ private void applyDockerNetwork(HostConfig hostConfig) {+ config.services().ecs().dockerNetwork()+ .or(() -> config.services().dockerNetwork())+ .filter(n -> !n.isBlank())+ .ifPresent(network -> {+ hostConfig.withNetworkMode(network);+ LOG.debugv("Attaching ECS container to network: {0}", network);+ });+ }++ private List<String> buildEnvVars(ContainerDefinition def) {+ List<String> envVars = new ArrayList<>();+ if (def.getEnvironment() != null) {+ for (var kv : def.getEnvironment()) {+ envVars.add(kv.name() + "=" + kv.value());+ }+ }+ return envVars;+ }++ private List<NetworkBinding> resolveNetworkBindings(String dockerId, ContainerDefinition def, boolean nativeMode) {+ List<NetworkBinding> bindings = new ArrayList<>();+ if (def.getPortMappings() == null || def.getPortMappings().isEmpty()) {+ return bindings;+ }++ var inspect = dockerClient.inspectContainerCmd(dockerId).exec();+ var portBindingsMap = inspect.getNetworkSettings().getPorts().getBindings();++ for (PortMapping pm : def.getPortMappings()) {+ ExposedPort ep = ExposedPort.tcp(pm.containerPort());+ var binding = portBindingsMap.get(ep);+ int hostPort = pm.containerPort();+ String bindIp = "0.0.0.0";++ if (nativeMode && binding != null && binding.length > 0) {+ hostPort = Integer.parseInt(binding[0].getHostPortSpec());+ if (binding[0].getHostIp() != null && !binding[0].getHostIp().isBlank()) {+ bindIp = binding[0].getHostIp();+ }+ }++ bindings.add(new NetworkBinding(bindIp, pm.containerPort(), hostPort, pm.protocol()));+ }+ return bindings;+ }++ private Container buildContainer(String taskArn, ContainerDefinition def, String dockerId,+ List<NetworkBinding> networkBindings, String region) {+ Container container = new Container();+ container.setTaskArn(taskArn);+ container.setName(def.getName());+ container.setImage(def.getImage());+ container.setLastStatus("RUNNING");+ container.setNetworkBindings(networkBindings);+ container.setDockerId(dockerId);+ container.setContainerArn(regionResolver.buildArn("ecs", region,+ "container/" + extractTaskId(taskArn) + "/" + def.getName()));+ return container;+ }++ private Closeable attachLogStream(String dockerId, String containerName,+ String family, String taskId, String region) {+ String logGroup = "/ecs/" + family;+ String logStream = LOG_STREAM_DATE_FMT.format(LocalDate.now()) + "/" + containerName + "/" + taskId;+ ensureLogGroupAndStream(logGroup, logStream, region);++ try {+ ResultCallback.Adapter<Frame> callback = dockerClient.logContainerCmd(dockerId)+ .withStdOut(true)+ .withStdErr(true)+ .withFollowStream(true)+ .withTimestamps(false)+ .exec(new ResultCallback.Adapter<>() {+ @Override+ public void onNext(Frame frame) {+ String line = new String(frame.getPayload(), StandardCharsets.UTF_8).stripTrailing();+ if (!line.isEmpty()) {+ LOG.infov("[ecs:{0}:{1}] {2}", family, containerName, line);+ forwardToCloudWatchLogs(logGroup, logStream, region, line);+ }+ }+ });+ return callback;+ } catch (Exception e) {+ LOG.warnv("Could not attach log stream for ECS container {0}: {1}", dockerId, e.getMessage());+ return null;+ }+ }++ private void ensureLogGroupAndStream(String logGroup, String logStream, String region) {+ try {+ cloudWatchLogsService.createLogGroup(logGroup, null, null, region);+ } catch (AwsException ignored) {+ } catch (Exception e) {+ LOG.warnv("Could not create CW log group {0}: {1}", logGroup, e.getMessage());+ }+ try {+ cloudWatchLogsService.createLogStream(logGroup, logStream, region);+ } catch (AwsException ignored) {+ } catch (Exception e) {+ LOG.warnv("Could not create CW log stream {0}/{1}: {2}", logGroup, logStream, e.getMessage());+ }+ }++ private void forwardToCloudWatchLogs(String logGroup, String logStream, String region, String line) {+ try {+ Map<String, Object> event = new HashMap<>();+ event.put("timestamp", System.currentTimeMillis());+ event.put("message", line);+ cloudWatchLogsService.putLogEvents(logGroup, logStream, List.of(event), region);+ } catch (Exception e) {+ LOG.debugv("Could not forward ECS log line to CloudWatch Logs: {0}", e.getMessage());+ }+ }++ private static String extractTaskId(String taskArn) {+ int slash = taskArn.lastIndexOf('/');+ return slash >= 0 ? taskArn.substring(slash + 1) : taskArn;+ }++ // Inner enum to avoid import cycle — mirrors model.TaskStatus for readability+ private enum TaskStatus { RUNNING }+}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.javanew file mode 100644index 0000000000..9127f3bbbb--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskHandle.java@@ -0,0 +1,26 @@+package io.github.hectorvent.floci.services.ecs.container;++import java.io.Closeable;+import java.util.List;+import java.util.Map;++/**+ * Holds the runtime Docker container IDs for a running ECS task.+ * Maps container name → Docker container ID and log stream handle.+ */+public class EcsTaskHandle {++ private final String taskArn;+ private final Map<String, String> containerIds; // containerName → dockerId+ private final List<Closeable> logStreams;++ public EcsTaskHandle(String taskArn, Map<String, String> containerIds, List<Closeable> logStreams) {+ this.taskArn = taskArn;+ this.containerIds = containerIds;+ this.logStreams = logStreams;+ }++ public String getTaskArn() { return taskArn; }+ public Map<String, String> getContainerIds() { return containerIds; }+ public List<Closeable> getLogStreams() { return logStreams; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/Attribute.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Attribute.javanew file mode 100644index 0000000000..8f080771b9--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Attribute.java@@ -0,0 +1,6 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++@RegisterForReflection+public record Attribute(String name, String value, String targetType, String targetId) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/CapacityProvider.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/CapacityProvider.javanew file mode 100644index 0000000000..080124da3c--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/CapacityProvider.java@@ -0,0 +1,33 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.HashMap;+import java.util.Map;++@RegisterForReflection+public class CapacityProvider {++ private String capacityProviderArn;+ private String name;+ private String status;+ private Map<String, Object> autoScalingGroupProvider;+ private Map<String, String> tags = new HashMap<>();++ public String getCapacityProviderArn() { return capacityProviderArn; }+ public void setCapacityProviderArn(String capacityProviderArn) { this.capacityProviderArn = capacityProviderArn; }++ public String getName() { return name; }+ public void setName(String name) { this.name = name; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public Map<String, Object> getAutoScalingGroupProvider() { return autoScalingGroupProvider; }+ public void setAutoScalingGroupProvider(Map<String, Object> autoScalingGroupProvider) {+ this.autoScalingGroupProvider = autoScalingGroupProvider;+ }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ClusterSetting.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ClusterSetting.javanew file mode 100644index 0000000000..7aa551ba1d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ClusterSetting.java@@ -0,0 +1,6 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++@RegisterForReflection+public record ClusterSetting(String name, String value) {}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.javanew file mode 100644index 0000000000..5a14e047bd--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/Container.java@@ -0,0 +1,48 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+public class Container {++ private String containerArn;+ private String taskArn;+ private String name;+ private String image;+ private String lastStatus;+ private Integer exitCode;+ private String reason;+ private List<NetworkBinding> networkBindings;++ // transient — not persisted+ private transient String dockerId;++ public String getContainerArn() { return containerArn; }+ public void setContainerArn(String containerArn) { this.containerArn = containerArn; }++ public String getTaskArn() { return taskArn; }+ public void setTaskArn(String taskArn) { this.taskArn = taskArn; }++ public String getName() { return name; }+ public void setName(String name) { this.name = name; }++ public String getImage() { return image; }+ public void setImage(String image) { this.image = image; }++ public String getLastStatus() { return lastStatus; }+ public void setLastStatus(String lastStatus) { this.lastStatus = lastStatus; }++ public Integer getExitCode() { return exitCode; }+ public void setExitCode(Integer exitCode) { this.exitCode = exitCode; }++ public String getReason() { return reason; }+ public void setReason(String reason) { this.reason = reason; }++ public List<NetworkBinding> getNetworkBindings() { return networkBindings; }+ public void setNetworkBindings(List<NetworkBinding> networkBindings) { this.networkBindings = networkBindings; }++ 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.javanew file mode 100644index 0000000000..053f61b338--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerDefinition.java@@ -0,0 +1,50 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++@RegisterForReflection+public class ContainerDefinition {++ private String name;+ private String image;+ private Integer cpu;+ private Integer memory;+ private Integer memoryReservation;+ private boolean essential = true;+ private List<PortMapping> portMappings;+ private List<KeyValuePair> environment;+ private List<String> command;+ private List<String> entryPoint;++ public String getName() { return name; }+ public void setName(String name) { this.name = name; }++ public String getImage() { return image; }+ public void setImage(String image) { this.image = image; }++ 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; }++ public boolean isEssential() { return essential; }+ public void setEssential(boolean essential) { this.essential = essential; }++ public List<PortMapping> getPortMappings() { return portMappings; }+ public void setPortMappings(List<PortMapping> portMappings) { this.portMappings = portMappings; }++ public List<KeyValuePair> getEnvironment() { return environment; }+ public void setEnvironment(List<KeyValuePair> environment) { this.environment = environment; }++ public List<String> getCommand() { return command; }+ public void setCommand(List<String> command) { this.command = command; }++ public List<String> getEntryPoint() { return entryPoint; }+ public void setEntryPoint(List<String> entryPoint) { this.entryPoint = entryPoint; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerInstance.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerInstance.javanew file mode 100644index 0000000000..7ed33cb63e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ContainerInstance.java@@ -0,0 +1,49 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.HashMap;+import java.util.List;+import java.util.Map;++@RegisterForReflection+public class ContainerInstance {++ private String containerInstanceArn;+ private String ec2InstanceId;+ private String status;+ private int runningTasksCount;+ private int pendingTasksCount;+ private String agentVersion;+ private boolean agentConnected;+ private List<Attribute> attributes = new ArrayList<>();+ private Map<String, String> tags = new HashMap<>();++ public String getContainerInstanceArn() { return containerInstanceArn; }+ public void setContainerInstanceArn(String containerInstanceArn) { this.containerInstanceArn = containerInstanceArn; }++ public String getEc2InstanceId() { return ec2InstanceId; }+ public void setEc2InstanceId(String ec2InstanceId) { this.ec2InstanceId = ec2InstanceId; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public int getRunningTasksCount() { return runningTasksCount; }+ public void setRunningTasksCount(int runningTasksCount) { this.runningTasksCount = runningTasksCount; }++ public int getPendingTasksCount() { return pendingTasksCount; }+ public void setPendingTasksCount(int pendingTasksCount) { this.pendingTasksCount = pendingTasksCount; }++ public String getAgentVersion() { return agentVersion; }+ public void setAgentVersion(String agentVersion) { this.agentVersion = agentVersion; }++ public boolean isAgentConnected() { return agentConnected; }+ public void setAgentConnected(boolean agentConnected) { this.agentConnected = agentConnected; }++ public List<Attribute> getAttributes() { return attributes; }+ public void setAttributes(List<Attribute> attributes) { this.attributes = attributes; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsCluster.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsCluster.javanew file mode 100644index 0000000000..55c578fd58--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsCluster.java@@ -0,0 +1,56 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.HashMap;+import java.util.List;+import java.util.Map;++@RegisterForReflection+public class EcsCluster {++ private String clusterArn;+ private String clusterName;+ private String status;+ private int registeredContainerInstancesCount;+ private int runningTasksCount;+ private int pendingTasksCount;+ private int activeServicesCount;+ private List<ClusterSetting> settings;+ private List<String> capacityProviders;+ private List<Map<String, Object>> defaultCapacityProviderStrategy;+ private Map<String, String> tags = new HashMap<>();++ public String getClusterArn() { return clusterArn; }+ public void setClusterArn(String clusterArn) { this.clusterArn = clusterArn; }++ public String getClusterName() { return clusterName; }+ public void setClusterName(String clusterName) { this.clusterName = clusterName; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public int getRegisteredContainerInstancesCount() { return registeredContainerInstancesCount; }+ public void setRegisteredContainerInstancesCount(int count) { this.registeredContainerInstancesCount = count; }++ public int getRunningTasksCount() { return runningTasksCount; }+ public void setRunningTasksCount(int count) { this.runningTasksCount = count; }++ public int getPendingTasksCount() { return pendingTasksCount; }+ public void setPendingTasksCount(int count) { this.pendingTasksCount = count; }++ public int getActiveServicesCount() { return activeServicesCount; }+ public void setActiveServicesCount(int count) { this.activeServicesCount = count; }++ 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>> s) { this.defaultCapacityProviderStrategy = s; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+}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.javanew file mode 100644index 0000000000..8bb94651c9--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.java@@ -0,0 +1,64 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.HashMap;+import java.util.Map;++@RegisterForReflection+public class EcsServiceModel {++ private String serviceArn;+ private String serviceName;+ private String clusterArn;+ private String taskDefinition;+ private LaunchType launchType;+ private int desiredCount;+ private int runningCount;+ private int pendingCount;+ private String status;+ private Instant createdAt;+ private String namespace;+ private String deploymentController;+ private Map<String, String> tags = new HashMap<>();++ public String getServiceArn() { return serviceArn; }+ public void setServiceArn(String serviceArn) { this.serviceArn = serviceArn; }++ public String getServiceName() { return serviceName; }+ public void setServiceName(String serviceName) { this.serviceName = serviceName; }++ public String getClusterArn() { return clusterArn; }+ public void setClusterArn(String clusterArn) { this.clusterArn = clusterArn; }++ public String getTaskDefinition() { return taskDefinition; }+ public void setTaskDefinition(String taskDefinition) { this.taskDefinition = taskDefinition; }++ public LaunchType getLaunchType() { return launchType; }+ public void setLaunchType(LaunchType launchType) { this.launchType = launchType; }++ public int getDesiredCount() { return desiredCount; }+ public void setDesiredCount(int desiredCount) { this.desiredCount = desiredCount; }++ public int getRunningCount() { return runningCount; }+ public void setRunningCount(int runningCount) { this.runningCount = runningCount; }++ public int getPendingCount() { return pendingCount; }+ public void setPendingCount(int pendingCount) { this.pendingCount = pendingCount; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public Instant getCreatedAt() { return createdAt; }+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }++ public String getNamespace() { return namespace; }+ public void setNamespace(String namespace) { this.namespace = namespace; }++ public String getDeploymentController() { return deploymentController; }+ public void setDeploymentController(String deploymentController) { this.deploymentController = deploymentController; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+}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.javanew file mode 100644index 0000000000..a01fca5be8--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsTask.java@@ -0,0 +1,89 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.HashMap;+import java.util.List;+import java.util.Map;++@RegisterForReflection+public class EcsTask {++ private String taskArn;+ private String clusterArn;+ private String taskDefinitionArn;+ private String group;+ private LaunchType launchType;+ private String lastStatus;+ private String desiredStatus;+ private String cpu;+ private String memory;+ private Instant createdAt;+ private Instant startedAt;+ private Instant stoppedAt;+ private String startedBy;+ private String stoppedReason;+ private List<Container> containers;+ private String containerInstanceArn;+ private boolean protectionEnabled;+ private Instant protectedUntil;+ private Map<String, String> tags = new HashMap<>();++ public String getTaskArn() { return taskArn; }+ public void setTaskArn(String taskArn) { this.taskArn = taskArn; }++ public String getClusterArn() { return clusterArn; }+ public void setClusterArn(String clusterArn) { this.clusterArn = clusterArn; }++ public String getTaskDefinitionArn() { return taskDefinitionArn; }+ public void setTaskDefinitionArn(String taskDefinitionArn) { this.taskDefinitionArn = taskDefinitionArn; }++ public String getGroup() { return group; }+ public void setGroup(String group) { this.group = group; }++ public LaunchType getLaunchType() { return launchType; }+ public void setLaunchType(LaunchType launchType) { this.launchType = launchType; }++ public String getLastStatus() { return lastStatus; }+ public void setLastStatus(String lastStatus) { this.lastStatus = lastStatus; }++ public String getDesiredStatus() { return desiredStatus; }+ public void setDesiredStatus(String desiredStatus) { this.desiredStatus = desiredStatus; }++ 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 Instant getCreatedAt() { return createdAt; }+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }++ public Instant getStartedAt() { return startedAt; }+ public void setStartedAt(Instant startedAt) { this.startedAt = startedAt; }++ public Instant getStoppedAt() { return stoppedAt; }+ public void setStoppedAt(Instant stoppedAt) { this.stoppedAt = stoppedAt; }++ public String getStartedBy() { return startedBy; }+ public void setStartedBy(String startedBy) { this.startedBy = startedBy; }++ public String getStoppedReason() { return stoppedReason; }+ public void setStoppedReason(String stoppedReason) { this.stoppedReason = stoppedReason; }++ public List<Container> getContainers() { return containers; }+ public void setContainers(List<Container> containers) { this.containers = containers; }++ public String getContainerInstanceArn() { return containerInstanceArn; }+ public void setContainerInstanceArn(String containerInstanceArn) { this.containerInstanceArn = containerInstanceArn; }++ public boolean isProtectionEnabled() { return protectionEnabled; }+ public void setProtectionEnabled(boolean protectionEnabled) { this.protectionEnabled = protectionEnabled; }++ public Instant getProtectedUntil() { return protectedUntil; }+ public void setProtectedUntil(Instant protectedUntil) { this.protectedUntil = protectedUntil; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/KeyValuePair.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/KeyValuePair.javanew file mode 100644index 0000000000..44425c99a7--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/KeyValuePair.java@@ -0,0 +1,4 @@+package io.github.hectorvent.floci.services.ecs.model;++public record KeyValuePair(String name, String value) {+}\ No newline at end of filediff --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.javanew file mode 100644index 0000000000..162ae547ab--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/LaunchType.java@@ -0,0 +1,5 @@+package io.github.hectorvent.floci.services.ecs.model;++public enum LaunchType {+ EC2, FARGATE, EXTERNAL+}\ No newline at end of filediff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/NetworkBinding.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/NetworkBinding.javanew file mode 100644index 0000000000..ff11244df1--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/NetworkBinding.java@@ -0,0 +1,4 @@+package io.github.hectorvent.floci.services.ecs.model;++public record NetworkBinding(String bindIP, int containerPort, int hostPort, String protocol) {+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/NetworkMode.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/NetworkMode.javanew file mode 100644index 0000000000..a29493b715--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/NetworkMode.java@@ -0,0 +1,5 @@+package io.github.hectorvent.floci.services.ecs.model;++public enum NetworkMode {+ bridge, host, awsvpc, none+}\ No newline at end of filediff --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.javanew file mode 100644index 0000000000..0a609e519c--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/PortMapping.java@@ -0,0 +1,8 @@+package io.github.hectorvent.floci.services.ecs.model;++public record PortMapping(int containerPort, int hostPort, String protocol) {++ public PortMapping(int containerPort) {+ this(containerPort, 0, "tcp");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ProtectedTask.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ProtectedTask.javanew file mode 100644index 0000000000..183348155f--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ProtectedTask.java@@ -0,0 +1,8 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++@RegisterForReflection+public record ProtectedTask(String taskArn, boolean protectionEnabled, Instant expirationDate) {}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ServiceDeployment.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ServiceDeployment.javanew file mode 100644index 0000000000..ca31b680c1--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ServiceDeployment.java@@ -0,0 +1,38 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++@RegisterForReflection+public class ServiceDeployment {++ private String serviceDeploymentArn;+ private String serviceArn;+ private String clusterArn;+ private String taskDefinition;+ private String status;+ private Instant createdAt;+ private Instant updatedAt;++ public String getServiceDeploymentArn() { return serviceDeploymentArn; }+ public void setServiceDeploymentArn(String serviceDeploymentArn) { this.serviceDeploymentArn = serviceDeploymentArn; }++ public String getServiceArn() { return serviceArn; }+ public void setServiceArn(String serviceArn) { this.serviceArn = serviceArn; }++ public String getClusterArn() { return clusterArn; }+ public void setClusterArn(String clusterArn) { this.clusterArn = clusterArn; }++ public String getTaskDefinition() { return taskDefinition; }+ public void setTaskDefinition(String taskDefinition) { this.taskDefinition = taskDefinition; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public Instant getCreatedAt() { return createdAt; }+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }++ public Instant getUpdatedAt() { return updatedAt; }+ public void setUpdatedAt(Instant updatedAt) { this.updatedAt = updatedAt; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/ServiceRevision.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ServiceRevision.javanew file mode 100644index 0000000000..3e90bc159b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/ServiceRevision.java@@ -0,0 +1,34 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++@RegisterForReflection+public class ServiceRevision {++ private String serviceRevisionArn;+ private String serviceArn;+ private String clusterArn;+ private String taskDefinition;+ private LaunchType launchType;+ private Instant createdAt;++ public String getServiceRevisionArn() { return serviceRevisionArn; }+ public void setServiceRevisionArn(String serviceRevisionArn) { this.serviceRevisionArn = serviceRevisionArn; }++ public String getServiceArn() { return serviceArn; }+ public void setServiceArn(String serviceArn) { this.serviceArn = serviceArn; }++ public String getClusterArn() { return clusterArn; }+ public void setClusterArn(String clusterArn) { this.clusterArn = clusterArn; }++ public String getTaskDefinition() { return taskDefinition; }+ public void setTaskDefinition(String taskDefinition) { this.taskDefinition = taskDefinition; }++ public LaunchType getLaunchType() { return launchType; }+ public void setLaunchType(LaunchType launchType) { this.launchType = launchType; }++ public Instant getCreatedAt() { return createdAt; }+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }+}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.javanew file mode 100644index 0000000000..8e031ce7df--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskDefinition.java@@ -0,0 +1,50 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.HashMap;+import java.util.List;+import java.util.Map;++@RegisterForReflection+public class TaskDefinition {++ private String taskDefinitionArn;+ private String family;+ private int revision;+ private String status; // ACTIVE or INACTIVE+ private NetworkMode networkMode;+ private String cpu;+ private String memory;+ private List<ContainerDefinition> containerDefinitions;+ private Map<String, String> tags = new HashMap<>();++ public String getTaskDefinitionArn() { return taskDefinitionArn; }+ public void setTaskDefinitionArn(String taskDefinitionArn) { this.taskDefinitionArn = taskDefinitionArn; }++ public String getFamily() { return family; }+ public void setFamily(String family) { this.family = family; }++ public int getRevision() { return revision; }+ public void setRevision(int revision) { this.revision = revision; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public NetworkMode getNetworkMode() { return networkMode; }+ public void setNetworkMode(NetworkMode networkMode) { this.networkMode = networkMode; }++ 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 List<ContainerDefinition> getContainerDefinitions() { return containerDefinitions; }+ public void setContainerDefinitions(List<ContainerDefinition> containerDefinitions) {+ this.containerDefinitions = containerDefinitions;+ }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskSet.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskSet.javanew file mode 100644index 0000000000..677bd85030--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskSet.java@@ -0,0 +1,80 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.HashMap;+import java.util.Map;++@RegisterForReflection+public class TaskSet {++ private String id;+ private String taskSetArn;+ private String serviceArn;+ private String clusterArn;+ private String taskDefinition;+ private String status;+ private int computedDesiredCount;+ private int pendingCount;+ private int runningCount;+ private double scaleValue;+ private String scaleUnit;+ private String stabilityStatus;+ private LaunchType launchType;+ private String externalId;+ private Instant createdAt;+ private Instant updatedAt;+ private Map<String, String> tags = new HashMap<>();++ public String getId() { return id; }+ public void setId(String id) { this.id = id; }++ public String getTaskSetArn() { return taskSetArn; }+ public void setTaskSetArn(String taskSetArn) { this.taskSetArn = taskSetArn; }++ public String getServiceArn() { return serviceArn; }+ public void setServiceArn(String serviceArn) { this.serviceArn = serviceArn; }++ public String getClusterArn() { return clusterArn; }+ public void setClusterArn(String clusterArn) { this.clusterArn = clusterArn; }++ public String getTaskDefinition() { return taskDefinition; }+ public void setTaskDefinition(String taskDefinition) { this.taskDefinition = taskDefinition; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public int getComputedDesiredCount() { return computedDesiredCount; }+ public void setComputedDesiredCount(int computedDesiredCount) { this.computedDesiredCount = computedDesiredCount; }++ public int getPendingCount() { return pendingCount; }+ public void setPendingCount(int pendingCount) { this.pendingCount = pendingCount; }++ public int getRunningCount() { return runningCount; }+ public void setRunningCount(int runningCount) { this.runningCount = runningCount; }++ public double getScaleValue() { return scaleValue; }+ public void setScaleValue(double scaleValue) { this.scaleValue = scaleValue; }++ public String getScaleUnit() { return scaleUnit; }+ public void setScaleUnit(String scaleUnit) { this.scaleUnit = scaleUnit; }++ public String getStabilityStatus() { return stabilityStatus; }+ public void setStabilityStatus(String stabilityStatus) { this.stabilityStatus = stabilityStatus; }++ public LaunchType getLaunchType() { return launchType; }+ public void setLaunchType(LaunchType launchType) { this.launchType = launchType; }++ public String getExternalId() { return externalId; }+ public void setExternalId(String externalId) { this.externalId = externalId; }++ public Instant getCreatedAt() { return createdAt; }+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }++ public Instant getUpdatedAt() { return updatedAt; }+ public void setUpdatedAt(Instant updatedAt) { this.updatedAt = updatedAt; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskStatus.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskStatus.javanew file mode 100644index 0000000000..2d701572fa--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/TaskStatus.java@@ -0,0 +1,5 @@+package io.github.hectorvent.floci.services.ecs.model;++public enum TaskStatus {+ PROVISIONING, PENDING, ACTIVATING, RUNNING, DEACTIVATING, STOPPING, DEPROVISIONING, STOPPED+}\ No newline at end of filediff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 81f3796472..2cd1141bd8 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -125,3 +125,6 @@ floci:default-image: "opensearchproject/opensearch:2"proxy-base-port: 9400proxy-max-port: 9499+ ecs:+ enabled: true+ mock: falsediff --git a/src/test/java/io/github/hectorvent/floci/lifecycle/HealthControllerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/lifecycle/HealthControllerIntegrationTest.javaindex a8db15e494..66734364de 100644--- a/src/test/java/io/github/hectorvent/floci/lifecycle/HealthControllerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/lifecycle/HealthControllerIntegrationTest.java@@ -38,7 +38,8 @@ class HealthControllerIntegrationTest {"cloudformation": "running","acm": "running","email": "running",- "es": "running"+ "es": "running",+ "ecs": "running"},"edition": "floci-always-free","version": "dev"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.javanew file mode 100644index 0000000000..a353d588f6--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsIntegrationTest.java@@ -0,0 +1,485 @@+package io.github.hectorvent.floci.services.ecs;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.RestAssured;+import io.restassured.config.EncoderConfig;+import io.restassured.http.ContentType;+import org.junit.jupiter.api.BeforeAll;+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 static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++/**+ * Integration tests for the ECS service (mock mode — no Docker required).+ *+ * Coverage:+ * - Clusters: Create, Describe, List, Update, Delete+ * - Task Definitions: Register, Describe, List, ListFamilies, Deregister+ * - Tasks: RunTask, DescribeTask, ListTasks, StopTask+ * - Services: Create, Describe, List, Update, Delete+ * - Tags: TagResource, ListTagsForResource, UntagResource+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class EcsIntegrationTest {++ private static final String TARGET_PREFIX = "AmazonEC2ContainerServiceV20141113.";+ private static final String REGION = "us-east-1";+ private static final String ACCOUNT = "000000000000";+ private static final String CLUSTER_NAME = "test-cluster";+ private static final String CLUSTER_ARN =+ "arn:aws:ecs:" + REGION + ":" + ACCOUNT + ":cluster/" + CLUSTER_NAME;+ private static final String TASK_DEF_FAMILY = "test-task";+ private static final String SERVICE_NAME = "test-service";++ private static final String CONTENT_TYPE = "application/x-amz-json-1.1";++ private static String taskArn;+ private static String serviceArn;+ private static String taskDefArn;++ @BeforeAll+ static void configureRestAssured() {+ RestAssured.config = RestAssured.config().encoderConfig(+ EncoderConfig.encoderConfig()+ .encodeContentTypeAs(CONTENT_TYPE, ContentType.TEXT));+ }++ // ── Helpers ───────────────────────────────────────────────────────────────++ private static io.restassured.specification.RequestSpecification ecs(String action) {+ return given()+ .contentType(CONTENT_TYPE)+ .header("X-Amz-Target", TARGET_PREFIX + action);+ }++ // ── Clusters ──────────────────────────────────────────────────────────────++ @Test+ @Order(1)+ void createCluster() {+ ecs("CreateCluster")+ .body("""+ {"clusterName": "%s"}+ """.formatted(CLUSTER_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("cluster.clusterName", equalTo(CLUSTER_NAME))+ .body("cluster.clusterArn", containsString(CLUSTER_NAME))+ .body("cluster.status", equalTo("ACTIVE"));+ }++ @Test+ @Order(2)+ void createClusterIdempotent() {+ ecs("CreateCluster")+ .body("""+ {"clusterName": "%s"}+ """.formatted(CLUSTER_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("cluster.clusterName", equalTo(CLUSTER_NAME));+ }++ @Test+ @Order(3)+ void describeCluster() {+ ecs("DescribeClusters")+ .body("""+ {"clusters": ["%s"]}+ """.formatted(CLUSTER_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("clusters", hasSize(1))+ .body("clusters[0].clusterName", equalTo(CLUSTER_NAME))+ .body("clusters[0].status", equalTo("ACTIVE"))+ .body("failures", empty());+ }++ @Test+ @Order(4)+ void listClusters() {+ ecs("ListClusters")+ .body("{}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("clusterArns", hasItem(containsString(CLUSTER_NAME)));+ }++ // ── Task Definitions ──────────────────────────────────────────────────────++ @Test+ @Order(10)+ void registerTaskDefinition() {+ taskDefArn = ecs("RegisterTaskDefinition")+ .body("""+ {+ "family": "%s",+ "containerDefinitions": [+ {+ "name": "app",+ "image": "nginx:latest",+ "cpu": 256,+ "memory": 512,+ "essential": true,+ "portMappings": [{"containerPort": 80, "protocol": "tcp"}]+ }+ ],+ "requiresCompatibilities": ["FARGATE"],+ "cpu": "256",+ "memory": "512",+ "networkMode": "awsvpc"+ }+ """.formatted(TASK_DEF_FAMILY))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("taskDefinition.family", equalTo(TASK_DEF_FAMILY))+ .body("taskDefinition.revision", equalTo(1))+ .body("taskDefinition.status", equalTo("ACTIVE"))+ .body("taskDefinition.taskDefinitionArn", containsString(TASK_DEF_FAMILY))+ .body("taskDefinition.containerDefinitions", hasSize(1))+ .body("taskDefinition.containerDefinitions[0].name", equalTo("app"))+ .extract()+ .path("taskDefinition.taskDefinitionArn");+ }++ @Test+ @Order(11)+ void describeTaskDefinition() {+ ecs("DescribeTaskDefinition")+ .body("""+ {"taskDefinition": "%s:1"}+ """.formatted(TASK_DEF_FAMILY))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("taskDefinition.family", equalTo(TASK_DEF_FAMILY))+ .body("taskDefinition.revision", equalTo(1))+ .body("taskDefinition.status", equalTo("ACTIVE"));+ }++ @Test+ @Order(12)+ void listTaskDefinitions() {+ ecs("ListTaskDefinitions")+ .body("{}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("taskDefinitionArns", hasItem(containsString(TASK_DEF_FAMILY)));+ }++ @Test+ @Order(13)+ void listTaskDefinitionFamilies() {+ ecs("ListTaskDefinitionFamilies")+ .body("{}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("families", hasItem(TASK_DEF_FAMILY));+ }++ // ── Tasks ─────────────────────────────────────────────────────────────────++ @Test+ @Order(20)+ void runTask() {+ taskArn = ecs("RunTask")+ .body("""+ {+ "cluster": "%s",+ "taskDefinition": "%s",+ "launchType": "FARGATE",+ "count": 1+ }+ """.formatted(CLUSTER_NAME, TASK_DEF_FAMILY))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("tasks", hasSize(1))+ .body("tasks[0].taskArn", containsString("task/"))+ .body("tasks[0].clusterArn", containsString(CLUSTER_NAME))+ .body("tasks[0].lastStatus", notNullValue())+ .body("failures", empty())+ .extract()+ .path("tasks[0].taskArn");+ }++ @Test+ @Order(21)+ void describeTask() {+ ecs("DescribeTasks")+ .body("""+ {+ "cluster": "%s",+ "tasks": ["%s"]+ }+ """.formatted(CLUSTER_NAME, taskArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("tasks", hasSize(1))+ .body("tasks[0].taskArn", equalTo(taskArn))+ .body("failures", empty());+ }++ @Test+ @Order(22)+ void listTasks() {+ ecs("ListTasks")+ .body("""+ {"cluster": "%s"}+ """.formatted(CLUSTER_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("taskArns", hasItem(taskArn));+ }++ @Test+ @Order(23)+ void stopTask() {+ ecs("StopTask")+ .body("""+ {+ "cluster": "%s",+ "task": "%s",+ "reason": "integration-test"+ }+ """.formatted(CLUSTER_NAME, taskArn))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("task.taskArn", equalTo(taskArn))+ .body("task.lastStatus", equalTo("STOPPED"));+ }++ // ── Services ──────────────────────────────────────────────────────────────++ @Test+ @Order(30)+ void createService() {+ serviceArn = ecs("CreateService")+ .body("""+ {+ "cluster": "%s",+ "serviceName": "%s",+ "taskDefinition": "%s",+ "desiredCount": 1,+ "launchType": "FARGATE"+ }+ """.formatted(CLUSTER_NAME, SERVICE_NAME, TASK_DEF_FAMILY))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("service.serviceName", equalTo(SERVICE_NAME))+ .body("service.serviceArn", containsString(SERVICE_NAME))+ .body("service.clusterArn", containsString(CLUSTER_NAME))+ .body("service.desiredCount", equalTo(1))+ .body("service.status", equalTo("ACTIVE"))+ .extract()+ .path("service.serviceArn");+ }++ @Test+ @Order(31)+ void describeService() {+ ecs("DescribeServices")+ .body("""+ {+ "cluster": "%s",+ "services": ["%s"]+ }+ """.formatted(CLUSTER_NAME, SERVICE_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("services", hasSize(1))+ .body("services[0].serviceName", equalTo(SERVICE_NAME))+ .body("services[0].status", equalTo("ACTIVE"))+ .body("failures", empty());+ }++ @Test+ @Order(32)+ void listServices() {+ ecs("ListServices")+ .body("""+ {"cluster": "%s"}+ """.formatted(CLUSTER_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("serviceArns", hasItem(containsString(SERVICE_NAME)));+ }++ @Test+ @Order(33)+ void updateService() {+ ecs("UpdateService")+ .body("""+ {+ "cluster": "%s",+ "service": "%s",+ "desiredCount": 2+ }+ """.formatted(CLUSTER_NAME, SERVICE_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("service.desiredCount", equalTo(2));+ }++ // ── Tags ─────────────────────────────────────────────────────────────────++ @Test+ @Order(40)+ void tagResource() {+ ecs("TagResource")+ .body("""+ {+ "resourceArn": "%s",+ "tags": [+ {"key": "env", "value": "test"},+ {"key": "team", "value": "platform"}+ ]+ }+ """.formatted(CLUSTER_ARN))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(41)+ void listTagsForResource() {+ ecs("ListTagsForResource")+ .body("""+ {"resourceArn": "%s"}+ """.formatted(CLUSTER_ARN))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("tags", hasSize(2))+ .body("tags.find { it.key == 'env' }.value", equalTo("test"))+ .body("tags.find { it.key == 'team' }.value", equalTo("platform"));+ }++ @Test+ @Order(42)+ void untagResource() {+ ecs("UntagResource")+ .body("""+ {+ "resourceArn": "%s",+ "tagKeys": ["env"]+ }+ """.formatted(CLUSTER_ARN))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ ecs("ListTagsForResource")+ .body("""+ {"resourceArn": "%s"}+ """.formatted(CLUSTER_ARN))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("tags", hasSize(1))+ .body("tags[0].key", equalTo("team"));+ }++ // ── Cleanup ───────────────────────────────────────────────────────────────++ @Test+ @Order(50)+ void deleteService() {+ ecs("DeleteService")+ .body("""+ {+ "cluster": "%s",+ "service": "%s",+ "force": true+ }+ """.formatted(CLUSTER_NAME, SERVICE_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("service.serviceName", equalTo(SERVICE_NAME))+ .body("service.status", equalTo("INACTIVE"));+ }++ @Test+ @Order(51)+ void deregisterTaskDefinition() {+ ecs("DeregisterTaskDefinition")+ .body("""+ {"taskDefinition": "%s:1"}+ """.formatted(TASK_DEF_FAMILY))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("taskDefinition.status", equalTo("INACTIVE"));+ }++ @Test+ @Order(52)+ void deleteCluster() {+ ecs("DeleteCluster")+ .body("""+ {"cluster": "%s"}+ """.formatted(CLUSTER_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("cluster.clusterName", equalTo(CLUSTER_NAME))+ .body("cluster.status", equalTo("INACTIVE"));+ }++ @Test+ @Order(53)+ void deleteClusterNotFound() {+ ecs("DeleteCluster")+ .body("""+ {"cluster": "non-existent-cluster"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400);+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex da8aa02549..7f76a523f8 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -96,4 +96,7 @@ floci:enabled: trueopensearch:enabled: true- mode: mock\ No newline at end of file+ mode: mock+ ecs:+ enabled: true+ mock: true\ No newline at end of file