Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): honor configured function architecture (#2994)
Niels Kootstra7fdd145c0c7d
diff --git a/docs/configuration/advanced/application-yml.md b/docs/configuration/advanced/application-yml.mdindex e33cedc450..2da1e30f99 100644--- a/docs/configuration/advanced/application-yml.md+++ b/docs/configuration/advanced/application-yml.md@@ -132,6 +132,7 @@ floci:enabled: trueephemeral: false # true = remove container after each invocationecr-base-uri: public.ecr.aws # Registry for Lambda runtime images (legacy: floci.ecr-base-uri / FLOCI_ECR_BASE_URI)+ honour-architectures: false # true = select the declared Lambda Docker architecturedefault-memory-mb: 128default-timeout-seconds: 3runtime-api-base-port: 12000 # Port range for Lambda Runtime API@@ -312,9 +313,15 @@ All keys in this table are declared on `EmulatorConfig` and accept environment v| `FLOCI_SERVICES_SES_SMTP_USER` | *(unset)* | SMTP authentication username || `FLOCI_SERVICES_SES_SMTP_PASS` | *(unset)* | SMTP authentication password || `FLOCI_SERVICES_SES_SMTP_STARTTLS` | `DISABLED` | STARTTLS mode: `DISABLED`, `OPTIONAL`, or `REQUIRED` |+| `FLOCI_SERVICES_LAMBDA_HONOUR_ARCHITECTURES` | `false` | Select the declared Lambda architecture for Docker image pulls and containers || `FLOCI_SERVICES_LAMBDA_HOT_RELOAD_ENABLED` | `false` | Enable bind-mount hot-reload mode (`S3Bucket=hot-reload`) || `FLOCI_SERVICES_LAMBDA_HOT_RELOAD_ALLOWED_PATHS` | *(unset)* | Comma-separated list of host paths allowed as bind-mount roots; unset = any absolute path |+Enable `FLOCI_SERVICES_LAMBDA_HONOUR_ARCHITECTURES` only when the Docker host can run the+function architecture. Foreign architectures require Docker Desktop support or host emulation+such as `binfmt_misc` with QEMU. Floci does not fall back to the host architecture when this+setting is enabled.+Per-queue SQS redrive policy (`maxReceiveCount`) is configured at queue creation time via `SetQueueAttributes` / `CreateQueue`, not as a global default.`FLOCI_DEFAULT_AVAILABILITY_ZONE` is declared in `EmulatorConfig` but not in the shipped `application.yml`, so it falls through to the `@WithDefault` value above when unset.diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex fda52bd442..0da6006ef1 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -211,10 +211,19 @@ These AWS Lambda operations have no handler in Floci. Calls will return `404` or## Configuration+!!! warning "Lambda container architecture"+ Floci uses the Docker host architecture by default. Set+ `FLOCI_SERVICES_LAMBDA_HONOUR_ARCHITECTURES=true` to run each function with+ its declared `arm64` or `x86_64` architecture. The Docker host must support+ the selected architecture. Foreign architectures require Docker Desktop or+ host emulation such as `binfmt_misc` with QEMU. Floci does not fall back to+ the host architecture when this setting is enabled.+| Variable | Default | Description ||---|---|---|| `FLOCI_SERVICES_LAMBDA_ENABLED` | `true` | Enable or disable the service || `FLOCI_SERVICES_LAMBDA_EPHEMERAL` | `false` | Remove containers after each invocation |+| `FLOCI_SERVICES_LAMBDA_HONOUR_ARCHITECTURES` | `false` | Select each function's declared architecture for Docker image pulls and containers || `FLOCI_SERVICES_LAMBDA_DEFAULT_MEMORY_MB` | `128` | Default function memory (MB) || `FLOCI_SERVICES_LAMBDA_DEFAULT_TIMEOUT_SECONDS` | `3` | Default function timeout (seconds) || `FLOCI_SERVICES_LAMBDA_RUNTIME_API_BASE_PORT` | `12000` | First port in the Lambda Runtime API range |diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex b4c31091aa..fb75657c8e 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -1861,6 +1861,16 @@ public interface EmulatorConfig {@WithDefault("false")boolean ephemeral();+ /**+ * When true, Docker Lambda containers use the platform declared by the function's+ * Architectures value. Disabled by default because foreign-platform containers require+ * host support such as binfmt_misc or QEMU.+ *+ * Env var: FLOCI_SERVICES_LAMBDA_HONOUR_ARCHITECTURES+ */+ @WithDefault("false")+ boolean honourArchitectures();+@WithDefault("300")int containerIdleTimeoutSeconds();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.javaindex da2b316f27..df85b6c83d 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManager.java@@ -102,15 +102,34 @@ public class ContainerLifecycleManager {* @return the container ID*/public String create(ContainerSpec spec) {- LOG.debugv("Creating container from spec: image={0}, name={1}", spec.image(), spec.name());+ String resolvedImage = imageCacheService.ensureImageExists(spec.image());+ return create(spec, resolvedImage, null);+ }++ /**+ * Creates a container for a specific Docker platform.+ *+ * @param spec the container specification+ * @param platform Docker platform, such as {@code linux/arm64}+ * @return the container ID+ */+ public String create(ContainerSpec spec, String platform) {+ String resolvedImage = imageCacheService.ensureImageExists(spec.image(), platform);+ return create(spec, resolvedImage, platform);+ }- imageCacheService.ensureImageExists(spec.image());+ private String create(ContainerSpec spec, String resolvedImage, String platform) {+ LOG.debugv("Creating container from spec: image={0}, name={1}", spec.image(), spec.name());HostConfig hostConfig = buildHostConfig(spec);- CreateContainerCmd createCmd = dockerClient.createContainerCmd(spec.image())+ CreateContainerCmd createCmd = dockerClient.createContainerCmd(resolvedImage).withHostConfig(hostConfig);+ if (platform != null && !platform.isBlank()) {+ createCmd.withPlatform(platform);+ }+if (spec.name() != null) {createCmd.withName(spec.name());}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.javaindex e57f338ff0..7a19441b4f 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java@@ -75,6 +75,7 @@ public class LambdaService implements ResourceProvider {"arn:(aws[a-zA-Z-]*)?:iam::\\d{12}:role/?[a-zA-Z_0-9+=,.@\\-_/]+");private static final Pattern HANDLER_PATTERN = Pattern.compile("\\S+");private static final int MAX_HANDLER_LENGTH = 128;+ private static final List<String> FUNCTION_ARCHITECTURES = List.of("x86_64", "arm64");private final LambdaFunctionStore functionStore;private final LambdaExecutorService executorService;@@ -338,6 +339,7 @@ public class LambdaService implements ResourceProvider {throw new AwsException("ResourceConflictException","Function already exist: " + functionName, 409);}+ List<String> architectures = validateArchitectures(request.get("Architectures"));LambdaFunction fn = new LambdaFunction();fn.setAccountId(regionResolver.getAccountId());@@ -368,10 +370,6 @@ public class LambdaService implements ResourceProvider {Map<String, String> tags = (Map<String, String>) request.get("Tags");if (tags != null) fn.setTags(tags);- // Architectures- @SuppressWarnings("unchecked")- List<String> architectures = request.get("Architectures") instanceof List- ? (List<String>) request.get("Architectures") : null;if (architectures != null && !architectures.isEmpty()) {fn.setArchitectures(new ArrayList<>(architectures));}@@ -555,6 +553,7 @@ public class LambdaService implements ResourceProvider {public LambdaFunction updateFunctionCode(String region, String functionName, Map<String, Object> request) {LambdaFunction fn = getFunction(region, functionName);functionName = fn.getFunctionName();+ List<String> architectures = validateArchitectures(request.get("Architectures"));String zipFileBase64 = (String) request.get("ZipFile");String imageUri = (String) request.get("ImageUri");@@ -577,13 +576,8 @@ public class LambdaService implements ResourceProvider {}}- if (request.containsKey("Architectures")) {- @SuppressWarnings("unchecked")- List<String> archs = request.get("Architectures") instanceof List- ? (List<String>) request.get("Architectures") : null;- if (archs != null && !archs.isEmpty()) {- fn.setArchitectures(new ArrayList<>(archs));- }+ if (architectures != null) {+ fn.setArchitectures(new ArrayList<>(architectures));}fn.setLastModified(System.currentTimeMillis());@@ -602,6 +596,7 @@ public class LambdaService implements ResourceProvider {public LambdaFunction updateFunctionConfiguration(String region, String functionName, Map<String, Object> request) {LambdaFunction fn = getFunction(region, functionName);+ List<String> architectures = validateArchitectures(request.get("Architectures"));// Validated before any field mutation below, not inline where Layers is applied further// down - fn is the live object backing this store entry (InMemoryStorage#get returns the@@ -680,13 +675,8 @@ public class LambdaService implements ResourceProvider {}}- if (request.containsKey("Architectures")) {- @SuppressWarnings("unchecked")- List<String> archs = request.get("Architectures") instanceof List- ? (List<String>) request.get("Architectures") : null;- if (archs != null && !archs.isEmpty()) {- fn.setArchitectures(new ArrayList<>(archs));- }+ if (architectures != null) {+ fn.setArchitectures(new ArrayList<>(architectures));}if (request.containsKey("EphemeralStorage")) {@@ -1515,6 +1505,41 @@ public class LambdaService implements ResourceProvider {return parsed;}+ private static List<String> validateArchitectures(Object value) {+ if (value == null) {+ return null;+ }+ if (!(value instanceof List<?> architectures)) {+ throw new AwsException("InvalidParameterValueException",+ "1 validation error detected: Value '" + value + "' at 'architectures' "+ + "failed to satisfy constraint: Member must be a list",+ 400);+ }+ if (architectures.isEmpty()) {+ throw new AwsException("InvalidParameterValueException",+ "1 validation error detected: Value '[]' at 'architectures' "+ + "failed to satisfy constraint: Member must have length greater than or equal to 1",+ 400);+ }+ if (architectures.size() > 1) {+ throw new AwsException("InvalidParameterValueException",+ "1 validation error detected: Value '" + architectures + "' at 'architectures' "+ + "failed to satisfy constraint: Member must have length less than or equal to 1",+ 400);+ }++ Object architecture = architectures.getFirst();+ if (!FUNCTION_ARCHITECTURES.contains(architecture)) {+ throw new AwsException("InvalidParameterValueException",+ "1 validation error detected: Value '" + architecture+ + "' at 'architectures.1.member' "+ + "failed to satisfy constraint: Member must satisfy enum value set: "+ + FUNCTION_ARCHITECTURES,+ 400);+ }+ return List.of((String) architecture);+ }+private static void validateFileSystemVpcConfig(List<LambdaFileSystemConfig> fileSystemConfigs,Map<String, Object> vpcConfig) {if (fileSystemConfigs == null || fileSystemConfigs.isEmpty()) {diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.javaindex 9176617746..cb1cdcd2a0 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java@@ -372,7 +372,7 @@ public class ContainerLauncher implements LambdaRuntimeLauncher {// Create container without starting — provided.* runtimes exec// /var/runtime/bootstrap on start, so code must be copied first.- containerId = lifecycleManager.create(spec);+ containerId = createContainer(spec, fn);LOG.infov("Created container {0} for function {1}", containerId, fn.getFunctionName());// Docker now holds the real container-to-volume reference, which removeVolume's own in-use// check protects from here on - release the in-flight marker that stood in for it before@@ -515,6 +515,33 @@ public class ContainerLauncher implements LambdaRuntimeLauncher {}}+ private static Optional<String> dockerPlatform(LambdaFunction fn) {+ List<String> architectures = fn.getArchitectures();+ if (architectures == null) {+ return Optional.of("linux/amd64");+ }+ if (architectures.size() != 1) {+ return Optional.empty();+ }+ return switch (architectures.getFirst()) {+ case "arm64" -> Optional.of("linux/arm64");+ case "x86_64" -> Optional.of("linux/amd64");+ default -> Optional.empty();+ };+ }++ private String createContainer(ContainerSpec spec, LambdaFunction fn) {+ if (!config.services().lambda().honourArchitectures()) {+ return lifecycleManager.create(spec);+ }+ Optional<String> platform = dockerPlatform(fn);+ if (platform.isEmpty()) {+ throw new IllegalStateException("Invalid persisted architectures "+ + fn.getArchitectures() + " for function '" + fn.getFunctionName() + "'");+ }+ return lifecycleManager.create(spec, platform.get());+ }+public void stop(ContainerHandle handle) {LOG.infov("Stopping container {0}", handle.getContainerId());handle.setState(ContainerState.STOPPED);@@ -876,19 +903,19 @@ public class ContainerLauncher implements LambdaRuntimeLauncher {String shortId = java.util.UUID.randomUUID().toString().replace("-", "").substring(0, 8);// A minimal helper container (sleep) with the volume mounted read-write at /var/task; we// tar-copy the code into it, then discard it — the data persists in the volume.- ContainerSpec helperSpec = containerBuilder.newContainer(image)+ ContainerBuilder.Builder helperBuilder = containerBuilder.newContainer(image).withName(resolveContainerNamePrefix(config) + "-codevol-" + fn.getFunctionName() + "-" + shortId).withEnv(java.util.List.of()).withEntrypoint(java.util.List.of("sleep")).withCmd(java.util.List.of("3600"))- .withNamedVolume(volName, TASK_DIR, false)- .build();+ .withNamedVolume(volName, TASK_DIR, false);+ ContainerSpec helperSpec = helperBuilder.build();// Gate the heavy work (helper create + ~90MB tar copy) so a burst of first-time populates// doesn't thrash the Docker daemon. Only populates are serialized — plain cold starts aren't.acquirePopulatePermit(fn.getFunctionName());String helperId = null;try {- helperId = lifecycleManager.create(helperSpec);+ helperId = createContainer(helperSpec, fn);lifecycleManager.startCreated(helperId, helperSpec);copyDirToContainerStrict(lifecycleManager.getDockerClient(), helperId,Path.of(fn.getCodeLocalPath()), TASK_DIR, fn.getFunctionName());diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ImageCacheService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ImageCacheService.javaindex 365e10886b..1ef0c3c273 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ImageCacheService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ImageCacheService.java@@ -1,22 +1,26 @@package io.github.hectorvent.floci.services.lambda.launcher;import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.command.InspectImageResponse;+import com.github.dockerjava.api.command.PullImageCmd;import com.github.dockerjava.api.command.PullImageResultCallback;import com.github.dockerjava.api.exception.DockerClientException;import com.github.dockerjava.api.exception.InternalServerErrorException;import com.github.dockerjava.api.model.AuthConfig;+import com.github.dockerjava.api.model.Info;import io.github.hectorvent.floci.config.EmulatorConfig;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;import java.util.List;-import java.util.Set;+import java.util.Locale;+import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.TimeUnit;/**- * Ensures each Docker image is pulled only once.+ * Ensures each Docker image is pulled only once per platform.* Thread-safe using ConcurrentHashMap for double-checked locking per image.*/@ApplicationScoped@@ -29,8 +33,9 @@ public class ImageCacheService {private final DockerClient dockerClient;private final List<EmulatorConfig.DockerConfig.RegistryCredential> registryCredentials;- private final Set<String> pulledImages = ConcurrentHashMap.newKeySet();+ private final Map<ImageKey, String> resolvedImages = new ConcurrentHashMap<>();private final ConcurrentHashMap<String, Object> locks = new ConcurrentHashMap<>();+ private volatile String daemonPlatform;@Injectpublic ImageCacheService(DockerClient dockerClient, EmulatorConfig config) {@@ -38,29 +43,47 @@ public class ImageCacheService {this.registryCredentials = config.docker().registryCredentials();}- public void ensureImageExists(String imageUri) {- if (pulledImages.contains(imageUri)) {- return;+ public String ensureImageExists(String imageUri) {+ return ensureImageExists(imageUri, null);+ }++ public String ensureImageExists(String imageUri, String platform) {+ boolean explicitPlatform = platform != null && !platform.isBlank();+ String requestedPlatform = explicitPlatform ? platform.trim() : daemonPlatform();+ ImageKey imageKey = new ImageKey(imageUri, requestedPlatform);+ String resolvedImage = validResolvedImage(imageKey);+ if (resolvedImage != null) {+ return resolvedImage;}Object lock = locks.computeIfAbsent(imageUri, k -> new Object());synchronized (lock) {- if (pulledImages.contains(imageUri)) {- return;+ resolvedImage = validResolvedImage(imageKey);+ if (resolvedImage != null) {+ return resolvedImage;}- if (isLocalImagePresent(imageUri)) {- pulledImages.add(imageUri);+ InspectImageResponse localImage = inspectLocalImage(imageUri);+ if (matchesPlatform(localImage, requestedPlatform)) {+ resolvedImage = resolvedImageReference(imageUri, requestedPlatform, localImage);+ resolvedImages.put(imageKey, resolvedImage);LOG.infov("Image already present locally, skipping pull: {0}", imageUri);- return;+ return resolvedImage;}LOG.infov("Pulling image: {0}", imageUri);try {- runWithRetry(imageUri, MAX_PULL_ATTEMPTS, INITIAL_BACKOFF_MS,- () -> dockerClient.pullImageCmd(imageUri)- .withAuthConfig(resolveAuth(imageUri))- .exec(new PullImageResultCallback())- .awaitCompletion(5, TimeUnit.MINUTES));- pulledImages.add(imageUri);+ runWithRetry(imageUri, MAX_PULL_ATTEMPTS, INITIAL_BACKOFF_MS, () -> {+ PullImageCmd pullImage = dockerClient.pullImageCmd(imageUri)+ .withAuthConfig(resolveAuth(imageUri));+ if (explicitPlatform) {+ pullImage.withPlatform(requestedPlatform);+ }+ pullImage.exec(new PullImageResultCallback())+ .awaitCompletion(5, TimeUnit.MINUTES);+ });+ resolvedImage = resolvedImageReference(imageUri, requestedPlatform,+ inspectLocalImage(imageUri));+ resolvedImages.put(imageKey, resolvedImage);LOG.infov("Image pulled successfully: {0}", imageUri);+ return resolvedImage;} catch (InterruptedException e) {Thread.currentThread().interrupt();throw new RuntimeException("Interrupted while pulling image: " + imageUri, e);@@ -118,15 +141,78 @@ public class ImageCacheService {void run() throws InterruptedException;}- private boolean isLocalImagePresent(String imageUri) {+ private InspectImageResponse inspectLocalImage(String imageUri) {try {- dockerClient.inspectImageCmd(imageUri).exec();- return true;+ return dockerClient.inspectImageCmd(imageUri).exec();} catch (com.github.dockerjava.api.exception.NotFoundException e) {+ return null;+ }+ }++ private String validResolvedImage(ImageKey imageKey) {+ String resolvedImage = resolvedImages.get(imageKey);+ if (resolvedImage == null) {+ return null;+ }+ if (inspectLocalImage(resolvedImage) != null) {+ return resolvedImage;+ }+ resolvedImages.remove(imageKey, resolvedImage);+ return null;+ }++ private String daemonPlatform() {+ String resolvedPlatform = daemonPlatform;+ if (resolvedPlatform != null) {+ return resolvedPlatform;+ }+ Info info = dockerClient.infoCmd().exec();+ String architecture = info.getArchitecture();+ if (architecture == null || architecture.isBlank()) {+ throw new DockerClientException("Docker did not report its architecture");+ }+ String os = info.getOsType();+ if (os == null || os.isBlank()) {+ os = "linux";+ }+ String normalizedArchitecture = switch (architecture.toLowerCase(Locale.ROOT)) {+ case "aarch64" -> "arm64";+ case "x86_64" -> "amd64";+ default -> architecture.toLowerCase(Locale.ROOT);+ };+ resolvedPlatform = os.toLowerCase(Locale.ROOT) + "/" + normalizedArchitecture;+ daemonPlatform = resolvedPlatform;+ return resolvedPlatform;+ }++ private static boolean matchesPlatform(InspectImageResponse image, String platform) {+ if (image == null) {return false;}+ if (platform == null) {+ return true;+ }+ String[] parts = platform.split("/", 2);+ return parts.length == 2+ && parts[0].equals(image.getOs())+ && parts[1].equals(image.getArch());+ }++ private static String resolvedImageReference(String imageUri, String platform,+ InspectImageResponse image) {+ if (!matchesPlatform(image, platform)) {+ throw new DockerClientException(+ "Docker image does not match requested platform " + platform + ": " + imageUri);+ }+ String imageId = image.getId();+ if (imageId == null || imageId.isBlank()) {+ throw new DockerClientException("Docker did not report an image ID for: " + imageUri);+ }+ return imageId;}+ private record ImageKey(String imageUri, String platform) {}+private AuthConfig resolveAuth(String imageUri) {String host = extractRegistryHost(imageUri);for (EmulatorConfig.DockerConfig.RegistryCredential cred : registryCredentials) {diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 678b649ba9..595ba91c0b 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -258,6 +258,7 @@ floci:enabled: trueephemeral: falseecr-base-uri: public.ecr.aws # FLOCI_SERVICES_LAMBDA_ECR_BASE_URI — registry for Lambda runtime images (legacy: floci.ecr-base-uri / FLOCI_ECR_BASE_URI)+ honour-architectures: false # Select the Lambda architecture for Docker pull and createdefault-memory-mb: 128default-timeout-seconds: 3# 500 ports, not the former 100 (9200-9299): one port is held per running Lambdadiff --git a/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManagerLabelsTest.java b/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManagerLabelsTest.javaindex 36fd85ad02..c64a54de07 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManagerLabelsTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerLifecycleManagerLabelsTest.java@@ -31,6 +31,7 @@ import static org.mockito.ArgumentMatchers.anyLong;import static org.mockito.Mockito.RETURNS_SELF;import static org.mockito.Mockito.lenient;import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;import static org.mockito.Mockito.verify;import static org.mockito.Mockito.when;@@ -66,6 +67,8 @@ class ContainerLifecycleManagerLabelsTest {void setUp() {lenient().when(config.docker()).thenReturn(dockerConfig);lenient().when(dockerConfig.resourceNamespace()).thenReturn(Optional.empty());+ lenient().when(imageCacheService.ensureImageExists(any()))+ .thenAnswer(invocation -> invocation.getArgument(0));}@Test@@ -77,6 +80,7 @@ class ContainerLifecycleManagerLabelsTest {assertEquals(Map.of("floci", "true", "floci_emulator", "floci-aws"),capturedLabels(createCmd));+ verify(imageCacheService).ensureImageExists("busybox:stable");}@Test@@ -103,6 +107,31 @@ class ContainerLifecycleManagerLabelsTest {capturedLabels(createCmd));}+ @Test+ void createUsesRequestedDockerPlatform() {+ when(imageCacheService.ensureImageExists("busybox:stable", "linux/arm64"))+ .thenReturn("sha256:arm64");+ CreateContainerCmd createCmd = stubCreateContainer("sha256:arm64");++ manager().create(new ContainerSpec("busybox:stable"), "linux/arm64");++ verify(imageCacheService).ensureImageExists("busybox:stable", "linux/arm64");+ verify(dockerClient).createContainerCmd("sha256:arm64");+ verify(createCmd).withPlatform("linux/arm64");+ }++ @Test+ void createUsesResolvedImageForDaemonDefaultPlatform() {+ when(imageCacheService.ensureImageExists("busybox:stable"))+ .thenReturn("sha256:native");+ CreateContainerCmd createCmd = stubCreateContainer("sha256:native");++ manager().create(new ContainerSpec("busybox:stable"));++ verify(dockerClient).createContainerCmd("sha256:native");+ verify(createCmd, never()).withPlatform(any());+ }+@Testvoid createIncludesNamespaceLabelWhenConfigured() {when(dockerConfig.resourceNamespace()).thenReturn(Optional.of("run-one"));@@ -169,8 +198,12 @@ class ContainerLifecycleManagerLabelsTest {}private CreateContainerCmd stubCreateContainer() {+ return stubCreateContainer("busybox:stable");+ }++ private CreateContainerCmd stubCreateContainer(String image) {CreateContainerCmd createCmd = mock(CreateContainerCmd.class, RETURNS_SELF);- when(dockerClient.createContainerCmd("busybox:stable")).thenReturn(createCmd);+ when(dockerClient.createContainerCmd(image)).thenReturn(createCmd);CreateContainerResponse response = mock(CreateContainerResponse.class);when(response.getId()).thenReturn("container-id");when(createCmd.exec()).thenReturn(response);diff --git a/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerPlatformDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerPlatformDockerIntegrationTest.javanew file mode 100644index 0000000000..d7aedf3a85--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/docker/ContainerPlatformDockerIntegrationTest.java@@ -0,0 +1,71 @@+package io.github.hectorvent.floci.core.common.docker;++import com.github.dockerjava.api.DockerClient;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;+import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.Locale;+import java.util.UUID;++import static org.junit.jupiter.api.Assertions.assertEquals;++@QuarkusTest+class ContainerPlatformDockerIntegrationTest {++ private static final Logger LOG = Logger.getLogger(ContainerPlatformDockerIntegrationTest.class);+ private static final String IMAGE = "public.ecr.aws/docker/library/busybox:1.36";++ @Inject+ DockerClient dockerClient;++ @Inject+ ContainerBuilder containerBuilder;++ @Inject+ ContainerLifecycleManager lifecycleManager;++ @BeforeEach+ void requireDocker() {+ Assumptions.assumeTrue(isDockerAvailable(),+ "Docker daemon must be available for container platform integration tests");+ }++ @Test+ void createUsesRequestedForeignPlatformImage() {+ String hostArchitecture = dockerClient.infoCmd().exec().getArchitecture()+ .toLowerCase(Locale.ROOT);+ boolean armHost = hostArchitecture.equals("arm64") || hostArchitecture.equals("aarch64");+ String requestedArchitecture = armHost ? "amd64" : "arm64";+ String platform = "linux/" + requestedArchitecture;+ ContainerSpec spec = containerBuilder.newContainer(IMAGE)+ .withName("floci-platform-test-" + UUID.randomUUID())+ .build();++ String containerId = null;+ try {+ containerId = lifecycleManager.create(spec, platform);+ String imageId = dockerClient.inspectContainerCmd(containerId).exec().getImageId();++ assertEquals(requestedArchitecture,+ dockerClient.inspectImageCmd(imageId).exec().getArch());+ } finally {+ if (containerId != null) {+ dockerClient.removeContainerCmd(containerId).withForce(true).exec();+ }+ }+ }++ private boolean isDockerAvailable() {+ try {+ dockerClient.pingCmd().exec();+ return true;+ } catch (Exception e) {+ LOG.warn("Docker daemon is not available for the container platform integration test", e);+ return false;+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.javaindex 42e6f29ce9..8d750644a8 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java@@ -591,6 +591,125 @@ class LambdaServiceTest {assertEquals(List.of("x86_64"), service.getFunction(REGION, "arch-fn").getArchitectures());}+ @Test+ void createFunctionRejectsUnsupportedArchitectureWithoutPersistingFunction() {+ Map<String, Object> request = baseRequest("unsupported-create-architecture");+ request.put("Architectures", List.of("sparc"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));++ assertUnsupportedArchitecture(error);+ assertTrue(service.listFunctions(REGION).isEmpty());+ }++ @Test+ void createFunctionRejectsMultipleArchitecturesWithoutPersistingFunction() {+ Map<String, Object> request = baseRequest("multiple-create-architectures");+ request.put("Architectures", List.of("arm64", "x86_64"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));++ assertEquals("InvalidParameterValueException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ assertEquals("1 validation error detected: Value '[arm64, x86_64]' at 'architectures' "+ + "failed to satisfy constraint: Member must have length less than or equal to 1",+ error.getMessage());+ assertTrue(service.listFunctions(REGION).isEmpty());+ }++ @Test+ void createFunctionRejectsEmptyArchitecturesWithoutPersistingFunction() {+ Map<String, Object> request = baseRequest("empty-create-architectures");+ request.put("Architectures", List.of());++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));++ assertEquals("InvalidParameterValueException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ assertEquals("1 validation error detected: Value '[]' at 'architectures' "+ + "failed to satisfy constraint: Member must have length greater than or equal to 1",+ error.getMessage());+ assertTrue(service.listFunctions(REGION).isEmpty());+ }++ @Test+ void createFunctionRejectsScalarArchitecturesWithoutPersistingFunction() {+ Map<String, Object> request = baseRequest("scalar-create-architectures");+ request.put("Architectures", "arm64");++ AwsException error = assertThrows(AwsException.class,+ () -> service.createFunction(REGION, request));++ assertMalformedArchitectures(error, "arm64");+ assertTrue(service.listFunctions(REGION).isEmpty());+ }++ @Test+ void updateFunctionCodeRejectsUnsupportedArchitectureBeforeMutation() {+ service.createFunction(REGION, baseRequest("unsupported-code-architecture"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionCode(REGION, "unsupported-code-architecture",+ Map.of("ImageUri", "example.invalid/changed:latest",+ "Architectures", List.of("sparc"))));++ assertUnsupportedArchitecture(error);+ LambdaFunction unchanged = service.getFunction(REGION, "unsupported-code-architecture");+ assertNull(unchanged.getImageUri());+ assertNull(unchanged.getArchitectures());+ }++ @Test+ void updateFunctionCodeRejectsObjectArchitecturesBeforeMutation() {+ service.createFunction(REGION, baseRequest("object-code-architectures"));+ String revisionId = service.getFunction(REGION, "object-code-architectures").getRevisionId();+ Map<String, String> malformedArchitectures = Map.of("Architecture", "arm64");++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionCode(REGION, "object-code-architectures",+ Map.of("ImageUri", "example.invalid/changed:latest",+ "Architectures", malformedArchitectures)));++ assertMalformedArchitectures(error, malformedArchitectures);+ LambdaFunction unchanged = service.getFunction(REGION, "object-code-architectures");+ assertNull(unchanged.getImageUri());+ assertNull(unchanged.getArchitectures());+ assertEquals(revisionId, unchanged.getRevisionId());+ }++ @Test+ void updateFunctionConfigurationRejectsUnsupportedArchitectureBeforeMutation() {+ service.createFunction(REGION, baseRequest("unsupported-config-architecture"));++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionConfiguration(REGION, "unsupported-config-architecture",+ Map.of("Description", "changed", "Architectures", List.of("sparc"))));++ assertUnsupportedArchitecture(error);+ LambdaFunction unchanged = service.getFunction(REGION, "unsupported-config-architecture");+ assertNull(unchanged.getDescription());+ assertNull(unchanged.getArchitectures());+ }++ @Test+ void updateFunctionConfigurationRejectsScalarArchitecturesBeforeMutation() {+ service.createFunction(REGION, baseRequest("scalar-config-architectures"));+ String revisionId = service.getFunction(REGION, "scalar-config-architectures").getRevisionId();++ AwsException error = assertThrows(AwsException.class,+ () -> service.updateFunctionConfiguration(REGION, "scalar-config-architectures",+ Map.of("Description", "changed", "Architectures", 64)));++ assertMalformedArchitectures(error, 64);+ LambdaFunction unchanged = service.getFunction(REGION, "scalar-config-architectures");+ assertNull(unchanged.getDescription());+ assertNull(unchanged.getArchitectures());+ assertEquals(revisionId, unchanged.getRevisionId());+ }+@Testvoid updateFunctionCodeWithoutArchitecturesKeepsExisting() {Map<String, Object> req = baseRequest("arch-keep-fn");@@ -601,6 +720,22 @@ class LambdaServiceTest {assertEquals(List.of("arm64"), updated.getArchitectures());}+ private static void assertUnsupportedArchitecture(AwsException error) {+ assertEquals("InvalidParameterValueException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ assertEquals("1 validation error detected: Value 'sparc' at 'architectures.1.member' "+ + "failed to satisfy constraint: Member must satisfy enum value set: [x86_64, arm64]",+ error.getMessage());+ }++ private static void assertMalformedArchitectures(AwsException error, Object value) {+ assertEquals("InvalidParameterValueException", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ assertEquals("1 validation error detected: Value '" + value + "' at 'architectures' "+ + "failed to satisfy constraint: Member must be a list",+ error.getMessage());+ }+@Testvoid rehydrateConcurrency_restoresReservedFromStore() {// Simulate a persisted state: functions already live in the storediff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncherTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncherTest.javaindex bde16eb0c8..03b831a5f9 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncherTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncherTest.java@@ -33,6 +33,8 @@ import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.extension.ExtendWith;import org.junit.jupiter.api.io.TempDir;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.MethodSource;import org.mockito.ArgumentCaptor;import org.mockito.InOrder;import org.mockito.Mock;@@ -50,11 +52,13 @@ import java.util.Optional;import java.util.OptionalInt;import java.util.concurrent.CompletableFuture;import java.util.concurrent.atomic.AtomicBoolean;+import java.util.stream.Stream;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNotNull;import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertSame;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;@@ -146,6 +150,7 @@ class ContainerLauncherTest {// lenient: the failure-path test (populate fails before any container is created) never// reaches these, but every success-path test does — they must not trip strict-stubs.lenient().when(lifecycleManager.create(any())).thenReturn("container-123");+ lenient().when(lifecycleManager.create(any(), anyString())).thenReturn("container-123");ContainerLifecycleManager.ContainerInfo info =new ContainerLifecycleManager.ContainerInfo("container-123", Map.of());lenient().when(lifecycleManager.startCreated(eq("container-123"), any())).thenReturn(info);@@ -204,6 +209,13 @@ class ContainerLauncherTest {.orElseGet(() -> specs.get(specs.size() - 1));}+ private String captureRealContainerPlatform() {+ ArgumentCaptor<String> platformCaptor = ArgumentCaptor.forClass(String.class);+ verify(lifecycleManager, atLeastOnce()).create(any(ContainerSpec.class), platformCaptor.capture());+ List<String> platforms = platformCaptor.getAllValues();+ return platforms.get(platforms.size() - 1);+ }+/** Returns the read-only {@code /var/task} volume mount on the spec, or null if absent. */private static Mount varTaskVolumeMount(ContainerSpec spec) {if (spec.mounts() == null) {@@ -215,6 +227,137 @@ class ContainerLauncherTest {.orElse(null);}+ @Test+ void launchFunction_usesArm64DockerPlatformWhenArchitectureHonouringIsEnabled() throws Exception {+ EmulatorConfig.LambdaServiceConfig lambda = config.services().lambda();+ when(lambda.honourArchitectures()).thenReturn(true);+ Path codePath = Files.createDirectory(tempDir.resolve("arm64-code"));++ LambdaFunction fn = new LambdaFunction();+ fn.setFunctionName("arm64-fn");+ fn.setRuntime("nodejs20.x");+ fn.setHandler("index.handler");+ fn.setCodeLocalPath(codePath.toString());+ fn.setArchitectures(List.of("arm64"));++ launcher.launch(fn);++ assertEquals("linux/arm64", captureRealContainerPlatform());+ }++ @Test+ void launchFunction_usesAmd64DockerPlatformForX86Architecture() throws Exception {+ EmulatorConfig.LambdaServiceConfig lambda = config.services().lambda();+ when(lambda.honourArchitectures()).thenReturn(true);+ Path codePath = Files.createDirectory(tempDir.resolve("x86-code"));++ LambdaFunction fn = new LambdaFunction();+ fn.setFunctionName("x86-fn");+ fn.setRuntime("nodejs20.x");+ fn.setHandler("index.handler");+ fn.setCodeLocalPath(codePath.toString());+ fn.setArchitectures(List.of("x86_64"));++ launcher.launch(fn);++ assertEquals("linux/amd64", captureRealContainerPlatform());+ }++ @Test+ void launchFunction_usesAmd64DockerPlatformWhenArchitectureIsOmitted() throws Exception {+ EmulatorConfig.LambdaServiceConfig lambda = config.services().lambda();+ when(lambda.honourArchitectures()).thenReturn(true);+ Path codePath = Files.createDirectory(tempDir.resolve("default-architecture-code"));++ LambdaFunction fn = new LambdaFunction();+ fn.setFunctionName("default-architecture-fn");+ fn.setRuntime("nodejs20.x");+ fn.setHandler("index.handler");+ fn.setCodeLocalPath(codePath.toString());++ launcher.launch(fn);++ assertEquals("linux/amd64", captureRealContainerPlatform());+ }++ @Test+ void launchFunction_keepsDaemonDefaultPlatformWhenArchitectureHonouringIsDisabled() throws Exception {+ Path codePath = Files.createDirectory(tempDir.resolve("native-platform-code"));++ LambdaFunction fn = new LambdaFunction();+ fn.setFunctionName("native-platform-fn");+ fn.setRuntime("nodejs20.x");+ fn.setHandler("index.handler");+ fn.setCodeLocalPath(codePath.toString());+ fn.setArchitectures(List.of("arm64"));++ launcher.launch(fn);++ captureRealContainerSpec();+ verify(lifecycleManager, never()).create(any(ContainerSpec.class), anyString());+ }++ @ParameterizedTest+ @MethodSource("invalidPersistedArchitectures")+ void launchFunction_rejectsInvalidPersistedArchitecturesBeforeCreatingContainer(+ List<String> architectures) throws Exception {+ EmulatorConfig.LambdaServiceConfig lambda = config.services().lambda();+ when(lambda.honourArchitectures()).thenReturn(true);+ Path codePath = Files.createDirectory(tempDir.resolve("legacy-invalid-architecture-code"));++ LambdaFunction fn = new LambdaFunction();+ fn.setFunctionName("legacy-invalid-architecture-fn");+ fn.setRuntime("nodejs20.x");+ fn.setHandler("index.handler");+ fn.setCodeLocalPath(codePath.toString());+ fn.setArchitectures(architectures);++ IllegalStateException exception = assertThrows(IllegalStateException.class,+ () -> launcher.launch(fn));++ assertEquals("Invalid persisted architectures " + architectures+ + " for function 'legacy-invalid-architecture-fn'", exception.getMessage());+ verify(lifecycleManager, never()).create(any(ContainerSpec.class));+ verify(lifecycleManager, never()).create(any(ContainerSpec.class), anyString());+ assertSame(architectures, fn.getArchitectures());+ }++ private static Stream<List<String>> invalidPersistedArchitectures() {+ return Stream.of(+ List.of(),+ List.of("riscv64"),+ List.of("arm64", "x86_64"));+ }++ @Test+ void launchFunction_usesArm64DockerPlatformForCodeVolumeHelper() throws Exception {+ EmulatorConfig.LambdaServiceConfig lambda = config.services().lambda();+ when(lambda.honourArchitectures()).thenReturn(true);+ Path codePath = Files.createDirectory(tempDir.resolve("large-arm64-code"));+ Files.write(codePath.resolve("bundle.bin"), new byte[8 * 1024]);++ LambdaFunction fn = new LambdaFunction();+ fn.setFunctionName("large-arm64-fn");+ fn.setRuntime("nodejs20.x");+ fn.setHandler("index.handler");+ fn.setCodeLocalPath(codePath.toString());+ fn.setCodeSha256("large-arm64-code-sha");+ fn.setArchitectures(List.of("arm64"));++ long originalThreshold = ContainerLauncher.CODE_VOLUME_MIN_BYTES;+ try {+ ContainerLauncher.CODE_VOLUME_MIN_BYTES = 4 * 1024;+ launcher.launch(fn);+ } finally {+ ContainerLauncher.CODE_VOLUME_MIN_BYTES = originalThreshold;+ }++ ArgumentCaptor<String> platformCaptor = ArgumentCaptor.forClass(String.class);+ verify(lifecycleManager, times(2)).create(any(ContainerSpec.class), platformCaptor.capture());+ assertTrue(platformCaptor.getAllValues().stream()+ .allMatch("linux/arm64"::equals));+ }+@Testvoid launchFunction_labelsContainerWithResourceIdentity() throws Exception {Path codePath = Files.createDirectory(tempDir.resolve("code"));diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/ImageCacheServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/ImageCacheServiceTest.javaindex d53f674265..8679647c39 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/ImageCacheServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/ImageCacheServiceTest.java@@ -2,6 +2,8 @@ package io.github.hectorvent.floci.services.lambda.launcher;import com.github.dockerjava.api.DockerClient;import com.github.dockerjava.api.command.InspectImageCmd;+import com.github.dockerjava.api.command.InspectImageResponse;+import com.github.dockerjava.api.command.InfoCmd;import com.github.dockerjava.api.command.PullImageCmd;import com.github.dockerjava.api.command.PullImageResultCallback;import com.github.dockerjava.api.exception.DockerClientException;@@ -9,6 +11,7 @@ import com.github.dockerjava.api.exception.DockerException;import com.github.dockerjava.api.exception.InternalServerErrorException;import com.github.dockerjava.api.exception.NotFoundException;import com.github.dockerjava.api.exception.UnauthorizedException;+import com.github.dockerjava.api.model.Info;import io.github.hectorvent.floci.config.EmulatorConfig;import org.junit.jupiter.api.Test;@@ -21,8 +24,10 @@ import static org.junit.jupiter.api.Assertions.assertSame;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.nullable;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;@@ -37,7 +42,11 @@ class ImageCacheServiceTest {PullImageCmd pullImage = mock(PullImageCmd.class);PullImageResultCallback callback = mock(PullImageResultCallback.class);when(dockerClient.inspectImageCmd(IMAGE)).thenReturn(inspectImage);- when(inspectImage.exec()).thenThrow(new NotFoundException("image not found"));+ when(inspectImage.exec()).thenThrow(new NotFoundException("image not found"))+ .thenReturn(new InspectImageResponse()+ .withId("sha256:native")+ .withOs("linux")+ .withArch("amd64"));when(dockerClient.pullImageCmd(IMAGE)).thenReturn(pullImage);when(pullImage.withAuthConfig(any())).thenReturn(pullImage);when(pullImage.exec(any(PullImageResultCallback.class))).thenReturn(callback);@@ -45,6 +54,7 @@ class ImageCacheServiceTest {newService(dockerClient).ensureImageExists(IMAGE);verify(pullImage).exec(any(PullImageResultCallback.class));+ verify(pullImage, never()).withPlatform(nullable(String.class));verify(callback).awaitCompletion(5, TimeUnit.MINUTES);}@@ -63,6 +73,139 @@ class ImageCacheServiceTest {verify(dockerClient, never()).pullImageCmd(IMAGE);}+ @Test+ void pullsRequestedPlatformWhenLocalImageArchitectureDoesNotMatch() throws Exception {+ DockerClient dockerClient = mock(DockerClient.class);+ InspectImageCmd inspectImage = mock(InspectImageCmd.class);+ PullImageCmd pullImage = mock(PullImageCmd.class);+ PullImageResultCallback callback = mock(PullImageResultCallback.class);+ when(dockerClient.inspectImageCmd(IMAGE)).thenReturn(inspectImage);+ when(inspectImage.exec()).thenReturn(+ new InspectImageResponse().withOs("linux").withArch("amd64"),+ new InspectImageResponse().withId("sha256:arm64").withOs("linux").withArch("arm64"));+ when(dockerClient.pullImageCmd(IMAGE)).thenReturn(pullImage);+ when(pullImage.withAuthConfig(any())).thenReturn(pullImage);+ when(pullImage.withPlatform("linux/arm64")).thenReturn(pullImage);+ when(pullImage.exec(any(PullImageResultCallback.class))).thenReturn(callback);++ String resolvedImage = newService(dockerClient)+ .ensureImageExists(IMAGE, "linux/arm64");++ assertEquals("sha256:arm64", resolvedImage);+ verify(pullImage).withPlatform("linux/arm64");+ verify(callback).awaitCompletion(5, TimeUnit.MINUTES);+ }++ @Test+ void skipsPullWhenLocalImageMatchesRequestedPlatform() {+ DockerClient dockerClient = mock(DockerClient.class);+ InspectImageCmd inspectImage = mock(InspectImageCmd.class);+ when(dockerClient.inspectImageCmd(IMAGE)).thenReturn(inspectImage);+ when(inspectImage.exec()).thenReturn(new InspectImageResponse()+ .withId("sha256:arm64")+ .withOs("linux")+ .withArch("arm64"));++ String resolvedImage = newService(dockerClient)+ .ensureImageExists(IMAGE, "linux/arm64");++ assertEquals("sha256:arm64", resolvedImage);+ verify(dockerClient, never()).pullImageCmd(IMAGE);+ }++ @Test+ void keepsDifferentPlatformsAsSeparateCacheRequests() {+ DockerClient dockerClient = mock(DockerClient.class);+ InspectImageCmd inspectImage = mock(InspectImageCmd.class);+ PullImageCmd pullImage = mock(PullImageCmd.class);+ PullImageResultCallback callback = mock(PullImageResultCallback.class);+ when(dockerClient.inspectImageCmd(IMAGE)).thenReturn(inspectImage);+ when(inspectImage.exec()).thenReturn(+ new InspectImageResponse().withOs("linux").withArch("amd64"),+ new InspectImageResponse().withId("sha256:arm64").withOs("linux").withArch("arm64"),+ new InspectImageResponse().withOs("linux").withArch("arm64"),+ new InspectImageResponse().withId("sha256:amd64").withOs("linux").withArch("amd64"));+ when(dockerClient.pullImageCmd(IMAGE)).thenReturn(pullImage);+ when(pullImage.withAuthConfig(any())).thenReturn(pullImage);+ when(pullImage.withPlatform("linux/arm64")).thenReturn(pullImage);+ when(pullImage.withPlatform("linux/amd64")).thenReturn(pullImage);+ when(pullImage.exec(any(PullImageResultCallback.class))).thenReturn(callback);++ ImageCacheService service = newService(dockerClient);+ String armImage = service.ensureImageExists(IMAGE, "linux/arm64");+ String amdImage = service.ensureImageExists(IMAGE, "linux/amd64");++ assertEquals("sha256:arm64", armImage);+ assertEquals("sha256:amd64", amdImage);+ verify(pullImage).withPlatform("linux/arm64");+ verify(pullImage).withPlatform("linux/amd64");+ }++ @Test+ void restoresDaemonDefaultImageAfterPlatformSpecificPull() throws Exception {+ DockerClient dockerClient = mock(DockerClient.class);+ InspectImageCmd inspectImage = mock(InspectImageCmd.class);+ PullImageCmd pullImage = mock(PullImageCmd.class);+ PullImageResultCallback callback = mock(PullImageResultCallback.class);+ when(dockerClient.inspectImageCmd(IMAGE)).thenReturn(inspectImage);+ when(inspectImage.exec()).thenThrow(new NotFoundException("image not found"))+ .thenReturn(new InspectImageResponse()+ .withId("sha256:arm64")+ .withOs("linux")+ .withArch("arm64"),+ new InspectImageResponse()+ .withId("sha256:arm64")+ .withOs("linux")+ .withArch("arm64"),+ new InspectImageResponse()+ .withId("sha256:amd64")+ .withOs("linux")+ .withArch("amd64"));+ when(dockerClient.pullImageCmd(IMAGE)).thenReturn(pullImage);+ when(pullImage.withAuthConfig(any())).thenReturn(pullImage);+ when(pullImage.withPlatform("linux/arm64")).thenReturn(pullImage);+ when(pullImage.exec(any(PullImageResultCallback.class))).thenReturn(callback);++ ImageCacheService service = newService(dockerClient);+ service.ensureImageExists(IMAGE, "linux/arm64");+ service.ensureImageExists(IMAGE);++ verify(pullImage, times(2)).exec(any(PullImageResultCallback.class));+ verify(pullImage).withPlatform("linux/arm64");+ }++ @Test+ void repullsPlatformImageWhenCachedImageWasRemoved() throws Exception {+ DockerClient dockerClient = mock(DockerClient.class);+ InspectImageCmd inspectImage = mock(InspectImageCmd.class);+ InspectImageCmd inspectCachedImage = mock(InspectImageCmd.class);+ PullImageCmd pullImage = mock(PullImageCmd.class);+ PullImageResultCallback callback = mock(PullImageResultCallback.class);+ when(dockerClient.inspectImageCmd(IMAGE)).thenReturn(inspectImage);+ when(dockerClient.inspectImageCmd("sha256:arm64-old")).thenReturn(inspectCachedImage);+ when(inspectImage.exec()).thenReturn(+ new InspectImageResponse()+ .withId("sha256:arm64-old")+ .withOs("linux")+ .withArch("arm64"),+ new InspectImageResponse().withOs("linux").withArch("amd64"),+ new InspectImageResponse()+ .withId("sha256:arm64-new")+ .withOs("linux")+ .withArch("arm64"));+ when(inspectCachedImage.exec()).thenThrow(new NotFoundException("image was removed"));+ when(dockerClient.pullImageCmd(IMAGE)).thenReturn(pullImage);+ when(pullImage.withAuthConfig(any())).thenReturn(pullImage);+ when(pullImage.withPlatform("linux/arm64")).thenReturn(pullImage);+ when(pullImage.exec(any(PullImageResultCallback.class))).thenReturn(callback);++ ImageCacheService service = newService(dockerClient);+ assertEquals("sha256:arm64-old", service.ensureImageExists(IMAGE, "linux/arm64"));++ assertEquals("sha256:arm64-new", service.ensureImageExists(IMAGE, "linux/arm64"));+ verify(pullImage).exec(any(PullImageResultCallback.class));+ }+@Testvoid succeedsOnFirstAttempt() throws Exception {AtomicInteger calls = new AtomicInteger();@@ -163,6 +306,9 @@ class ImageCacheServiceTest {}private static ImageCacheService newService(DockerClient dockerClient) {+ InfoCmd infoCmd = mock(InfoCmd.class);+ when(dockerClient.infoCmd()).thenReturn(infoCmd);+ when(infoCmd.exec()).thenReturn(new Info().withOsType("linux").withArchitecture("amd64"));EmulatorConfig config = mock(EmulatorConfig.class);EmulatorConfig.DockerConfig dockerConfig = mock(EmulatorConfig.DockerConfig.class);when(config.docker()).thenReturn(dockerConfig);diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex b70a9df188..4c471c6423 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -127,6 +127,7 @@ floci:enabled: truelambda:enabled: true+ honour-architectures: false# aws-config-path:hot-reload:enabled: true