Skip to content

armgit / floci

Public Imported from GitHub
0

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