Alternative backup DNS request solution

Author: bryce-anderson

servicetalk-dns-discovery-netty/src/main/java/io/servicetalk/dns/discovery/netty/DefaultDnsClient.java

@@ -41,6 +41,7 @@
 import io.netty.channel.EventLoop;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.handler.codec.dns.DefaultDnsQuestion;
+import io.netty.handler.codec.dns.DnsQuestion;
 import io.netty.handler.codec.dns.DnsRawRecord;
 import io.netty.handler.codec.dns.DnsRecord;
 import io.netty.resolver.ResolvedAddressTypes;
@@ -56,6 +57,7 @@
 import io.netty.util.ReferenceCountUtil;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.FutureListener;
+import io.netty.util.concurrent.GenericFutureListener;
 import io.netty.util.concurrent.Promise;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -75,6 +77,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.RandomAccess;
+import java.util.function.Function;
 import java.util.function.IntFunction;
 import javax.annotation.Nullable;
 
@@ -127,7 +130,7 @@ final class DefaultDnsClient implements DnsClient {
     private static final Cancellable TERMINATED = () -> { };
 
     private final EventLoopAwareNettyIoExecutor nettyIoExecutor;
-    private final DnsNameResolver resolver;
+    private final DnsNameResolverDelegate resolver;
     private final MinTtlCache ttlCache;
     private final long maxTTLNanos;
     private final long ttlJitterNanos;
@@ -144,6 +147,117 @@ final class DefaultDnsClient implements DnsClient {
     private final String id;
     private boolean closed;
 
+    private interface DnsNameResolverDelegate {
+        void close();
+
+        Future<List<InetAddress>> resolveAll(String name);
+
+        Future<List<DnsRecord>> resolveAll(DnsQuestion name);
+
+        long queryTimeoutMillis();
+    }
+
+    private static final class SingleResolver implements DnsNameResolverDelegate {
+        private final DnsNameResolver nettyResolver;
+
+        SingleResolver(DnsNameResolver nettyResolver) {
+            this.nettyResolver = nettyResolver;
+        }
+
+        @Override
+        public void close() {
+            nettyResolver.close();
+        }
+
+        @Override
+        public Future<List<InetAddress>> resolveAll(String name) {
+            return nettyResolver.resolveAll(name);
+        }
+
+        @Override
+        public Future<List<DnsRecord>> resolveAll(DnsQuestion question) {
+            return nettyResolver.resolveAll(question);
+        }
+
+        @Override
+        public long queryTimeoutMillis() {
+            return nettyResolver.queryTimeoutMillis();
+        }
+    }
+
+    private static final class BackupRequestResolver implements DnsNameResolverDelegate {
+
+        private final DnsNameResolver primary;
+        private final DnsNameResolver backup;
+        private final EventLoop eventLoop;
+
+        // TODO: we'll want to make sure we share the cache, make our backup request interval more flexible, and also
+        //  give ourselves some sort of budget so we don't overload DNS, but these are all possible.
+        BackupRequestResolver(DnsNameResolverBuilder builder, EventLoop eventLoop) {
+            primary = builder.build();
+            backup = builder.consolidateCacheSize(0).build();
+            this.eventLoop = eventLoop;
+        }
+
+        @Override
+        public void close() {
+            try {
+                primary.close();
+            } finally {
+                backup.close();
+            }
+        }
+
+        @Override
+        public Future<List<InetAddress>> resolveAll(String name) {
+            return compose(resolver -> resolver.resolveAll(name));
+        }
+
+        @Override
+        public Future<List<DnsRecord>> resolveAll(DnsQuestion name) {
+            return compose(resolver -> resolver.resolveAll(name));
+        }
+
+        @Override
+        public long queryTimeoutMillis() {
+            return primary.queryTimeoutMillis();
+        }
+
+        private <T> Future<T> compose(Function<DnsNameResolver, Future<T>> query) {
+            Promise<T> result = eventLoop.newPromise();
+            Future<T> r1 = query.apply(primary);
+            Future<?> timer = eventLoop.schedule(() -> join(query.apply(backup), result, null),
+                    50, MILLISECONDS);
+            join(r1, result, timer);
+            return result;
+        }
+
+        private static <T> void join(Future<? extends T> future, Promise<T> promise, @Nullable Future<?> timer) {
+            // transfer results from future to promise and cancellation from promise to future.
+            future.addListener(new GenericFutureListener<Future<T>>() {
+                @Override
+                public void operationComplete(Future<T> future) {
+                    if (timer != null) {
+                        timer.cancel(true);
+                    }
+                    if (future.isSuccess()) {
+                        promise.trySuccess(future.getNow());
+                    } else if (!future.isCancelled()) {
+                        promise.tryFailure(future.cause());
+                    }
+                }
+            });
+            promise.addListener(new GenericFutureListener<Future<T>>() {
+                @Override
+                public void operationComplete(Future<T> promise) {
+                    if (promise.isCancelled()) {
+                        future.cancel(true);
+                    }
+                }
+            });
+        }
+    }
+
     DefaultDnsClient(final String id, final IoExecutor ioExecutor, final int consolidateCacheSize,
                      final int minTTL, final int maxTTL, final int minCacheTTL, final int maxCacheTTL,
                      final int negativeTTLCacheSeconds, final long ttlJitterNanos,
@@ -229,7 +343,8 @@ final class DefaultDnsClient implements DnsClient {
         if (dnsServerAddressStreamProvider != null) {
             builder.nameServerProvider(toNettyType(dnsServerAddressStreamProvider));
         }
-        resolver = builder.build();
+        // resolver = new SingleResolver(builder.build());
+        resolver = new BackupRequestResolver(builder, eventLoop);
         this.resolutionTimeoutMillis = resolutionTimeout != null ? resolutionTimeout.toMillis() :
                 // Default value is chosen based on a combination of default "timeout" and "attempts" options of
                 // /etc/resolv.conf: https://man7.org/linux/man-pages/man5/resolv.conf.5.html