Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(dns): forward queries without per-context ordering (#4643)

Sam Fakhreddine89f59dea625a
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.java
index 91c933cd84..2df2b7aa7b 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
@@ -5,7 +5,9 @@ import io.github.hectorvent.floci.config.TlsConfigSource;
import io.github.hectorvent.floci.core.common.RegionResolver;
import io.github.hectorvent.floci.core.common.docker.ContainerDetector;
import io.quarkus.runtime.Startup;
+import io.vertx.core.Future;
import io.vertx.core.Vertx;
+import io.vertx.core.WorkerExecutor;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.datagram.DatagramSocket;
import io.vertx.core.datagram.DatagramSocketOptions;
@@ -28,6 +30,7 @@ import java.util.LinkedHashSet;
import java.util.List;
import java.util.Optional;
import java.util.SequencedSet;
+import java.util.concurrent.Callable;
import java.util.concurrent.ThreadLocalRandom;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -72,6 +75,11 @@ public class EmbeddedDnsServer {
// Per-upstream timeout. Bounded so trying every upstream stays under a typical 5s client
// resolver timeout even in the worst case.
private static final int FORWARD_TIMEOUT_MS = 1500;
+ // Forwards block a thread for up to FORWARD_TIMEOUT_MS per target, so they get their own
+ // bounded pool: a burst of queries to a dead resolver must not take every thread of the
+ // shared worker pool that planQuery and the rest of the emulator also run on.
+ private static final String FORWARD_POOL_NAME = "floci-dns-forward";
+ private static final int FORWARD_POOL_SIZE = 8;
public static final String DEFAULT_SUFFIX = "localhost.floci.io";
public static final String LOCALSTACK_SUFFIX = "localhost.localstack.cloud";
private static final Pattern EC2_PRIVATE_DNS_NAME =
@@ -88,6 +96,7 @@ public class EmbeddedDnsServer {
private volatile String serverIp;
private final SequencedSet<String> suffixes = new LinkedHashSet<>();
private volatile List<String> upstreamDnsServers = List.of();
+ private volatile WorkerExecutor forwardPool;
// Held as the Iterable a CDI Instance already is, so iterating resolves the beans lazily on
// the packet path rather than at startup, where a source's storage must not be touched yet.
private final Iterable<DnsRecordSource> recordSources;
@@ -576,7 +585,7 @@ public class EmbeddedDnsServer {
if (upstreams.isEmpty()) {
return;
}
- vertx.executeBlocking(() -> forwardToUpstreams(query, upstreams, DNS_PORT))
+ submitForward(forwardPool(vertx), () -> forwardToUpstreams(query, upstreams, DNS_PORT))
.onSuccess(response ->
socket.send(Buffer.buffer(response), senderPort, senderHost, v -> {}))
.onFailure(e ->
@@ -597,7 +606,7 @@ public class EmbeddedDnsServer {
String senderHost, int senderPort,
List<DnsForwardingRule.Target> targets, String qname,
short txId, int questionOffset, int questionEnd) {
- vertx.executeBlocking(() -> forwardToTargets(query, shuffled(targets)))
+ submitForward(forwardPool(vertx), () -> forwardToTargets(query, shuffled(targets)))
.onSuccess(response ->
socket.send(Buffer.buffer(response), senderPort, senderHost, v -> {}))
.onFailure(e -> {
@@ -609,6 +618,28 @@ public class EmbeddedDnsServer {
});
}
+ /**
+ * Runs a blocking forward on the pool without Vert.x's per-context ordering, so one
+ * unresponsive upstream or rule target does not hold up forwarding for every other query.
+ */
+ static <T> Future<T> submitForward(WorkerExecutor pool, Callable<T> task) {
+ return pool.executeBlocking(task, false);
+ }
+
+ private WorkerExecutor forwardPool(Vertx vertx) {
+ WorkerExecutor pool = forwardPool;
+ if (pool == null) {
+ synchronized (this) {
+ pool = forwardPool;
+ if (pool == null) {
+ pool = vertx.createSharedWorkerExecutor(FORWARD_POOL_NAME, FORWARD_POOL_SIZE);
+ forwardPool = pool;
+ }
+ }
+ }
+ return pool;
+ }
+
private static List<DnsForwardingRule.Target> shuffled(List<DnsForwardingRule.Target> targets) {
if (targets.size() < 2) {
return targets;
diff --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.java
index d862b4d8be..fceab727e4 100644
--- 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.java
@@ -1,5 +1,7 @@
package io.github.hectorvent.floci.core.common.dns;
+import io.vertx.core.Vertx;
+import io.vertx.core.WorkerExecutor;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -11,6 +13,8 @@ import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.*;
@@ -673,6 +677,29 @@ class EmbeddedDnsServerTest {
List.of(new DnsForwardingRule.Target("127.0.0.1", 1))));
}
+ @Test
+ void submitForward_slowForwardDoesNotBlockTheNextOneOnTheSameContext() throws Exception {
+ // Catches: forwards submitted from one event-loop context run one at a time, so a single
+ // unresponsive upstream stalls every other query's forwarding until it times out.
+ Vertx vertx = Vertx.vertx();
+ WorkerExecutor pool = vertx.createSharedWorkerExecutor("dns-forward-test", 2);
+ CountDownLatch releaseSlow = new CountDownLatch(1);
+ CountDownLatch fastDone = new CountDownLatch(1);
+ try {
+ vertx.getOrCreateContext().runOnContext(v -> {
+ EmbeddedDnsServer.submitForward(pool, () -> releaseSlow.await(10, TimeUnit.SECONDS));
+ EmbeddedDnsServer.submitForward(pool, () -> {
+ fastDone.countDown();
+ return null;
+ });
+ });
+ assertTrue(fastDone.await(5, TimeUnit.SECONDS));
+ } finally {
+ releaseSlow.countDown();
+ vertx.close().toCompletionStage().toCompletableFuture().get(10, TimeUnit.SECONDS);
+ }
+ }
+
/** Replies to the first datagram received with a fixed payload, on a daemon thread. */
private void startResponder(DatagramSocket responder, byte[] responsePayload) {
Thread t = new Thread(() -> {