Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ecs): register ECS service containers as ELBv2 targets (#929)
Marvelous Ikponmwosaeb1ca7b6743b
diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.javaindex bfeae28075..589683e8d2 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java@@ -1,12 +1,14 @@package io.github.hectorvent.floci.services.ecs;import io.github.hectorvent.floci.core.common.AwsErrorResponse;+import io.github.hectorvent.floci.core.common.AwsException;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.EcsLoadBalancer;import io.github.hectorvent.floci.services.ecs.model.EcsServiceModel;import io.github.hectorvent.floci.services.ecs.model.EcsTask;import io.github.hectorvent.floci.services.ecs.model.KeyValuePair;@@ -370,15 +372,59 @@ public class EcsJsonHandler {String taskDefinition = req.path("taskDefinition").asText();int desiredCount = req.path("desiredCount").asInt(1);LaunchType launchType = parseEnum(req, "launchType", LaunchType.class);+ List<EcsLoadBalancer> loadBalancers = parseLoadBalancers(req.path("loadBalancers"));EcsServiceModel svc = service.createService(cluster, serviceName, taskDefinition,- desiredCount, launchType, region);+ desiredCount, launchType, loadBalancers, region);ObjectNode resp = objectMapper.createObjectNode();resp.set("service", serviceNode(svc));return Response.ok(resp).build();}+ private List<EcsLoadBalancer> parseLoadBalancers(JsonNode node) {+ List<EcsLoadBalancer> result = new ArrayList<>();+ if (node == null || !node.isArray()) {+ return result;+ }+ for (JsonNode lb : node) {+ String targetGroupArn = lb.hasNonNull("targetGroupArn")+ ? lb.path("targetGroupArn").asText() : null;+ String loadBalancerName = lb.hasNonNull("loadBalancerName")+ ? lb.path("loadBalancerName").asText() : null;+ String containerName = lb.hasNonNull("containerName")+ ? lb.path("containerName").asText() : null;+ Integer containerPort = lb.hasNonNull("containerPort")+ ? lb.path("containerPort").asInt() : null;++ // AWS rejects malformed loadBalancers entries with InvalidParameterException.+ // containerName + containerPort are always required; an entry must target+ // either a target group (ALB/NLB) or a classic load balancer by name.+ if (containerName == null || containerName.isBlank()) {+ throw new AwsException("InvalidParameterException",+ "loadBalancers entry is missing the required containerName.", 400);+ }+ if (containerPort == null) {+ throw new AwsException("InvalidParameterException",+ "loadBalancers entry is missing the required containerPort.", 400);+ }+ boolean hasTargetGroup = targetGroupArn != null && !targetGroupArn.isBlank();+ boolean hasLoadBalancerName = loadBalancerName != null && !loadBalancerName.isBlank();+ if (!hasTargetGroup && !hasLoadBalancerName) {+ throw new AwsException("InvalidParameterException",+ "loadBalancers entry must specify either targetGroupArn or loadBalancerName.", 400);+ }++ EcsLoadBalancer m = new EcsLoadBalancer();+ m.setTargetGroupArn(targetGroupArn);+ m.setLoadBalancerName(loadBalancerName);+ m.setContainerName(containerName);+ m.setContainerPort(containerPort);+ result.add(m);+ }+ return result;+ }+private Response handleUpdateService(JsonNode req, String region) {String cluster = req.has("cluster") ? req.path("cluster").asText() : null;String serviceName = req.path("service").asText();@@ -955,6 +1001,18 @@ public class EcsJsonHandler {if (s.getTags() != null && !s.getTags().isEmpty()) {n.set("tags", tagsNode(s.getTags()));}+ if (s.getLoadBalancers() != null && !s.getLoadBalancers().isEmpty()) {+ ArrayNode lbs = objectMapper.createArrayNode();+ for (EcsLoadBalancer lb : s.getLoadBalancers()) {+ ObjectNode ln = objectMapper.createObjectNode();+ if (lb.getTargetGroupArn() != null) { ln.put("targetGroupArn", lb.getTargetGroupArn()); }+ if (lb.getLoadBalancerName() != null) { ln.put("loadBalancerName", lb.getLoadBalancerName()); }+ if (lb.getContainerName() != null) { ln.put("containerName", lb.getContainerName()); }+ if (lb.getContainerPort() != null) { ln.put("containerPort", lb.getContainerPort()); }+ lbs.add(ln);+ }+ n.set("loadBalancers", lbs);+ }return n;}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancerRegistrar.java b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancerRegistrar.javanew file mode 100644index 0000000000..d8d4372001--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancerRegistrar.java@@ -0,0 +1,100 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.services.ecs.container.EcsContainerManager;+import io.github.hectorvent.floci.services.ecs.model.Container;+import io.github.hectorvent.floci.services.ecs.model.EcsLoadBalancer;+import io.github.hectorvent.floci.services.ecs.model.EcsServiceModel;+import io.github.hectorvent.floci.services.ecs.model.EcsTask;+import io.github.hectorvent.floci.services.ecs.model.NetworkBinding;+import io.github.hectorvent.floci.services.elbv2.ElbV2Service;+import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.util.List;+import java.util.function.BiConsumer;++/**+ * Bridges ECS services to ELBv2: when an ECS service declares a {@code loadBalancers}+ * block, this registrar registers each running task container as a target in the named+ * ELBv2 target group (and deregisters it when the task stops).+ * <p>+ * One-way dependency ECS → ELBv2; the ELBv2 data plane reaches the container over plain+ * TCP and never calls back into ECS, so there is no cycle.+ */+@ApplicationScoped+public class EcsLoadBalancerRegistrar {++ private static final Logger LOG = Logger.getLogger(EcsLoadBalancerRegistrar.class);++ private final ElbV2Service elbV2Service;+ private final EcsContainerManager containerManager;++ @Inject+ public EcsLoadBalancerRegistrar(ElbV2Service elbV2Service, EcsContainerManager containerManager) {+ this.elbV2Service = elbV2Service;+ this.containerManager = containerManager;+ }++ /** Registers the task's load-balanced containers as ELBv2 targets. */+ public void registerTask(EcsTask task, EcsServiceModel svc, String region) {+ forEachTarget(task, svc, (tgArn, td) -> {+ try {+ elbV2Service.registerTargets(region, tgArn, List.of(td));+ LOG.infov("Registered ECS task target {0}:{1} into target group {2}",+ td.getId(), td.getPort(), tgArn);+ } catch (Exception e) {+ LOG.warnv("Could not register ECS target into {0}: {1}", tgArn, e.getMessage());+ }+ });+ }++ /** Deregisters the task's load-balanced containers from their ELBv2 target groups. */+ public void deregisterTask(EcsTask task, EcsServiceModel svc, String region) {+ forEachTarget(task, svc, (tgArn, td) -> {+ try {+ elbV2Service.deregisterTargets(region, tgArn, List.of(td));+ LOG.infov("Deregistered ECS task target {0}:{1} from target group {2}",+ td.getId(), td.getPort(), tgArn);+ } catch (Exception e) {+ LOG.warnv("Could not deregister ECS target from {0}: {1}", tgArn, e.getMessage());+ }+ });+ }++ private void forEachTarget(EcsTask task, EcsServiceModel svc,+ BiConsumer<String, TargetDescription> action) {+ if (svc == null || svc.getLoadBalancers() == null || svc.getLoadBalancers().isEmpty()) {+ return;+ }+ if (task.getContainers() == null || task.getContainers().isEmpty()) {+ return;+ }+ for (EcsLoadBalancer lb : svc.getLoadBalancers()) {+ if (lb.getTargetGroupArn() == null || lb.getTargetGroupArn().isBlank()) {+ continue;+ }+ Container container = task.getContainers().stream()+ .filter(c -> lb.getContainerName() == null+ || lb.getContainerName().equals(c.getName()))+ .findFirst()+ .orElse(null);+ if (container == null || container.getNetworkBindings() == null) {+ continue;+ }+ NetworkBinding binding = container.getNetworkBindings().stream()+ .filter(b -> lb.getContainerPort() == null+ || lb.getContainerPort() == b.containerPort())+ .findFirst()+ .orElse(null);+ if (binding == null) {+ continue;+ }+ TargetDescription td = new TargetDescription();+ td.setId(containerManager.resolveContainerHost(container));+ td.setPort(binding.hostPort());+ action.accept(lb.getTargetGroupArn(), td);+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.java b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.javaindex b1dd3a776f..3803825a76 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/EcsService.java@@ -11,6 +11,7 @@ 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.EcsLoadBalancer;import io.github.hectorvent.floci.services.ecs.model.EcsServiceModel;import io.github.hectorvent.floci.services.ecs.model.EcsTask;import io.github.hectorvent.floci.services.ecs.model.LaunchType;@@ -46,6 +47,7 @@ public class EcsService {private final RegionResolver regionResolver;private final EcsContainerManager containerManager;+ private final EcsLoadBalancerRegistrar lbRegistrar;private final boolean dockerMode;private final String baseUrl;private final ScheduledExecutorService reconciler = Executors.newSingleThreadScheduledExecutor(@@ -80,21 +82,12 @@ public class EcsService {@Injectpublic 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) {+ EmulatorConfig config, EcsLoadBalancerRegistrar lbRegistrar) {this.regionResolver = regionResolver;this.containerManager = containerManager;- this.dockerMode = dockerMode;- this.baseUrl = baseUrl;+ this.dockerMode = !config.services().ecs().mock();+ this.baseUrl = config.effectiveBaseUrl();+ this.lbRegistrar = lbRegistrar;}@PostConstruct@@ -301,6 +294,7 @@ public class EcsService {taskHandles.put(taskArn, handle);cluster.setRunningTasksCount(cluster.getRunningTasksCount() + 1);LOG.infov("Started ECS task (docker): {0}", taskArn);+ registerTaskWithLoadBalancers(task, cluster, group, region);} catch (Exception e) {LOG.errorv("Failed to start ECS task {0}: {1}", taskArn, e.getMessage());task.setLastStatus(TaskStatus.STOPPED.name());@@ -326,6 +320,8 @@ public class EcsService {task.setLastStatus(TaskStatus.STOPPING.name());task.setStoppedReason(reason != null ? reason : "Stopped by user");+ deregisterTaskFromLoadBalancers(task, region);+if (dockerMode) {EcsTaskHandle handle = taskHandles.remove(task.getTaskArn());containerManager.stopTask(handle);@@ -346,6 +342,34 @@ public class EcsService {return task;}+ /** Registers a freshly-started task's containers as ELBv2 targets if its service is load-balanced. */+ private void registerTaskWithLoadBalancers(EcsTask task, EcsCluster cluster, String group, String region) {+ if (group == null) {+ return;+ }+ EcsServiceModel svc = services.get(serviceKey(region, cluster.getClusterName(), group));+ if (svc != null && !svc.getLoadBalancers().isEmpty()) {+ lbRegistrar.registerTask(task, svc, region);+ }+ }++ /** Deregisters a stopping task's containers from any ELBv2 target groups its service declared. */+ private void deregisterTaskFromLoadBalancers(EcsTask task, String region) {+ // Gated on dockerMode for symmetry with the register hook (inside launchTasks'+ // dockerMode branch): mock-mode tasks have no containers and never registered.+ if (!dockerMode || task.getGroup() == null) {+ return;+ }+ EcsCluster cluster = resolveClusterByArn(task.getClusterArn());+ if (cluster == null) {+ return;+ }+ EcsServiceModel svc = services.get(serviceKey(region, cluster.getClusterName(), task.getGroup()));+ if (svc != null && !svc.getLoadBalancers().isEmpty()) {+ lbRegistrar.deregisterTask(task, svc, region);+ }+ }+public List<EcsTask> describeTasks(String clusterRef, List<String> taskRefs, String region) {List<EcsTask> result = new ArrayList<>();for (String ref : taskRefs) {@@ -405,7 +429,8 @@ public class EcsService {// ── Services ──────────────────────────────────────────────────────────────public EcsServiceModel createService(String clusterRef, String serviceName, String taskDefinition,- int desiredCount, LaunchType launchType, String region) {+ int desiredCount, LaunchType launchType,+ List<EcsLoadBalancer> loadBalancers, String region) {EcsCluster cluster = resolveClusterOrDefault(clusterRef, region);resolveTaskDefinitionOrThrow(taskDefinition, region);@@ -423,6 +448,7 @@ public class EcsService {svc.setTaskDefinition(taskDefinition);svc.setLaunchType(launchType != null ? launchType : LaunchType.FARGATE);svc.setDesiredCount(desiredCount);+ svc.setLoadBalancers(loadBalancers);svc.setStatus("ACTIVE");svc.setCreatedAt(Instant.now());@@ -463,10 +489,11 @@ public class EcsService {throw new AwsException("InvalidParameterException","The service cannot be stopped. Update the service to 0 tasks or use the force flag.", 400);}- services.remove(key);svc.setStatus("INACTIVE");svc.setDesiredCount(0);cluster.setActiveServicesCount(Math.max(0, cluster.getActiveServicesCount() - 1));+ // Stop tasks before removing the service from the map, so the per-task+ // ELBv2 deregistration hook can still resolve the service's loadBalancers.tasks.values().stream().filter(t -> t.getClusterArn().equals(cluster.getClusterArn())).filter(t -> svc.getServiceArn().equals(t.getGroup())@@ -480,6 +507,7 @@ public class EcsService {t.getTaskArn(), e.getMessage());}});+ services.remove(key);return svc;}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.javaindex 1e2123c2ff..65ea65d54f 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManager.java@@ -173,6 +173,64 @@ public class EcsContainerManager {return envVars;}+ /**+ * Resolves the host address at which a running task container is reachable from the+ * Floci process — used to register the container as an ELBv2 target.+ * <p>+ * Native mode: the container's port is published to a host port, reachable at+ * {@code 127.0.0.1}. Floci-in-Docker mode: the container is reached by its IP on the+ * shared Docker network. Returns {@code 127.0.0.1} as a safe fallback.+ */+ public String resolveContainerHost(Container container) {+ if (!containerDetector.isRunningInContainer()) {+ return "127.0.0.1";+ }+ String dockerId = container.getDockerId();+ if (dockerId == null || dockerId.isBlank()) {+ return "127.0.0.1";+ }+ try {+ var inspect = lifecycleManager.getDockerClient().inspectContainerCmd(dockerId).exec();+ var networks = inspect.getNetworkSettings().getNetworks();++ // A container can be on multiple networks; getNetworks() is unordered.+ // Pick an IP that the Floci/ELBv2 process can actually route to:+ // 1. the explicitly-configured ECS Docker network, if set;+ // 2. otherwise any user-defined network (Floci joins one when in Docker)+ // in preference to the default bridge;+ // 3. otherwise the first non-blank IP.+ String configured = config.services().ecs().dockerNetwork().orElse(null);+ if (configured != null && !configured.isBlank()) {+ var net = networks.get(configured);+ if (net != null && isUsableIp(net.getIpAddress())) {+ return net.getIpAddress();+ }+ }+ for (var entry : networks.entrySet()) {+ if (!isDefaultDockerNetwork(entry.getKey())+ && isUsableIp(entry.getValue().getIpAddress())) {+ return entry.getValue().getIpAddress();+ }+ }+ for (var net : networks.values()) {+ if (isUsableIp(net.getIpAddress())) {+ return net.getIpAddress();+ }+ }+ } catch (Exception e) {+ LOG.warnv("Could not resolve container IP for {0}: {1}", dockerId, e.getMessage());+ }+ return "127.0.0.1";+ }++ private static boolean isUsableIp(String ip) {+ return ip != null && !ip.isBlank();+ }++ private static boolean isDefaultDockerNetwork(String name) {+ return "bridge".equals(name) || "host".equals(name) || "none".equals(name);+ }+private List<NetworkBinding> resolveNetworkBindings(String dockerId, ContainerDefinition def) {List<NetworkBinding> bindings = new ArrayList<>();if (def.getPortMappings() == null || def.getPortMappings().isEmpty()) {diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsLoadBalancer.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsLoadBalancer.javanew file mode 100644index 0000000000..afa023baa6--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsLoadBalancer.java@@ -0,0 +1,31 @@+package io.github.hectorvent.floci.services.ecs.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * A load balancer association on an ECS service ({@code CreateService}'s+ * {@code loadBalancers} block). Links a container port on the service's tasks+ * to an ELBv2 target group so running task containers can be registered as targets.+ */+@RegisterForReflection+public class EcsLoadBalancer {++ private String targetGroupArn;+ private String loadBalancerName;+ private String containerName;+ private Integer containerPort;++ public EcsLoadBalancer() {}++ public String getTargetGroupArn() { return targetGroupArn; }+ public void setTargetGroupArn(String targetGroupArn) { this.targetGroupArn = targetGroupArn; }++ public String getLoadBalancerName() { return loadBalancerName; }+ public void setLoadBalancerName(String loadBalancerName) { this.loadBalancerName = loadBalancerName; }++ public String getContainerName() { return containerName; }+ public void setContainerName(String containerName) { this.containerName = containerName; }++ public Integer getContainerPort() { return containerPort; }+ public void setContainerPort(Integer containerPort) { this.containerPort = containerPort; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.java b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.javaindex 8bb94651c9..2aaf3b1904 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/model/EcsServiceModel.java@@ -3,7 +3,9 @@ package io.github.hectorvent.floci.services.ecs.model;import io.quarkus.runtime.annotations.RegisterForReflection;import java.time.Instant;+import java.util.ArrayList;import java.util.HashMap;+import java.util.List;import java.util.Map;@RegisterForReflection@@ -22,6 +24,7 @@ public class EcsServiceModel {private String namespace;private String deploymentController;private Map<String, String> tags = new HashMap<>();+ private List<EcsLoadBalancer> loadBalancers = new ArrayList<>();public String getServiceArn() { return serviceArn; }public void setServiceArn(String serviceArn) { this.serviceArn = serviceArn; }@@ -61,4 +64,9 @@ public class EcsServiceModel {public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags; }++ public List<EcsLoadBalancer> getLoadBalancers() { return loadBalancers; }+ public void setLoadBalancers(List<EcsLoadBalancer> loadBalancers) {+ this.loadBalancers = loadBalancers != null ? loadBalancers : new ArrayList<>();+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancerRegistrarTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancerRegistrarTest.javanew file mode 100644index 0000000000..387d898948--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancerRegistrarTest.java@@ -0,0 +1,109 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.services.ecs.model.Container;+import io.github.hectorvent.floci.services.ecs.model.EcsLoadBalancer;+import io.github.hectorvent.floci.services.ecs.model.EcsServiceModel;+import io.github.hectorvent.floci.services.ecs.model.EcsTask;+import io.github.hectorvent.floci.services.ecs.model.NetworkBinding;+import io.github.hectorvent.floci.services.elbv2.ElbV2Service;+import io.github.hectorvent.floci.services.elbv2.model.TargetGroup;+import io.github.hectorvent.floci.services.elbv2.model.TargetHealth;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Component test for {@link EcsLoadBalancerRegistrar}: drives the register/deregister+ * logic directly with a synthetic task and a real {@link ElbV2Service}, since ECS runs+ * in mock mode (no Docker containers) under {@code @QuarkusTest}.+ */+@QuarkusTest+class EcsLoadBalancerRegistrarTest {++ private static final String REGION = "us-east-1";++ @Inject+ EcsLoadBalancerRegistrar registrar;++ @Inject+ ElbV2Service elbV2Service;++ private String createTargetGroup(String name) {+ TargetGroup tg = elbV2Service.createTargetGroup(REGION, name, "HTTP", "HTTP1",+ 8080, "vpc-regtest", "ip",+ null, null, false, null, null, null, null, null, null, null, Map.of());+ return tg.getTargetGroupArn();+ }++ private EcsTask taskWithContainer(String containerName, int containerPort, int hostPort) {+ Container container = new Container();+ container.setName(containerName);+ container.setNetworkBindings(List.of(+ new NetworkBinding("0.0.0.0", containerPort, hostPort, "tcp")));+ EcsTask task = new EcsTask();+ task.setTaskArn("arn:aws:ecs:" + REGION + ":000000000000:task/c/regtest");+ task.setGroup("regtest-svc");+ task.setContainers(List.of(container));+ return task;+ }++ private EcsServiceModel serviceWithLb(String tgArn, String containerName, int containerPort) {+ EcsLoadBalancer lb = new EcsLoadBalancer();+ lb.setTargetGroupArn(tgArn);+ lb.setContainerName(containerName);+ lb.setContainerPort(containerPort);+ EcsServiceModel svc = new EcsServiceModel();+ svc.setServiceName("regtest-svc");+ svc.setLoadBalancers(List.of(lb));+ return svc;+ }++ @Test+ void registerThenDeregisterTaskContainer() {+ String tgArn = createTargetGroup("reg-tg-1");+ EcsTask task = taskWithContainer("web", 8080, 34567);+ EcsServiceModel svc = serviceWithLb(tgArn, "web", 8080);++ registrar.registerTask(task, svc, REGION);++ List<TargetHealth> health = elbV2Service.describeTargetHealth(REGION, tgArn, null);+ assertEquals(1, health.size(), "one target should be registered");+ // ECS containers are reached at 127.0.0.1:<hostPort> in native mode.+ assertEquals("127.0.0.1", health.get(0).getTarget().getId());+ assertEquals(34567, health.get(0).getTarget().getPort());++ registrar.deregisterTask(task, svc, REGION);+ assertTrue(elbV2Service.describeTargetHealth(REGION, tgArn, null).isEmpty(),+ "target should be deregistered");+ }++ @Test+ void serviceWithoutLoadBalancersRegistersNothing() {+ String tgArn = createTargetGroup("reg-tg-2");+ EcsTask task = taskWithContainer("web", 8080, 40000);+ EcsServiceModel svc = new EcsServiceModel(); // no loadBalancers+ svc.setServiceName("regtest-svc");++ registrar.registerTask(task, svc, REGION);+ assertTrue(elbV2Service.describeTargetHealth(REGION, tgArn, null).isEmpty(),+ "no loadBalancers block -> no target registered");+ }++ @Test+ void containerPortMismatchRegistersNothing() {+ String tgArn = createTargetGroup("reg-tg-3");+ // task container exposes 8080, but the loadBalancers block points at 9999+ EcsTask task = taskWithContainer("web", 8080, 41000);+ EcsServiceModel svc = serviceWithLb(tgArn, "web", 9999);++ registrar.registerTask(task, svc, REGION);+ assertTrue(elbV2Service.describeTargetHealth(REGION, tgArn, null).isEmpty(),+ "no network binding for the declared containerPort -> no target");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancersIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancersIntegrationTest.javanew file mode 100644index 0000000000..fab49bf455--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/EcsLoadBalancersIntegrationTest.java@@ -0,0 +1,136 @@+package io.github.hectorvent.floci.services.ecs;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.notNullValue;++/**+ * Integration tests for the ECS service {@code loadBalancers} block (mock mode).+ * Verifies the field is parsed on CreateService and echoed on DescribeServices.+ * Actual ELBv2 target registration requires Docker-backed tasks and is covered by+ * {@link EcsLoadBalancerRegistrarTest} (registrar logic) and the end-to-end scenario.+ */+@QuarkusTest+class EcsLoadBalancersIntegrationTest {++ private static final String TARGET = "AmazonEC2ContainerServiceV20141113.";+ private static final String CT = "application/x-amz-json-1.1";++ @BeforeAll+ static void configure() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ private static void call(String action, String body) {+ given().contentType(CT).header("X-Amz-Target", TARGET + action)+ .body(body)+ .when().post("/")+ .then().statusCode(200);+ }++ private void seedClusterAndTaskDef(String cluster, String family) {+ call("CreateCluster", "{\"clusterName\":\"" + cluster + "\"}");+ call("RegisterTaskDefinition", "{\"family\":\"" + family + "\","+ + "\"containerDefinitions\":[{\"name\":\"web\",\"image\":\"nginx\","+ + "\"memory\":128,\"portMappings\":[{\"containerPort\":8080}]}]}");+ }++ @Test+ void createServiceParsesAndEchoesLoadBalancers() {+ seedClusterAndTaskDef("lb-cluster-1", "lb-td-1");+ String tgArn = "arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/lbtg1/abc123";++ given().contentType(CT).header("X-Amz-Target", TARGET + "CreateService")+ .body("{\"cluster\":\"lb-cluster-1\",\"serviceName\":\"lb-svc-1\","+ + "\"taskDefinition\":\"lb-td-1\",\"desiredCount\":1,"+ + "\"loadBalancers\":[{\"targetGroupArn\":\"" + tgArn + "\","+ + "\"containerName\":\"web\",\"containerPort\":8080}]}")+ .when().post("/")+ .then().statusCode(200)+ .body("service.serviceName", equalTo("lb-svc-1"))+ .body("service.loadBalancers", hasSize(1))+ .body("service.loadBalancers[0].targetGroupArn", equalTo(tgArn))+ .body("service.loadBalancers[0].containerName", equalTo("web"))+ .body("service.loadBalancers[0].containerPort", equalTo(8080));+ }++ @Test+ void describeServicesEchoesLoadBalancers() {+ seedClusterAndTaskDef("lb-cluster-2", "lb-td-2");+ String tgArn = "arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/lbtg2/def456";+ call("CreateService", "{\"cluster\":\"lb-cluster-2\",\"serviceName\":\"lb-svc-2\","+ + "\"taskDefinition\":\"lb-td-2\",\"desiredCount\":1,"+ + "\"loadBalancers\":[{\"targetGroupArn\":\"" + tgArn + "\","+ + "\"containerName\":\"web\",\"containerPort\":8080}]}");++ given().contentType(CT).header("X-Amz-Target", TARGET + "DescribeServices")+ .body("{\"cluster\":\"lb-cluster-2\",\"services\":[\"lb-svc-2\"]}")+ .when().post("/")+ .then().statusCode(200)+ .body("services", hasSize(1))+ .body("services[0].loadBalancers", hasSize(1))+ .body("services[0].loadBalancers[0].targetGroupArn", equalTo(tgArn));+ }++ @Test+ void createServiceWithoutLoadBalancersOmitsField() {+ seedClusterAndTaskDef("lb-cluster-3", "lb-td-3");+ given().contentType(CT).header("X-Amz-Target", TARGET + "CreateService")+ .body("{\"cluster\":\"lb-cluster-3\",\"serviceName\":\"lb-svc-3\","+ + "\"taskDefinition\":\"lb-td-3\",\"desiredCount\":1}")+ .when().post("/")+ .then().statusCode(200)+ .body("service.serviceName", equalTo("lb-svc-3"))+ .body("service.loadBalancers", org.hamcrest.Matchers.nullValue());+ }++ @Test+ void createServiceRejectsLoadBalancerEntryMissingRequiredFields() {+ seedClusterAndTaskDef("lb-cluster-5", "lb-td-5");+ // entry has containerName but no containerPort and no targetGroupArn/loadBalancerName+ given().contentType(CT).header("X-Amz-Target", TARGET + "CreateService")+ .body("{\"cluster\":\"lb-cluster-5\",\"serviceName\":\"lb-svc-5\","+ + "\"taskDefinition\":\"lb-td-5\",\"desiredCount\":1,"+ + "\"loadBalancers\":[{\"containerName\":\"web\"}]}")+ .when().post("/")+ .then().statusCode(400)+ .body("__type", org.hamcrest.Matchers.containsString("InvalidParameterException"));+ }++ @Test+ void createServiceRejectsLoadBalancerEntryWithoutTargetGroup() {+ seedClusterAndTaskDef("lb-cluster-6", "lb-td-6");+ // containerName + containerPort present, but neither targetGroupArn nor loadBalancerName+ given().contentType(CT).header("X-Amz-Target", TARGET + "CreateService")+ .body("{\"cluster\":\"lb-cluster-6\",\"serviceName\":\"lb-svc-6\","+ + "\"taskDefinition\":\"lb-td-6\",\"desiredCount\":1,"+ + "\"loadBalancers\":[{\"containerName\":\"web\",\"containerPort\":8080}]}")+ .when().post("/")+ .then().statusCode(400)+ .body("__type", org.hamcrest.Matchers.containsString("InvalidParameterException"));+ }++ @Test+ void serviceWithLoadBalancersIsStableInMockMode() {+ // Mock mode launches no real containers; the registrar must no-op cleanly.+ seedClusterAndTaskDef("lb-cluster-4", "lb-td-4");+ String tgArn = "arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/lbtg4/ghi789";+ call("CreateService", "{\"cluster\":\"lb-cluster-4\",\"serviceName\":\"lb-svc-4\","+ + "\"taskDefinition\":\"lb-td-4\",\"desiredCount\":1,"+ + "\"loadBalancers\":[{\"targetGroupArn\":\"" + tgArn + "\","+ + "\"containerName\":\"web\",\"containerPort\":8080}]}");+ // Service is describable and intact — no crash from the registrar hook.+ given().contentType(CT).header("X-Amz-Target", TARGET + "DescribeServices")+ .body("{\"cluster\":\"lb-cluster-4\",\"services\":[\"lb-svc-4\"]}")+ .when().post("/")+ .then().statusCode(200)+ .body("services[0].serviceArn", notNullValue())+ .body("services[0].status", equalTo("ACTIVE"));+ }+}