Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ecs): honor task portMappings hostPort when launching containers (#1610)
Hector Ventura1dc48eca393e
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 61e87286ae..67a371ae8f 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@@ -120,12 +120,18 @@ public class EcsContainerManager {specBuilder.withMemoryMb(def.getMemory());}- // Add port mappings. Publish to host only in native mode; in Docker- // mode ECS consumers reach containers via the docker network IP.+ // Add port mappings. An explicit hostPort is always published to the+ // Docker host so the service is reachable at localhost:<hostPort>,+ // matching AWS bridge mode (mirrors the ECR registry's fixed-port+ // publishing). When no hostPort is requested, publish a dynamic host+ // port in native mode; in Docker mode only expose the port, since ECS+ // consumers reach containers via the docker network IP.if (def.getPortMappings() != null) {boolean publishToHost = !containerDetector.isRunningInContainer();for (PortMapping pm : def.getPortMappings()) {- if (publishToHost) {+ if (pm.hostPort() > 0) {+ specBuilder.withPortBinding(pm.containerPort(), pm.hostPort());+ } else if (publishToHost) {specBuilder.withDynamicPort(pm.containerPort());} else {specBuilder.withExposedPort(pm.containerPort());diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManagerPortMappingsTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManagerPortMappingsTest.javanew file mode 100644index 0000000000..9a4d8832fd--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsContainerManagerPortMappingsTest.java@@ -0,0 +1,131 @@+package io.github.hectorvent.floci.services.ecs.container;++import com.github.dockerjava.api.DockerClient;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.ContainerInfo;+import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;+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.PortMapping;+import io.github.hectorvent.floci.services.ecs.model.TaskDefinition;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.List;+import java.util.Map;++import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyInt;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;+import static org.mockito.Mockito.RETURNS_SELF;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.times;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * Unit tests for container {@code portMappings} handling in+ * {@link EcsContainerManager#startTask} (regression coverage for issue #1270:+ * ECS task portMappings were ignored when launching Docker containers).+ *+ * <p>An explicit {@code hostPort} is published as a fixed host port binding so+ * the service is reachable at {@code localhost:<hostPort>}, in both native and+ * in-container modes. When {@code hostPort} is 0/unset, the container gets a+ * dynamic host port in native mode and is exposed-only when Floci runs inside+ * Docker.+ *+ * <p>The container builder and lifecycle manager are mocked, so the test asserts+ * the port arguments that <em>would</em> be handed to Docker without launching+ * one — runnable under {@code mvn test} (CI) with no Docker daemon.+ */+class EcsContainerManagerPortMappingsTest {++ private ContainerBuilder containerBuilder;+ private ContainerBuilder.Builder builder;+ private ContainerLifecycleManager lifecycleManager;+ private ContainerDetector containerDetector;+ private EcsContainerManager manager;++ @BeforeEach+ void setUp() {+ builder = mock(ContainerBuilder.Builder.class, RETURNS_SELF);+ containerBuilder = mock(ContainerBuilder.class);+ when(containerBuilder.newContainer(anyString())).thenReturn(builder);++ lifecycleManager = mock(ContainerLifecycleManager.class);+ when(lifecycleManager.createAndStart(any()))+ .thenReturn(new ContainerInfo("docker-id", Map.of()));+ // resolveNetworkBindings() inspects the container after launch; deep stubs+ // make the empty-binding readback (Map.get(...) -> null) NPE-free.+ DockerClient dockerClient = mock(DockerClient.class, RETURNS_DEEP_STUBS);+ when(lifecycleManager.getDockerClient()).thenReturn(dockerClient);++ ContainerLogStreamer logStreamer = mock(ContainerLogStreamer.class);+ containerDetector = mock(ContainerDetector.class);+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ RegionResolver regionResolver = mock(RegionResolver.class);++ manager = new EcsContainerManager(containerBuilder, lifecycleManager, logStreamer,+ containerDetector, config, regionResolver);+ }++ private void startWith(List<PortMapping> portMappings) {+ ContainerDefinition app = new ContainerDefinition();+ app.setName("app");+ app.setImage("app:latest");+ app.setPortMappings(portMappings);++ TaskDefinition taskDef = new TaskDefinition();+ taskDef.setFamily("test-family");+ taskDef.setContainerDefinitions(List.of(app));++ EcsTask task = new EcsTask();+ task.setTaskArn("arn:aws:ecs:us-east-1:000000000000:task/test-cluster/abc123");++ manager.startTask(task, taskDef, List.of(), "us-east-1");+ }++ @Test+ void explicitHostPortIsPublishedAsFixedBindingInNativeMode() {+ when(containerDetector.isRunningInContainer()).thenReturn(false);++ startWith(List.of(new PortMapping(5000, 5000, "tcp")));++ // Regression guard for #1270: the requested hostPort must be honored,+ // not replaced by a dynamic (random) host port.+ verify(builder, times(1)).withPortBinding(5000, 5000);+ verify(builder, never()).withDynamicPort(5000);+ verify(builder, never()).withExposedPort(5000);+ }++ @Test+ void zeroHostPortUsesDynamicPortInNativeMode() {+ when(containerDetector.isRunningInContainer()).thenReturn(false);++ startWith(List.of(new PortMapping(8080))); // hostPort defaults to 0++ verify(builder, times(1)).withDynamicPort(8080);+ verify(builder, never()).withPortBinding(eq(8080), anyInt());+ }++ @Test+ void inContainerModePublishesExplicitHostPortAndExposesDynamic() {+ when(containerDetector.isRunningInContainer()).thenReturn(true);++ startWith(List.of(+ new PortMapping(5000, 5000, "tcp"), // explicit -> published in both modes+ new PortMapping(9090))); // dynamic -> exposed only when in-container++ verify(builder, times(1)).withPortBinding(5000, 5000);+ verify(builder, times(1)).withExposedPort(9090);+ verify(builder, never()).withDynamicPort(9090);+ verify(builder, never()).withPortBinding(eq(9090), anyInt());+ }+}