Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
index 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.java
new file mode 100644
index 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.java
index 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 {
@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) {
+ 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.java
index 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.java
new file mode 100644
index 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.java
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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"));
+ }
+}