Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): wire S3VirtualHostFilter to container-aware DNS suffix (#598)
Hector Ventura7dbd0225d41f
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaDnsResolutionTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaDnsResolutionTest.javanew file mode 100644index 0000000000..f76dd64cd7--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaDnsResolutionTest.java@@ -0,0 +1,132 @@+package com.floci.test;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+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.core.SdkBytes;+import software.amazon.awssdk.core.sync.RequestBody;+import software.amazon.awssdk.services.lambda.LambdaClient;+import software.amazon.awssdk.services.lambda.model.CreateFunctionRequest;+import software.amazon.awssdk.services.lambda.model.DeleteFunctionRequest;+import software.amazon.awssdk.services.lambda.model.FunctionCode;+import software.amazon.awssdk.services.lambda.model.InvocationType;+import software.amazon.awssdk.services.lambda.model.InvokeRequest;+import software.amazon.awssdk.services.lambda.model.InvokeResponse;+import software.amazon.awssdk.services.lambda.model.Runtime;+import software.amazon.awssdk.services.s3.S3Client;+import software.amazon.awssdk.services.s3.model.CreateBucketRequest;+import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;+import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;+import software.amazon.awssdk.services.s3.model.PutObjectRequest;++import java.time.Duration;+import java.util.Optional;++import static org.assertj.core.api.Assertions.assertThat;+import static org.junit.jupiter.api.Assumptions.assumeTrue;++/**+ * Verifies that a Lambda container can reach S3 via virtual-hosted URL using+ * the embedded DNS server injected into the container's /etc/resolv.conf.+ *+ * Requires Docker dispatch (docker.sock mounted) — skipped automatically when+ * Lambda invocation is unavailable (CI without Docker, host-only mode, etc.).+ *+ * <p>The endpoint used inside the Lambda must match Floci's FLOCI_HOSTNAME so+ * that the embedded DNS resolves it and S3VirtualHostFilter recognises the+ * virtual-host prefix. Override via the {@code FLOCI_DNS_HOSTNAME} env var+ * (default: {@code floci}, matching the standard docker-compose.yml).+ */+@DisplayName("Lambda DNS — S3 virtual-host resolution from inside container")+class LambdaDnsResolutionTest {++ private static final String FUNCTION_NAME = "dns-probe-fn";+ private static final String BUCKET = "dns-probe-bucket";+ private static final String KEY = "hello.txt";+ private static final String OBJECT_BODY = "dns-resolution-ok";+ private static final String ROLE = "arn:aws:iam::000000000000:role/lambda-role";++ // The hostname Floci is reachable at from *inside* a Lambda container.+ // Must match FLOCI_HOSTNAME so the embedded DNS resolves *.{hostname} and+ // S3VirtualHostFilter extracts the bucket from the virtual-hosted Host header.+ private static final String FLOCI_DNS_ENDPOINT =+ Optional.ofNullable(System.getenv("FLOCI_DNS_HOSTNAME"))+ .filter(h -> !h.isBlank())+ .map(h -> h + ":4566")+ .orElse("floci:4566");++ private static LambdaClient lambda;+ private static S3Client s3;+ private static final ObjectMapper MAPPER = new ObjectMapper();++ @BeforeAll+ static void setup() {+ assumeTrue(TestFixtures.isLambdaDispatchAvailable(),+ "Lambda dispatch unavailable — skipping DNS resolution test");++ lambda = TestFixtures.lambdaClient();+ s3 = TestFixtures.s3Client();++ s3.createBucket(CreateBucketRequest.builder().bucket(BUCKET).build());+ s3.putObject(+ PutObjectRequest.builder().bucket(BUCKET).key(KEY).build(),+ RequestBody.fromString(OBJECT_BODY));++ lambda.createFunction(CreateFunctionRequest.builder()+ .functionName(FUNCTION_NAME)+ .runtime(Runtime.NODEJS20_X)+ .role(ROLE)+ .handler("index.handler")+ .timeout(30)+ .code(FunctionCode.builder()+ .zipFile(SdkBytes.fromByteArray(LambdaUtils.s3VirtualHostFetchZip()))+ .build())+ .build());+ }++ @AfterAll+ static void cleanup() {+ if (lambda != null) {+ try { lambda.deleteFunction(DeleteFunctionRequest.builder().functionName(FUNCTION_NAME).build()); } catch (Exception ignored) {}+ lambda.close();+ }+ if (s3 != null) {+ try { s3.deleteObject(DeleteObjectRequest.builder().bucket(BUCKET).key(KEY).build()); } catch (Exception ignored) {}+ try { s3.deleteBucket(DeleteBucketRequest.builder().bucket(BUCKET).build()); } catch (Exception ignored) {}+ s3.close();+ }+ }++ @Test+ @DisplayName("Lambda fetches S3 object via virtual-hosted URL using embedded DNS")+ void lambdaResolvesS3ViaVirtualHostedUrl() throws Exception {+ String payload = MAPPER.writeValueAsString(+ MAPPER.createObjectNode()+ .put("bucket", BUCKET)+ .put("key", KEY)+ .put("endpoint", FLOCI_DNS_ENDPOINT));++ InvokeResponse response = lambda.invoke(InvokeRequest.builder()+ .functionName(FUNCTION_NAME)+ .invocationType(InvocationType.REQUEST_RESPONSE)+ .payload(SdkBytes.fromUtf8String(payload))+ .overrideConfiguration(c -> c.apiCallTimeout(Duration.ofSeconds(30)))+ .build());++ assertThat(response.statusCode()).isEqualTo(200);+ assertThat(response.functionError()).isNullOrEmpty();++ String responseBody = response.payload().asUtf8String();+ JsonNode result = MAPPER.readTree(responseBody);++ assertThat(result.path("statusCode").asInt())+ .as("S3 virtual-host HTTP status from inside Lambda container")+ .isEqualTo(200);+ assertThat(result.path("body").asText())+ .as("S3 object body fetched via virtual-hosted URL")+ .contains(OBJECT_BODY);+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaUtils.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaUtils.javaindex 57abbc8fb6..9846d25d47 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaUtils.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaUtils.java@@ -151,6 +151,33 @@ public final class LambdaUtils {}}+ /**+ * ZIP containing a Node.js handler that fetches an S3 object via virtual-hosted URL.+ * Receives {@code {bucket, key, endpoint}} in the event (endpoint = "host:port").+ * Used to verify embedded DNS injection into Lambda containers.+ */+ public static byte[] s3VirtualHostFetchZip() {+ String code = """+ const http = require('http');+ exports.handler = async (event) => {+ const { bucket, key, endpoint } = event;+ const url = `http://${bucket}.${endpoint}/${key}`;+ console.log('[dns-probe] fetching', url);+ return new Promise((resolve, reject) => {+ http.get(url, (res) => {+ let data = '';+ res.on('data', chunk => data += chunk);+ res.on('end', () => {+ console.log('[dns-probe] status', res.statusCode, 'body', data);+ resolve({ statusCode: res.statusCode, body: data });+ });+ }).on('error', e => reject(new Error(e.message)));+ });+ };+ """;+ return createZip("index.js", code);+ }+private static byte[] createZip(String filename, String content) {try {ByteArrayOutputStream baos = new ByteArrayOutputStream();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/dns/EmbeddedDnsServer.java b/src/main/java/io/github/hectorvent/floci/core/common/dns/EmbeddedDnsServer.javaindex bffac4e330..8e69105806 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/dns/EmbeddedDnsServer.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/dns/EmbeddedDnsServer.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.core.common.dns;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.docker.ContainerDetector;+import io.quarkus.runtime.Startup;import io.vertx.core.Vertx;import io.vertx.core.buffer.Buffer;import io.vertx.core.datagram.DatagramSocket;@@ -34,12 +35,14 @@ import java.util.Optional;* Only starts when Floci detects it is running inside Docker. No-op on the host.*/@ApplicationScoped+@Startuppublic class EmbeddedDnsServer {private static final Logger LOG = Logger.getLogger(EmbeddedDnsServer.class);private static final int DNS_PORT = 53;private static final int TTL = 60;private static final String FALLBACK_UPSTREAM = "127.0.0.11";+ public static final String DEFAULT_SUFFIX = "localhost.floci.io";private volatile String serverIp;private final List<String> suffixes = new ArrayList<>();@@ -58,7 +61,7 @@ public class EmbeddedDnsServer {String myIp = InetAddress.getLocalHost().getHostAddress();upstreamDns = readUpstreamDns();- config.hostname().ifPresent(suffixes::add);+ suffixes.add(config.hostname().orElse(DEFAULT_SUFFIX));config.dns().extraSuffixes().ifPresent(suffixes::addAll);DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions().setIpV6(false));diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3VirtualHostFilter.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3VirtualHostFilter.javaindex a9bcc40274..06ffc176d3 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/S3VirtualHostFilter.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/S3VirtualHostFilter.java@@ -1,32 +1,35 @@package io.github.hectorvent.floci.services.s3;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.dns.EmbeddedDnsServer;+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;import jakarta.ws.rs.container.ContainerRequestContext;import jakarta.ws.rs.container.ContainerRequestFilter;import jakarta.ws.rs.container.PreMatching;import jakarta.ws.rs.core.UriBuilder;import jakarta.ws.rs.ext.Provider;-import org.eclipse.microprofile.config.ConfigProvider;import java.net.URI;-import java.util.Optional;@Provider@PreMatching+@ApplicationScopedpublic class S3VirtualHostFilter implements ContainerRequestFilter {private final String baseHostname;- public S3VirtualHostFilter() {- var config = ConfigProvider.getConfig();- String baseUrl = config- .getOptionalValue("floci.base-url", String.class)- .orElse("http://localhost:4566");- Optional<String> hostname = config- .getOptionalValue("floci.hostname", String.class);- String effectiveUrl = hostname- .map(h -> baseUrl.replaceFirst("://[^:/]+(:\\d+)?", "://" + h + "$1"))- .orElse(baseUrl);- this.baseHostname = extractHostnameFromUrl(effectiveUrl);+ @Inject+ public S3VirtualHostFilter(EmulatorConfig config, ContainerDetector containerDetector) {+ this.baseHostname = config.hostname()+ .orElseGet(() -> containerDetector.isRunningInContainer()+ ? EmbeddedDnsServer.DEFAULT_SUFFIX+ : extractHostnameFromUrl(config.baseUrl()));+ }++ S3VirtualHostFilter() {+ this.baseHostname = "localhost";}@Override