Light, fluffy, and always free - The AWS Local Emulator alternative
feat(lambda): embedded DNS server for virtual-hosted S3 resolution (#585)
Hector Venturae023936a8138
diff --git a/docker-compose.yml b/docker-compose.ymlindex d7365cc86b..1766738032 100644--- a/docker-compose.yml+++ b/docker-compose.yml@@ -22,7 +22,7 @@ services:networks:floci_default:aliases:- - localhost.floci.cloud+ - localhost.floci.ionetworks:floci_default:diff --git a/docs/configuration/application-yml.md b/docs/configuration/application-yml.mdindex 99bc585883..7d6b625ece 100644--- a/docs/configuration/application-yml.md+++ b/docs/configuration/application-yml.md@@ -64,6 +64,15 @@ floci:opensearch:flush-interval-ms: 5000+ dns:+ # Extra hostname suffixes resolved to Floci's container IP by the embedded DNS server.+ # The primary suffix (floci.hostname or derived from base-url) is always included.+ # Useful when migrating from LocalStack — Lambda functions that hardcode+ # localhost.localstack.cloud as their endpoint work without code changes.+ # Via env var (comma-separated): FLOCI_DNS_EXTRA_SUFFIXES=localhost.localstack.cloud,other.internal+ # extra-suffixes:+ # - localhost.localstack.cloud+auth:validate-signatures: false # Set to true to enforce AWS SigV4 validationpresign-secret: local-emulator-secret # HMAC secret for S3 pre-signed URL verification@@ -226,6 +235,7 @@ All keys in this table are declared on `EmulatorConfig` and accept environment v| `FLOCI_DEFAULT_AVAILABILITY_ZONE` | `us-east-1a` | Default AZ reported by EC2, RDS, and other AZ-aware services || `FLOCI_DEFAULT_ACCOUNT_ID` | `000000000000` | Default AWS account ID used in ARNs || `FLOCI_ECR_BASE_URI` | `public.ecr.aws` | Base URI used when pulling container images (e.g. Lambda) |+| `FLOCI_DNS_EXTRA_SUFFIXES` | *(unset)* | Comma-separated extra hostname suffixes the embedded DNS server resolves to Floci's container IP. E.g. `localhost.localstack.cloud,localhost.example.internal` || `FLOCI_SERVICES_SSM_MAX_PARAMETER_HISTORY` | `5` | Max parameter versions kept || `FLOCI_SERVICES_SQS_DEFAULT_VISIBILITY_TIMEOUT` | `30` | Default visibility timeout (seconds) || `FLOCI_SERVICES_SQS_MAX_MESSAGE_SIZE` | `262144` | Max message size (bytes) |diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex c56ad66b60..22d2ece871 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -143,6 +143,58 @@ services:- /var/run/docker.sock:/var/run/docker.sock```+### S3 virtual-hosted-style addressing inside Lambda containers++AWS SDKs use **virtual-hosted-style** S3 addressing by default, forming URLs like+`https://my-bucket.s3.amazonaws.com/key`. Against Floci the same pattern becomes+`http://my-bucket.localhost.floci.io:4566/key`.++When Floci runs **inside Docker**, Lambda containers are on the same Docker+network. Docker's embedded DNS resolves the exact alias `localhost.floci.io`+correctly, but has no wildcard support — `my-bucket.localhost.floci.io`+falls through to public DNS and resolves to the wrong IP, causing the Lambda+invocation to time out.++**Floci solves this automatically** by running an embedded DNS server (UDP/53)+on its container IP. All Lambda containers launched by Floci are configured to+use it as their DNS resolver. The embedded DNS server:++- Resolves `*.localhost.floci.io` → Floci's Docker network IP+- Forwards all other queries to the upstream resolver from `/etc/resolv.conf`++No extra configuration or `cap_add` is needed — Docker containers have+`CAP_NET_BIND_SERVICE` in their default capability set, so Floci (running as a+non-root user) can bind UDP/53 without any changes to your Compose file.++!!! note "Path-style as a workaround"+ If you cannot use virtual-hosted-style (e.g. Floci is running natively on+ the host, not in Docker), configure the SDK client with+ `forcePathStyle: true` / `s3ForcePathStyle: true`. Requests will go to+ `http://localhost:4566/my-bucket/key` instead and work without DNS.++#### Migrating from LocalStack++If your Lambda functions have `AWS_ENDPOINT_URL=http://localhost.localstack.cloud:4566`+hardcoded, add the LocalStack suffix to Floci's DNS resolver so it resolves to+Floci's IP without any function-side changes:++```yaml+floci:+ dns:+ extra-suffixes:+ - localhost.localstack.cloud+```++Via environment variable — use a comma-separated list for multiple suffixes:++```bash+# Single suffix+FLOCI_DNS_EXTRA_SUFFIXES=localhost.localstack.cloud++# Multiple suffixes+FLOCI_DNS_EXTRA_SUFFIXES=localhost.localstack.cloud,localhost.example.internal+```+### Private registry authenticationContainer image functions (`"PackageType": "Image"`) that pull from private registries need Docker credentials. See [Docker Configuration → Private Registry Authentication](../configuration/docker.md#private-registry-authentication) for the full guide.diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 4f4de875a7..132159af06 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -53,6 +53,8 @@ public interface EmulatorConfig {StorageConfig storage();+ DnsConfig dns();+AuthConfig auth();ServicesConfig services();@@ -61,6 +63,27 @@ public interface EmulatorConfig {InitHooksConfig initHooks();+ interface DnsConfig {+ /**+ * Additional hostname suffixes the embedded DNS server will resolve to Floci's+ * container IP, alongside the primary {@code floci.hostname}.+ *+ * Useful for migrating from LocalStack without changing Lambda endpoint configuration:+ * <pre>+ * floci:+ * dns:+ * extra-suffixes:+ * - localhost.localstack.cloud+ * </pre>+ *+ * Via environment variable (comma-separated for multiple values):+ * <pre>+ * FLOCI_DNS_EXTRA_SUFFIXES=localhost.localstack.cloud,localhost.example.internal+ * </pre>+ */+ Optional<List<String>> extraSuffixes();+ }+interface StorageConfig {@WithDefault("hybrid")String mode();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.javanew file mode 100644index 0000000000..bffac4e330--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/core/common/dns/EmbeddedDnsServer.java@@ -0,0 +1,233 @@+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.vertx.core.Vertx;+import io.vertx.core.buffer.Buffer;+import io.vertx.core.datagram.DatagramSocket;+import io.vertx.core.datagram.DatagramSocketOptions;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.net.DatagramPacket;+import java.net.InetAddress;+import java.nio.ByteBuffer;+import java.nio.file.Files;+import java.nio.file.Path;+import java.util.ArrayList;+import java.util.Arrays;+import java.util.List;+import java.util.Optional;++/**+ * Embedded UDP/53 DNS server that runs inside the Floci container and is injected+ * into every spawned container (Lambda, RDS, ElastiCache) as their DNS resolver.+ *+ * Resolves *.{floci.hostname} (and any configured extra-suffixes) to Floci's own+ * Docker network IP so virtual-hosted S3 URLs (my-bucket.floci:4566) work from+ * inside Lambda containers without requiring wildcard Docker aliases.+ *+ * All other queries are forwarded transparently to the upstream resolver read from+ * /etc/resolv.conf (Docker's embedded DNS at 127.0.0.11).+ *+ * Only starts when Floci detects it is running inside Docker. No-op on the host.+ */+@ApplicationScoped+public 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";++ private volatile String serverIp;+ private final List<String> suffixes = new ArrayList<>();+ private String upstreamDns;++ EmbeddedDnsServer(List<String> suffixes) {+ this.suffixes.addAll(suffixes);+ }++ @Inject+ public EmbeddedDnsServer(EmulatorConfig config, ContainerDetector containerDetector, Vertx vertx) {+ if (!containerDetector.isRunningInContainer()) {+ return;+ }+ try {+ String myIp = InetAddress.getLocalHost().getHostAddress();+ upstreamDns = readUpstreamDns();++ config.hostname().ifPresent(suffixes::add);+ config.dns().extraSuffixes().ifPresent(suffixes::addAll);++ DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions().setIpV6(false));+ socket.listen(DNS_PORT, "0.0.0.0", ar -> {+ if (ar.succeeded()) {+ serverIp = myIp;+ LOG.infov("Embedded DNS server started on {0}:53, resolving {1} → {0}", myIp, suffixes);+ socket.handler(packet -> handleQuery(+ vertx, socket, packet.data().getBytes(),+ packet.sender().host(), packet.sender().port(), myIp));+ } else {+ LOG.warnv("Embedded DNS server failed to bind on port 53: {0}", ar.cause().getMessage());+ }+ });+ } catch (Exception e) {+ LOG.warnv("Failed to initialize embedded DNS server: {0}", e.getMessage());+ }+ }++ public Optional<String> getServerIp() {+ return Optional.ofNullable(serverIp);+ }++ // ── packet handling ───────────────────────────────────────────────────────++ private void handleQuery(Vertx vertx, DatagramSocket socket, byte[] data,+ String senderHost, int senderPort, String myIp) {+ try {+ ByteBuffer buf = ByteBuffer.wrap(data);+ short txId = buf.getShort();+ short flags = buf.getShort();+ short qdCount = buf.getShort();+ buf.getShort(); // ancount+ buf.getShort(); // nscount+ buf.getShort(); // arcount++ if ((flags & 0x8000) != 0 || qdCount < 1) {+ return; // not a standard query+ }++ int questionOffset = buf.position(); // always 12 for a standard query+ String qname = readName(buf, data);+ short qtype = buf.getShort();+ buf.getShort(); // qclass+ int questionEnd = buf.position();++ if (qtype == 1 && matchesSuffix(qname)) {+ byte[] response = buildAResponse(data, txId, questionOffset, questionEnd, myIp);+ socket.send(Buffer.buffer(response), senderPort, senderHost, v -> {});+ } else {+ forwardAsync(vertx, socket, data, senderHost, senderPort);+ }+ } catch (Exception e) {+ LOG.debugv("DNS packet error: {0}", e.getMessage());+ }+ }++ // ── helpers ───────────────────────────────────────────────────────────────++ boolean matchesSuffix(String name) {+ if (name == null || name.isEmpty()) {+ return false;+ }+ String lower = name.toLowerCase();+ for (String suffix : suffixes) {+ String s = suffix.toLowerCase();+ if (lower.equals(s) || lower.endsWith("." + s)) {+ return true;+ }+ }+ return false;+ }++ String readName(ByteBuffer buf, byte[] data) {+ StringBuilder sb = new StringBuilder();+ int safety = 0;+ while (buf.hasRemaining() && safety++ < 128) {+ int len = buf.get() & 0xFF;+ if (len == 0) {+ break;+ }+ if ((len & 0xC0) == 0xC0) {+ // compression pointer+ int offset = ((len & 0x3F) << 8) | (buf.get() & 0xFF);+ ByteBuffer ptr = ByteBuffer.wrap(data);+ ptr.position(offset);+ if (sb.length() > 0) {+ sb.append('.');+ }+ sb.append(readName(ptr, data));+ return sb.toString();+ }+ if (sb.length() > 0) {+ sb.append('.');+ }+ byte[] label = new byte[len];+ buf.get(label);+ sb.append(new String(label));+ }+ return sb.toString();+ }++ byte[] buildAResponse(byte[] query, short txId, int questionOffset, int questionEnd, String ip) {+ int questionLength = questionEnd - questionOffset;+ // header(12) + question + answer(name-ptr(2) + type(2) + class(2) + ttl(4) + rdlen(2) + rdata(4))+ ByteBuffer resp = ByteBuffer.allocate(12 + questionLength + 16);++ // header+ resp.putShort(txId);+ resp.putShort((short) 0x8180); // QR=1, AA=1, RD=1, RCODE=0+ resp.putShort((short) 1); // qdcount+ resp.putShort((short) 1); // ancount+ resp.putShort((short) 0); // nscount+ resp.putShort((short) 0); // arcount++ // question (copied verbatim from query)+ resp.put(query, questionOffset, questionLength);++ // answer+ resp.putShort((short) 0xC00C); // name pointer to offset 12 (start of question name)+ resp.putShort((short) 1); // type A+ resp.putShort((short) 1); // class IN+ resp.putInt(TTL);+ resp.putShort((short) 4); // rdlength++ for (String octet : ip.split("\\.")) {+ resp.put((byte) Integer.parseInt(octet));+ }++ return resp.array();+ }++ private void forwardAsync(Vertx vertx, DatagramSocket socket, byte[] query,+ String senderHost, int senderPort) {+ String upstream = upstreamDns;+ if (upstream == null) {+ return;+ }+ vertx.executeBlocking(() -> {+ try (java.net.DatagramSocket fwd = new java.net.DatagramSocket()) {+ fwd.setSoTimeout(2000);+ InetAddress addr = InetAddress.getByName(upstream);+ fwd.send(new DatagramPacket(query, query.length, addr, DNS_PORT));+ byte[] buf = new byte[512];+ DatagramPacket resp = new DatagramPacket(buf, buf.length);+ fwd.receive(resp);+ return Arrays.copyOf(resp.getData(), resp.getLength());+ }+ }).onSuccess(response ->+ socket.send(Buffer.buffer(response), senderPort, senderHost, v -> {})+ ).onFailure(e ->+ LOG.debugv("DNS forwarding to {0} failed: {1}", upstream, e.getMessage())+ );+ }++ private String readUpstreamDns() {+ try {+ for (String line : Files.readAllLines(Path.of("/etc/resolv.conf"))) {+ line = line.trim();+ if (line.startsWith("nameserver ")) {+ String server = line.substring("nameserver ".length()).trim();+ if (!server.equals("127.0.0.1")) {+ return server;+ }+ }+ }+ } catch (Exception e) {+ LOG.debugv("Could not read /etc/resolv.conf: {0}", e.getMessage());+ }+ return FALLBACK_UPSTREAM;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerBuilder.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerBuilder.javaindex f036c9afb4..198c8e11c3 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerBuilder.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerBuilder.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.core.common.docker;import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.dns.EmbeddedDnsServer;import com.github.dockerjava.api.model.Bind;import com.github.dockerjava.api.model.LogConfig;import com.github.dockerjava.api.model.Mount;@@ -35,11 +36,14 @@ public class ContainerBuilder {private final EmulatorConfig config;private final DockerHostResolver dockerHostResolver;+ private final EmbeddedDnsServer embeddedDnsServer;@Inject- public ContainerBuilder(EmulatorConfig config, DockerHostResolver dockerHostResolver) {+ public ContainerBuilder(EmulatorConfig config, DockerHostResolver dockerHostResolver,+ EmbeddedDnsServer embeddedDnsServer) {this.config = config;this.dockerHostResolver = dockerHostResolver;+ this.embeddedDnsServer = embeddedDnsServer;}/**@@ -49,7 +53,7 @@ public class ContainerBuilder {* @return a new Builder instance*/public Builder newContainer(String image) {- return new Builder(image, config, dockerHostResolver);+ return new Builder(image, config, dockerHostResolver, embeddedDnsServer);}/**@@ -59,6 +63,7 @@ public class ContainerBuilder {private final String image;private final EmulatorConfig config;private final DockerHostResolver dockerHostResolver;+ private final EmbeddedDnsServer embeddedDnsServer;private String name;private final List<String> env = new ArrayList<>();@@ -73,11 +78,14 @@ public class ContainerBuilder {private final List<String> extraHosts = new ArrayList<>();private LogConfig logConfig;private boolean privileged;+ private final List<String> dnsServers = new ArrayList<>();- Builder(String image, EmulatorConfig config, DockerHostResolver dockerHostResolver) {+ Builder(String image, EmulatorConfig config, DockerHostResolver dockerHostResolver,+ EmbeddedDnsServer embeddedDnsServer) {this.image = image;this.config = config;this.dockerHostResolver = dockerHostResolver;+ this.embeddedDnsServer = embeddedDnsServer;}/**@@ -278,6 +286,16 @@ public class ContainerBuilder {return this;}+ /**+ * Injects Floci's embedded DNS server into the container so virtual-hosted+ * S3 hostnames (my-bucket.localhost.floci.io) resolve to Floci's Docker+ * network IP. No-op when the embedded DNS server is not running.+ */+ public Builder withEmbeddedDns() {+ embeddedDnsServer.getServerIp().ifPresent(dnsServers::add);+ return this;+ }+/*** Builds the immutable ContainerSpec.*/@@ -296,7 +314,8 @@ public class ContainerBuilder {List.copyOf(binds),List.copyOf(extraHosts),logConfig,- privileged+ privileged,+ List.copyOf(dnsServers));}}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 1bc852827f..1585b566bf 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@@ -329,6 +329,12 @@ public class ContainerLifecycleManager {hostConfig.withLogConfig(spec.logConfig());}+ // DNS servers — used to inject Floci's embedded DNS so spawned containers+ // can resolve *.localhost.floci.io to Floci's Docker network IP.+ if (spec.dnsServers() != null && !spec.dnsServers().isEmpty()) {+ hostConfig.withDns(spec.dnsServers().toArray(new String[0]));+ }+return hostConfig;}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerSpec.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerSpec.javaindex b879e3f2ba..3bb3b0f74f 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerSpec.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/ContainerSpec.java@@ -25,6 +25,7 @@ import java.util.Map;* @param extraHosts Extra /etc/hosts entries as "hostname:ip" strings* @param logConfig Docker log driver configuration (null = daemon default)* @param privileged Whether to run the container in privileged mode (required for k3s)+ * @param dnsServers DNS server IPs to inject into the container (e.g. Floci's embedded DNS)*/public record ContainerSpec(String image,@@ -40,14 +41,15 @@ public record ContainerSpec(List<Bind> binds,List<String> extraHosts,LogConfig logConfig,- boolean privileged+ boolean privileged,+ List<String> dnsServers) {/*** Creates a minimal spec with just the image name.* All other fields will be null or empty lists.*/public ContainerSpec(String image) {- this(image, null, List.of(), null, null, null, Map.of(), List.of(), null, List.of(), List.of(), List.of(), null, false);+ this(image, null, List.of(), null, null, null, Map.of(), List.of(), null, List.of(), List.of(), List.of(), null, false, List.of());}/**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 587634c675..164e11fea1 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@@ -157,6 +157,8 @@ public class ContainerLauncher {.withHostDockerInternalOnLinux().withLogRotation();+ specBuilder.withEmbeddedDns();+// For Image package type without an explicit handler, omit CMD so the image's own CMD is usedif (fn.getHandler() != null && !fn.getHandler().isBlank()) {specBuilder.withCmd(fn.getHandler());diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 11f9532d04..6b72b23e36 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -65,6 +65,14 @@ floci:opensearch:flush-interval-ms: 5000+ dns:+ # Extra hostname suffixes resolved to Floci's container IP by the embedded DNS server.+ # Useful when migrating from LocalStack — add localhost.localstack.cloud to avoid+ # changing Lambda endpoint environment variables.+ # Via env var (comma-separated): FLOCI_DNS_EXTRA_SUFFIXES=localhost.localstack.cloud,other.internal+ # extra-suffixes:+ # - localhost.localstack.cloud+auth:validate-signatures: falsepresign-secret: local-emulator-secretdiff --git a/src/test/java/io/github/hectorvent/floci/core/common/dns/EmbeddedDnsServerTest.java b/src/test/java/io/github/hectorvent/floci/core/common/dns/EmbeddedDnsServerTest.javanew file mode 100644index 0000000000..16a086a6c4--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/dns/EmbeddedDnsServerTest.java@@ -0,0 +1,164 @@+package io.github.hectorvent.floci.core.common.dns;++import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.nio.ByteBuffer;+import java.util.List;++import static org.junit.jupiter.api.Assertions.*;++class EmbeddedDnsServerTest {++ private EmbeddedDnsServer dns;++ @BeforeEach+ void setUp() {+ dns = new EmbeddedDnsServer(List.of("localhost.floci.io"));+ }++ // ── matchesSuffix ─────────────────────────────────────────────────────────++ @Test+ void matchesSuffix_exactMatch() {+ assertTrue(dns.matchesSuffix("localhost.floci.io"));+ }++ @Test+ void matchesSuffix_singleSubdomain() {+ assertTrue(dns.matchesSuffix("my-bucket.localhost.floci.io"));+ }++ @Test+ void matchesSuffix_deeplyNested() {+ assertTrue(dns.matchesSuffix("deeply.nested.bucket.localhost.floci.io"));+ }++ @Test+ void matchesSuffix_caseInsensitive() {+ assertTrue(dns.matchesSuffix("My-Bucket.Localhost.Floci.IO"));+ }++ @Test+ void matchesSuffix_noMatch() {+ assertFalse(dns.matchesSuffix("my-bucket.s3.amazonaws.com"));+ }++ @Test+ void matchesSuffix_partialSuffixNoMatch() {+ assertFalse(dns.matchesSuffix("floci.io"));+ }++ @Test+ void matchesSuffix_nullAndEmpty() {+ assertFalse(dns.matchesSuffix(null));+ assertFalse(dns.matchesSuffix(""));+ }++ // ── readName ──────────────────────────────────────────────────────────────++ @Test+ void readName_simple() {+ // my-bucket.localhost.floci.io encoded as DNS labels+ byte[] encoded = encodeName("my-bucket.localhost.floci.io");+ ByteBuffer buf = ByteBuffer.wrap(encoded);+ assertEquals("my-bucket.localhost.floci.io", dns.readName(buf, encoded));+ }++ @Test+ void readName_singleLabel() {+ byte[] encoded = encodeName("floci");+ ByteBuffer buf = ByteBuffer.wrap(encoded);+ assertEquals("floci", dns.readName(buf, encoded));+ }++ @Test+ void readName_withCompressionPointer() {+ // Build a buffer where the name at offset 12 is "floci.io" and+ // a pointer at offset 0 points to it.+ byte[] data = new byte[20];+ // pointer at offset 0 → offset 4+ data[0] = (byte) 0xC0;+ data[1] = 0x04;+ // "floci.io" at offset 4+ byte[] name = encodeName("floci.io");+ System.arraycopy(name, 0, data, 4, name.length);++ ByteBuffer buf = ByteBuffer.wrap(data);+ assertEquals("floci.io", dns.readName(buf, data));+ }++ // ── buildAResponse ────────────────────────────────────────────────────────++ @Test+ void buildAResponse_hasCorrectTransactionId() {+ byte[] query = buildQuery("my-bucket.localhost.floci.io", (short) 0x1234);+ byte[] response = dns.buildAResponse(query, (short) 0x1234, 12, query.length, "172.19.0.2");+ short txId = ByteBuffer.wrap(response).getShort(0);+ assertEquals((short) 0x1234, txId);+ }++ @Test+ void buildAResponse_flagsIndicateResponse() {+ byte[] query = buildQuery("bucket.localhost.floci.io", (short) 1);+ byte[] response = dns.buildAResponse(query, (short) 1, 12, query.length, "10.0.0.1");+ short flags = ByteBuffer.wrap(response).getShort(2);+ assertTrue((flags & 0x8000) != 0, "QR bit must be set");+ }++ @Test+ void buildAResponse_answerCountIsOne() {+ byte[] query = buildQuery("bucket.localhost.floci.io", (short) 2);+ byte[] response = dns.buildAResponse(query, (short) 2, 12, query.length, "10.0.0.1");+ short ancount = ByteBuffer.wrap(response).getShort(6);+ assertEquals(1, ancount);+ }++ @Test+ void buildAResponse_ipAddressIsCorrect() {+ byte[] query = buildQuery("bucket.localhost.floci.io", (short) 3);+ byte[] response = dns.buildAResponse(query, (short) 3, 12, query.length, "172.19.0.42");+ // IP starts at offset: 12 (header) + questionLength + 2+2+2+4+2 = questionLength + 24+ int questionLength = query.length - 12;+ ByteBuffer resp = ByteBuffer.wrap(response);+ resp.position(12 + questionLength + 10); // skip header + question + name-ptr(2) + type(2) + class(2) + ttl(4)+ short rdlen = resp.getShort();+ assertEquals(4, rdlen);+ assertEquals((byte) 172, resp.get());+ assertEquals((byte) 19, resp.get());+ assertEquals((byte) 0, resp.get());+ assertEquals((byte) 42, resp.get());+ }++ // ── helpers ───────────────────────────────────────────────────────────────++ private byte[] encodeName(String name) {+ String[] labels = name.split("\\.");+ int len = 1; // trailing zero+ for (String l : labels) len += 1 + l.length();+ byte[] buf = new byte[len];+ int pos = 0;+ for (String label : labels) {+ buf[pos++] = (byte) label.length();+ for (char c : label.toCharArray()) buf[pos++] = (byte) c;+ }+ buf[pos] = 0;+ return buf;+ }++ private byte[] buildQuery(String name, short txId) {+ byte[] encodedName = encodeName(name);+ // header(12) + name + type(2) + class(2)+ ByteBuffer buf = ByteBuffer.allocate(12 + encodedName.length + 4);+ buf.putShort(txId);+ buf.putShort((short) 0x0100); // standard query, RD=1+ buf.putShort((short) 1); // qdcount+ buf.putShort((short) 0);+ buf.putShort((short) 0);+ buf.putShort((short) 0);+ buf.put(encodedName);+ buf.putShort((short) 1); // type A+ buf.putShort((short) 1); // class IN+ return buf.array();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeSchedulerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeSchedulerIntegrationTest.javaindex 4b5c428ee9..037da6dad7 100644--- a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeSchedulerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeSchedulerIntegrationTest.java@@ -294,6 +294,8 @@ class EventBridgeSchedulerIntegrationTest {@Overridepublic StorageConfig storage() { return null; }@Override+ public DnsConfig dns() { return Optional::empty; }+ @Overridepublic AuthConfig auth() { return null; }@Overridepublic ServicesConfig services() { return null; }diff --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 90dafb9888..9150775c75 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@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.lambda.launcher;import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.dns.EmbeddedDnsServer;import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;@@ -41,6 +42,7 @@ class ContainerLauncherTest {@Mock DockerHostResolver dockerHostResolver;@Mock EmulatorConfig config;@Mock EcrRegistryManager ecrRegistryManager;+ @Mock EmbeddedDnsServer embeddedDnsServer;@Mock RuntimeApiServer runtimeApiServer;@Mock DockerClient dockerClient;@@ -64,7 +66,9 @@ class ContainerLauncherTest {when(docker.logMaxSize()).thenReturn("10m");when(docker.logMaxFile()).thenReturn("3");- ContainerBuilder containerBuilder = new ContainerBuilder(config, dockerHostResolver);+ when(embeddedDnsServer.getServerIp()).thenReturn(Optional.empty());++ ContainerBuilder containerBuilder = new ContainerBuilder(config, dockerHostResolver, embeddedDnsServer);launcher = new ContainerLauncher(containerBuilder, lifecycleManager, logStreamer, imageResolver,runtimeApiServerFactory, dockerHostResolver, config, ecrRegistryManager);