Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): register an ECS task definition's containers with their LinuxParameters (#6027)
Alessandro Lattaoe38ec02d4413
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationEcsLinuxParametersTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationEcsLinuxParametersTest.javanew file mode 100644index 0000000000..e8ccff833e--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationEcsLinuxParametersTest.java@@ -0,0 +1,99 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.cloudformation.CloudFormationClient;+import software.amazon.awssdk.services.cloudformation.model.StackEvent;+import software.amazon.awssdk.services.ecs.EcsClient;+import software.amazon.awssdk.services.ecs.model.ContainerDefinition;+import software.amazon.awssdk.services.ecs.model.LinuxParameters;+import software.amazon.awssdk.services.ecs.model.Tmpfs;++import java.time.Duration;+import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;++/**+ * A container's {@code LinuxParameters} in an {@code AWS::ECS::TaskDefinition} reach the task+ * definition, as the ECS SDK reads it back, and a Fargate template asking for swap fails as+ * {@code RegisterTaskDefinition} refuses it.+ */+@DisplayName("CloudFormation AWS::ECS::TaskDefinition LinuxParameters")+class CloudFormationEcsLinuxParametersTest {++ private static final Duration DEPLOY_TIMEOUT =+ TestFixtures.isRealAws() ? Duration.ofMinutes(10) : Duration.ofSeconds(10);+ private static final String LINUX_STACK = TestFixtures.uniqueName("compat-cfn-linux");+ private static final String FARGATE_STACK = TestFixtures.uniqueName("compat-cfn-linux-fargate");++ private static CloudFormationClient cloudFormation;+ private static EcsClient ecs;++ @BeforeAll+ static void setup() {+ cloudFormation = TestFixtures.cloudFormationClient();+ ecs = TestFixtures.ecsClient();+ }++ @AfterAll+ static void cleanup() {+ if (cloudFormation != null) {+ // DeleteStack answers for a stack that is gone too, so a failure here is a real one.+ cloudFormation.deleteStack(r -> r.stackName(LINUX_STACK));+ cloudFormation.deleteStack(r -> r.stackName(FARGATE_STACK));+ cloudFormation.close();+ }+ if (ecs != null) {+ ecs.close();+ }+ }++ @Test+ void linuxParametersReachTheTaskDefinition() throws InterruptedException {+ String name = LINUX_STACK;+ cloudFormation.createStack(r -> r.stackName(name).templateBody("""+ {"Resources": {"TaskDef": {"Type": "AWS::ECS::TaskDefinition", "Properties": {+ "Family": "%s", "RequiresCompatibilities": ["EC2"], "NetworkMode": "bridge",+ "ContainerDefinitions": [{"Name": "worker", "Image": "busybox", "Memory": 512,+ "LinuxParameters": {"InitProcessEnabled": true,+ "Capabilities": {"Add": ["SYS_PTRACE"], "Drop": ["NET_RAW"]},+ "SharedMemorySize": 256, "MaxSwap": 1024, "Swappiness": 10,+ "Tmpfs": [{"ContainerPath": "/scratch", "Size": 64, "MountOptions": ["noexec"]}]}}]}}}}+ """.formatted(name)));+ assertThat(TestFixtures.awaitStackTerminal(cloudFormation, name, DEPLOY_TIMEOUT)).isEqualTo("CREATE_COMPLETE");++ ContainerDefinition container = ecs.describeTaskDefinition(r -> r.taskDefinition(name))+ .taskDefinition().containerDefinitions().get(0);+ LinuxParameters linux = container.linuxParameters();+ assertThat(linux.initProcessEnabled()).isTrue();+ assertThat(linux.capabilities().add()).containsExactly("SYS_PTRACE");+ assertThat(linux.capabilities().drop()).containsExactly("NET_RAW");+ assertThat(linux.sharedMemorySize()).isEqualTo(256);+ assertThat(linux.maxSwap()).isEqualTo(1024);+ assertThat(linux.swappiness()).isEqualTo(10);+ Tmpfs tmpfs = linux.tmpfs().get(0);+ assertThat(tmpfs.containerPath()).isEqualTo("/scratch");+ assertThat(tmpfs.size()).isEqualTo(64);+ assertThat(tmpfs.mountOptions()).containsExactly("noexec");+ }++ @Test+ void aFargateTemplateAskingForSwapFailsAsRegisterTaskDefinitionDoes() throws InterruptedException {+ String name = FARGATE_STACK;+ cloudFormation.createStack(r -> r.stackName(name).templateBody("""+ {"Resources": {"TaskDef": {"Type": "AWS::ECS::TaskDefinition", "Properties": {+ "Family": "%s", "RequiresCompatibilities": ["FARGATE"], "NetworkMode": "awsvpc",+ "Cpu": "256", "Memory": "512",+ "ContainerDefinitions": [{"Name": "worker", "Image": "busybox",+ "LinuxParameters": {"MaxSwap": 512, "Swappiness": 10}}]}}}}+ """.formatted(name)));+ assertThat(TestFixtures.awaitStackTerminal(cloudFormation, name, DEPLOY_TIMEOUT)).isEqualTo("ROLLBACK_COMPLETE");++ List<StackEvent> events = cloudFormation.describeStackEvents(r -> r.stackName(name)).stackEvents();+ assertThat(events).anySatisfy(event -> assertThat(event.resourceStatusReason())+ .contains("Fargate compatible task definitions do not support maxSwap"));+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationEcsTaskDefinitionModelTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationEcsTaskDefinitionModelTest.javaindex 2f8d79c7ac..3de102fe16 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationEcsTaskDefinitionModelTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationEcsTaskDefinitionModelTest.java@@ -25,7 +25,8 @@ import static org.assertj.core.api.Assertions.assertThat;@DisplayName("CloudFormation ECS task definition model")class CloudFormationEcsTaskDefinitionModelTest {- private static final Duration DEPLOY_TIMEOUT = Duration.ofSeconds(60);+ private static final Duration DEPLOY_TIMEOUT =+ TestFixtures.isRealAws() ? Duration.ofMinutes(10) : Duration.ofSeconds(10);private static final String UNCONVERTED_STACK = TestFixtures.uniqueName("compat-cfn-ecs-unconverted");private static final String CONVERTED_STACK = TestFixtures.uniqueName("compat-cfn-ecs-converted");private static final String HINT = ". This may occur when a numeric value exceeds 32-bit integer max"diff --git a/docs/services/ecs.md b/docs/services/ecs.mdindex 4e9fbc1c18..8fe58cce89 100644--- a/docs/services/ecs.md+++ b/docs/services/ecs.md@@ -70,7 +70,12 @@ such as `proxyConfiguration`, `ulimits`, `resourceRequirements`,`systemControls` and placement constraints, is kept verbatim and returned as registered. A clientthat reads back what it wrote (Terraform, or a deploy tool verifying its own`RegisterTaskDefinition`) sees no drift. `runtimePlatform` does not change where a local task-runs: Floci launches every task on the host's own architecture.+runs: Floci launches every task on the host's own architecture. An `AWS::ECS::TaskDefinition` in a+CloudFormation template carries its containers' `LinuxParameters` into the same place, read as the+ECS handler reads them (see [CloudFormation](cloudformation.md#ecs-task-definitions)), so they are+returned in the API's shape and checked against the Fargate rules below exactly as if the task+definition had been registered through the API. As CloudFormation's handler does, it sends the+`devices` and `tmpfs` lists empty when the template has none.The round trip reaches inside the members Floci does parse. A port mapping keeps its `name`,`appProtocol` and `containerPortRange`, which is what a service's `serviceConnectConfiguration`diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCfnProvisioner.javaindex 603bf1ce28..693791182e 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCfnProvisioner.java@@ -352,6 +352,12 @@ public class EcsCfnProvisioner implements CfnResourceProvisioner {def.setSecrets(parseSecrets(item.path("Secrets")));def.setLogConfiguration(parseLogConfiguration(item.path("LogConfiguration")));def.setFirelensConfiguration(parseFirelensConfiguration(item.path("FirelensConfiguration")));+ Map<String, Object> linuxParameters = parseLinuxParameters(item.path("LinuxParameters"));+ if (linuxParameters != null) {+ Map<String, Object> unparsed = new LinkedHashMap<>();+ unparsed.put("linuxParameters", linuxParameters);+ def.setUnparsed(unparsed);+ }if (item.path("Command").isArray()) {def.setCommand(toStringList(item.path("Command")));}@@ -372,6 +378,68 @@ public class EcsCfnProvisioner implements CfnResourceProvisioner {node.has("SecretOptions") ? parseSecrets(node.path("SecretOptions")) : null);}+ /**+ * A container's {@code LinuxParameters}, read as the ECS handler reads them, in the shape+ * RegisterTaskDefinition takes them, and kept where that path keeps them: among the+ * definition's unparsed members, under {@code linuxParameters}. So DescribeTaskDefinition shows+ * them and the Fargate rules on them apply, as for a definition registered through the API.+ * The devices and tmpfs lists are always sent, empty when the template has none, as+ * CloudFormation's handler sends them (measured).+ */+ private static Map<String, Object> parseLinuxParameters(JsonNode node) {+ if (!node.isObject()) {+ return null;+ }+ Map<String, Object> result = new LinkedHashMap<>();+ JsonNode capabilities = node.path("Capabilities");+ if (capabilities.isObject()) {+ Map<String, Object> kernelCapabilities = new LinkedHashMap<>();+ putStringList(kernelCapabilities, "add", capabilities.path("Add"));+ putStringList(kernelCapabilities, "drop", capabilities.path("Drop"));+ result.put("capabilities", kernelCapabilities);+ }+ List<Map<String, Object>> devices = new ArrayList<>();+ for (JsonNode item : node.path("Devices")) {+ Map<String, Object> device = new LinkedHashMap<>();+ putValue(device, "hostPath", item.path("HostPath"));+ putValue(device, "containerPath", item.path("ContainerPath"));+ putStringList(device, "permissions", item.path("Permissions"));+ devices.add(device);+ }+ result.put("devices", devices);+ putValue(result, "initProcessEnabled", node.path("InitProcessEnabled"));+ putValue(result, "maxSwap", node.path("MaxSwap"));+ putValue(result, "sharedMemorySize", node.path("SharedMemorySize"));+ putValue(result, "swappiness", node.path("Swappiness"));+ List<Map<String, Object>> mounts = new ArrayList<>();+ for (JsonNode item : node.path("Tmpfs")) {+ Map<String, Object> mount = new LinkedHashMap<>();+ putValue(mount, "containerPath", item.path("ContainerPath"));+ putStringList(mount, "mountOptions", item.path("MountOptions"));+ putValue(mount, "size", item.path("Size"));+ mounts.add(mount);+ }+ result.put("tmpfs", mounts);+ return result;+ }++ /** A member the template sets, as the text, integer or boolean the handler converted it to. */+ private static void putValue(Map<String, Object> target, String key, JsonNode value) {+ if (value.isTextual()) {+ target.put(key, value.textValue());+ } else if (value.isInt()) {+ target.put(key, value.intValue());+ } else if (value.isBoolean()) {+ target.put(key, value.booleanValue());+ }+ }++ private static void putStringList(Map<String, Object> target, String key, JsonNode value) {+ if (value.isArray()) {+ target.put(key, toStringList(value));+ }+ }+private static FirelensConfiguration parseFirelensConfiguration(JsonNode node) {if (node == null || !node.isObject() || !node.hasNonNull("Type")) {return null;diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsLinuxParametersIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsLinuxParametersIntegrationTest.javanew file mode 100644index 0000000000..7fb7482119--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEcsLinuxParametersIntegrationTest.java@@ -0,0 +1,217 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.List;+import java.util.Map;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasKey;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * An {@code AWS::ECS::TaskDefinition} container's {@code LinuxParameters} reach the task+ * definition as RegisterTaskDefinition keeps them: DescribeTaskDefinition shows them in the API's+ * shape, and the Fargate rules RegisterTaskDefinition applies to them apply to a template too.+ */+@QuarkusTest+@TestProfile(CloudFormationEcsLinuxParametersIntegrationTest.DeviceProfile.class)+class CloudFormationEcsLinuxParametersIntegrationTest {++ /**+ * Floci refuses a host path outside {@code floci.services.ecs.host-volume-roots} by default; the+ * template's device, {@code /dev/fuse}, is let through.+ */+ public static final class DeviceProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.ecs.host-volume-roots", "/dev/fuse");+ }+ }++ private static final String ECS_CT = "application/x-amz-json-1.1";+ private static final String ECS_TARGET = "AmazonEC2ContainerServiceV20141113.";++ /**+ * The stacks a test asked for, each named afresh per run so a run never meets another run's.+ * They are deleted after each test, and a delete CloudFormation does not accept fails there,+ * reported apart from the test's own failure; deleting a stack that was never created answers+ * 200 and is a no-op.+ */+ private final List<String> stacksToDelete = new ArrayList<>();++ @AfterEach+ void deleteStacks() {+ for (String name : stacksToDelete) {+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteStack")+ .formParam("StackName", name)+ .when().post("/").then().statusCode(200);+ CfnStackWaits.awaitStackDeleted(name);+ }+ stacksToDelete.clear();+ }++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void linuxParametersReachTheTaskDefinition() {+ String name = "cfn-linux-parameters-" + System.nanoTime();+ String template = """+ {+ "Parameters": {"Shm": {"Type": "Number", "Default": "256"}},+ "Resources": {+ "TaskDef": {+ "Type": "AWS::ECS::TaskDefinition",+ "Properties": {+ "Family": "%s",+ "RequiresCompatibilities": ["EC2"],+ "NetworkMode": "bridge",+ "ContainerDefinitions": [+ {+ "Name": "worker", "Image": "busybox", "Memory": 512,+ "LinuxParameters": {+ "InitProcessEnabled": true,+ "Capabilities": {"Add": ["SYS_PTRACE"], "Drop": ["NET_RAW"]},+ "Devices": [{"HostPath": "/dev/fuse", "ContainerPath": "/dev/fuse",+ "Permissions": ["read", "write"]}],+ "SharedMemorySize": {"Ref": "Shm"},+ "MaxSwap": 1024,+ "Swappiness": 10,+ "Tmpfs": [{"ContainerPath": "/scratch", "Size": 64, "MountOptions": ["noexec"]}]+ }+ },+ {"Name": "plain", "Image": "busybox", "Memory": 128, "Essential": false}+ ]+ }+ }+ }+ }+ """;+ stacksToDelete.add(name);+ createStack(name, template.formatted(name));+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(name).status());++ given().contentType(ECS_CT)+ .header("X-Amz-Target", ECS_TARGET + "DescribeTaskDefinition")+ .body("{\"taskDefinition\":\"" + name + "\"}")+ .when().post("/").then().statusCode(200)+ .body("taskDefinition.containerDefinitions[0].name", equalTo("worker"))+ .body("taskDefinition.containerDefinitions[0].linuxParameters", equalTo(Map.of(+ "initProcessEnabled", true,+ "capabilities", Map.of("add", List.of("SYS_PTRACE"), "drop", List.of("NET_RAW")),+ "devices", List.of(Map.of("hostPath", "/dev/fuse", "containerPath", "/dev/fuse",+ "permissions", List.of("read", "write"))),+ "sharedMemorySize", 256,+ "maxSwap", 1024,+ "swappiness", 10,+ "tmpfs", List.of(Map.of("containerPath", "/scratch", "size", 64,+ "mountOptions", List.of("noexec"))))))+ .body("taskDefinition.containerDefinitions[1].name", equalTo("plain"))+ .body("taskDefinition.containerDefinitions[1]", not(hasKey("linuxParameters")));+ }++ @Test+ void aFargateTemplateAskingForSwapFailsAsRegisterTaskDefinitionDoes() {+ String name = "cfn-linux-parameters-fargate-" + System.nanoTime();+ String template = """+ {+ "Resources": {+ "TaskDef": {+ "Type": "AWS::ECS::TaskDefinition",+ "Properties": {+ "Family": "%s",+ "RequiresCompatibilities": ["FARGATE"],+ "NetworkMode": "awsvpc",+ "Cpu": "256",+ "Memory": "512",+ "ContainerDefinitions": [+ {"Name": "worker", "Image": "busybox", "LinuxParameters": {"MaxSwap": 512, "Swappiness": 10}}+ ]+ }+ }+ }+ }+ """;+ stacksToDelete.add(name);+ createStack(name, template.formatted(name));+ assertFargateSwapRefused(name, CfnStackWaits.awaitTerminal(name));+ }++ /**+ * Measured (eu-west-1, 2026-10-16): AWS::NoValue in a list leaves its entry out, and the devices+ * and tmpfs lists are registered empty when the template has none.+ */+ @Test+ void aNoValueInAListLeavesItsEntryOut() {+ String name = "cfn-linux-parameters-novalue-" + System.nanoTime();+ String template = """+ {+ "Conditions": {"Never": {"Fn::Equals": ["a", "b"]}},+ "Resources": {+ "TaskDef": {+ "Type": "AWS::ECS::TaskDefinition",+ "Properties": {+ "Family": "%s",+ "RequiresCompatibilities": ["EC2"],+ "ContainerDefinitions": [{+ "Name": "worker", "Image": "busybox", "Memory": 512,+ "LinuxParameters": {+ "Capabilities": {+ "Add": [{"Fn::If": ["Never", "SYS_PTRACE", {"Ref": "AWS::NoValue"}]}],+ "Drop": ["NET_RAW", {"Fn::If": ["Never", "MKNOD", {"Ref": "AWS::NoValue"}]}]},+ "Devices": [{"Fn::If": ["Never", {"HostPath": "/dev/null"}, {"Ref": "AWS::NoValue"}]}]+ }+ }]+ }+ }+ }+ }+ """;+ stacksToDelete.add(name);+ createStack(name, template.formatted(name));+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(name).status());++ given().contentType(ECS_CT)+ .header("X-Amz-Target", ECS_TARGET + "DescribeTaskDefinition")+ .body("{\"taskDefinition\":\"" + name + "\"}")+ .when().post("/").then().statusCode(200)+ .body("taskDefinition.containerDefinitions[0].linuxParameters", equalTo(Map.of(+ "capabilities", Map.of("add", List.of(), "drop", List.of("NET_RAW")),+ "devices", List.of(),+ "tmpfs", List.of())));+ }++ private static void assertFargateSwapRefused(String name, CfnStackWaits.StackState state) {+ assertEquals("ROLLBACK_COMPLETE", state.status());+ List<String> reasons = given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeStackEvents")+ .formParam("StackName", name)+ .when().post("/").then().statusCode(200).extract().xmlPath()+ .getList("**.findAll { it.name() == 'ResourceStatusReason' }", String.class);+ assertTrue(reasons.stream().anyMatch(reason -> reason != null+ && reason.contains("Fargate compatible task definitions do not support maxSwap")),+ reasons.toString());+ }++ private static void createStack(String name, String template) {+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", name)+ .formParam("TemplateBody", template)+ .when().post("/").then().statusCode(200);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCfnProvisionerTest.javaindex 0625723f29..fd38ab9e98 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EcsCfnProvisionerTest.java@@ -23,6 +23,7 @@ import org.mockito.InOrder;import java.util.ArrayList;import java.util.HashMap;import java.util.List;+import java.util.Map;import java.util.Set;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -231,6 +232,84 @@ class EcsCfnProvisionerTest {verifyNoMoreInteractions(ecs);}+ @Test+ void containerLinuxParametersReachTheTaskDefinitionInTheApiShape() {+ TaskDefinition td = new TaskDefinition();+ td.setTaskDefinitionArn(TASK_DEF_ARN);+ when(ecs.registerTaskDefinition(anyString(), anyList(), any(), any(), any(), any(), any(), anyList(),+ eq(REGION))).thenReturn(td);++ ObjectNode props = mapper.createObjectNode().put("Family", "web");+ ObjectNode container = props.putArray("ContainerDefinitions").addObject()+ .put("Name", "app").put("Image", "nginx:1");+ ObjectNode linux = container.putObject("LinuxParameters")+ .put("InitProcessEnabled", true).put("MaxSwap", 512).put("SharedMemorySize", 256)+ .put("Swappiness", 10);+ ObjectNode capabilities = linux.putObject("Capabilities");+ capabilities.putArray("Add").add("SYS_PTRACE");+ capabilities.putArray("Drop").add("NET_RAW").add("MKNOD");+ ObjectNode device = linux.putArray("Devices").addObject()+ .put("HostPath", "/dev/fuse").put("ContainerPath", "/dev/fuse");+ device.putArray("Permissions").add("read").add("write");+ ObjectNode tmpfs = linux.putArray("Tmpfs").addObject().put("ContainerPath", "/scratch").put("Size", 64);+ tmpfs.putArray("MountOptions").add("noexec").add("nosuid");++ provisioner.provision(resource("AWS::ECS::TaskDefinition", "TaskDef"), props, ctx());++ assertEquals(Map.of("linuxParameters", Map.of(+ "capabilities", Map.of("add", List.of("SYS_PTRACE"), "drop", List.of("NET_RAW", "MKNOD")),+ "devices", List.of(Map.of("hostPath", "/dev/fuse", "containerPath", "/dev/fuse",+ "permissions", List.of("read", "write"))),+ "initProcessEnabled", true,+ "maxSwap", 512,+ "sharedMemorySize", 256,+ "swappiness", 10,+ "tmpfs", List.of(Map.of("containerPath", "/scratch", "mountOptions", List.of("noexec", "nosuid"),+ "size", 64)))),+ registeredContainer().getUnparsed());+ }++ /** Text a parameter resolved to is converted as the ECS handler converts it (measured). */+ @Test+ void linuxParametersGivenAsTextAreReadAsTheEcsHandlerConvertsThem() {+ TaskDefinition td = new TaskDefinition();+ td.setTaskDefinitionArn(TASK_DEF_ARN);+ when(ecs.registerTaskDefinition(anyString(), anyList(), any(), any(), any(), any(), any(), anyList(),+ eq(REGION))).thenReturn(td);++ ObjectNode props = mapper.createObjectNode().put("Family", "web");+ props.putArray("ContainerDefinitions").addObject().put("Name", "app").put("Image", "nginx:1")+ .putObject("LinuxParameters").put("InitProcessEnabled", "TRUE").put("SharedMemorySize", "64");++ provisioner.provision(resource("AWS::ECS::TaskDefinition", "TaskDef"), props, ctx());++ assertEquals(Map.of("linuxParameters", Map.of("initProcessEnabled", true, "sharedMemorySize", 64,+ "devices", List.of(), "tmpfs", List.of())),+ registeredContainer().getUnparsed());+ }++ @Test+ void aContainerWithoutLinuxParametersCarriesNone() {+ TaskDefinition td = new TaskDefinition();+ td.setTaskDefinitionArn(TASK_DEF_ARN);+ when(ecs.registerTaskDefinition(anyString(), anyList(), any(), any(), any(), any(), any(), anyList(),+ eq(REGION))).thenReturn(td);++ ObjectNode props = mapper.createObjectNode().put("Family", "web");+ props.putArray("ContainerDefinitions").addObject().put("Name", "app").put("Image", "nginx:1");+ provisioner.provision(resource("AWS::ECS::TaskDefinition", "TaskDef"), props, ctx());++ assertNull(registeredContainer().getUnparsed());+ }++ private ContainerDefinition registeredContainer() {+ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<ContainerDefinition>> defs = ArgumentCaptor.forClass(List.class);+ verify(ecs).registerTaskDefinition(anyString(), defs.capture(), any(), any(), any(), any(), any(),+ anyList(), eq(REGION));+ return defs.getValue().get(0);+ }+@Testvoid taskDefinitionWithoutFamilyGeneratesOneAndIgnoresAnUnknownNetworkMode() {TaskDefinition td = new TaskDefinition();