Issue 5676: Introduced the option to fall back to TCP when DNS resolving via UDP fails with a timeout

Author: cgm-aw

src/main/generated/io/vertx/core/dns/AddressResolverOptionsConverter.java

@@ -105,6 +105,11 @@ static void fromJson(Iterable<java.util.Map.Entry<String, Object>> json, Address
             obj.setServers(list);
           }
           break;
+        case "useTcpForFallbackDnsResolving":
+          if (member.getValue() instanceof Boolean) {
+            obj.setUseTcpForFallbackDnsResolving((Boolean)member.getValue());
+          }
+          break;
       }
     }
   }
@@ -141,5 +146,6 @@ static void toJson(AddressResolverOptions obj, java.util.Map<String, Object> jso
       obj.getServers().forEach(item -> array.add(item));
       json.put("servers", array);
     }
+    json.put("useTcpForFallbackDnsResolving", obj.isUseTcpForFallbackDnsResolving());
   }
 }

src/main/java/io/vertx/core/dns/AddressResolverOptions.java

@@ -103,6 +103,11 @@ public class AddressResolverOptions {
    */
   public static final boolean DEFAULT_ROUND_ROBIN_INET_ADDRESS = false;
 
+  /**
+   * The default whether to use TCP for DNS resolving if resolving via UDP times out = false
+   */
+  public static final boolean DEFAULT_USE_TCP_FOR_FALLBACK_DNS_RESOLVING = false;
+
   private String hostsPath;
   private Buffer hostsValue;
   private int hostsRefreshPeriod;
@@ -118,6 +123,7 @@ public class AddressResolverOptions {
   private int ndots;
   private boolean rotateServers;
   private boolean roundRobinInetAddress;
+  private boolean useTcpForFallbackDnsResolving;
 
   public AddressResolverOptions() {
     servers = DEFAULT_SERVERS;
@@ -133,6 +139,7 @@ public AddressResolverOptions() {
     rotateServers = DEFAULT_ROTATE_SERVERS;
     roundRobinInetAddress = DEFAULT_ROUND_ROBIN_INET_ADDRESS;
     hostsRefreshPeriod = DEFAULT_HOSTS_REFRESH_PERIOD;
+    useTcpForFallbackDnsResolving = DEFAULT_USE_TCP_FOR_FALLBACK_DNS_RESOLVING;
   }
 
   public AddressResolverOptions(AddressResolverOptions other) {
@@ -151,6 +158,7 @@ public AddressResolverOptions(AddressResolverOptions other) {
     this.ndots = other.ndots;
     this.rotateServers = other.rotateServers;
     this.roundRobinInetAddress = other.roundRobinInetAddress;
+    this.useTcpForFallbackDnsResolving = other.useTcpForFallbackDnsResolving;
   }
 
   public AddressResolverOptions(JsonObject json) {
@@ -496,6 +504,24 @@ public AddressResolverOptions setRoundRobinInetAddress(boolean roundRobinInetAdd
     return this;
   }
 
+  /**
+   * @return the value {@code true} when using TCP for DNS resolving as a fallback is enabled when resolving via
+   * UDP times out.
+   */
+  public boolean isUseTcpForFallbackDnsResolving() {
+    return useTcpForFallbackDnsResolving;
+  }
+
+  /**
+   * Set to {@code true} to enable using TCP as a fallback for DNS resolving when using UDP times out.
+   *
+   * @return a reference to this, so the API can be used fluently
+   */
+  public AddressResolverOptions setUseTcpForFallbackDnsResolving(boolean useTcpForFallbackDnsResolving) {
+    this.useTcpForFallbackDnsResolving = useTcpForFallbackDnsResolving;
+    return this;
+  }
+
   public JsonObject toJson() {
     JsonObject json = new JsonObject();
     AddressResolverOptionsConverter.toJson(this, json);

src/main/java/io/vertx/core/impl/resolver/DnsResolverProvider.java

@@ -105,7 +105,8 @@ private DnsResolverProvider(VertxInternal vertx, AddressResolverOptions options)
     DnsNameResolverBuilder builder = new DnsNameResolverBuilder();
     builder.hostsFileEntriesResolver(this);
     builder.channelFactory(() -> vertx.transport().datagramChannel());
-    builder.socketChannelFactory(() -> (SocketChannel) vertx.transport().channelFactory(false).newChannel());
+    builder.socketChannelFactory(() -> (SocketChannel) vertx.transport().channelFactory(false).newChannel(),
+      options.isUseTcpForFallbackDnsResolving());
     builder.nameServerProvider(nameServerAddressProvider);
     builder.optResourceEnabled(options.isOptResourceEnabled());
     builder.resolveCache(resolveCache);

src/test/java/io/vertx/core/dns/HostnameResolutionTest.java

@@ -191,6 +191,7 @@ public void testOptions() {
     assertEquals(AddressResolverOptions.DEFAULT_RD_FLAG, options.getRdFlag());
     assertEquals(AddressResolverOptions.DEFAULT_NDOTS, options.getNdots());
     assertEquals(AddressResolverOptions.DEFAULT_SEARCH_DOMAINS, options.getSearchDomains());
+    assertEquals(AddressResolverOptions.DEFAULT_USE_TCP_FOR_FALLBACK_DNS_RESOLVING, options.isUseTcpForFallbackDnsResolving());
 
     boolean optResourceEnabled = TestUtils.randomBoolean();
     List<String> servers = Arrays.asList("1.2.3.4", "5.6.7.8");
@@ -205,11 +206,13 @@ public void testOptions() {
     for (int i = 0; i < 2; i++) {
       searchDomains.add(TestUtils.randomAlphaString(15));
     }
+    boolean useTcpForFallbackDnsResolving = true;
 
     assertSame(options, options.setOptResourceEnabled(optResourceEnabled));
     assertSame(options, options.setServers(new ArrayList<>(servers)));
     assertSame(options, options.setCacheMinTimeToLive(0));
     assertSame(options, options.setCacheMinTimeToLive(minTTL));
+    assertSame(options, options.setUseTcpForFallbackDnsResolving(useTcpForFallbackDnsResolving));
     try {
       options.setCacheMinTimeToLive(-1);
       fail("Should throw exception");
@@ -266,6 +269,7 @@ public void testOptions() {
     assertEquals(rdFlag, options.getRdFlag());
     assertEquals(ndots, options.getNdots());
     assertEquals(searchDomains, options.getSearchDomains());
+    assertEquals(useTcpForFallbackDnsResolving, options.isUseTcpForFallbackDnsResolving());
 
     // Test copy and json copy
     AddressResolverOptions copy = new AddressResolverOptions(options);
@@ -303,6 +307,7 @@ public void testOptions() {
     assertEquals(rdFlag, jsonCopy.getRdFlag());
     assertEquals(ndots, jsonCopy.getNdots());
     assertEquals(searchDomains, jsonCopy.getSearchDomains());
+    assertEquals(useTcpForFallbackDnsResolving, jsonCopy.isUseTcpForFallbackDnsResolving());
   }
 
   @Test
@@ -318,6 +323,7 @@ public void testDefaultJsonOptions() {
     assertEquals(AddressResolverOptions.DEFAULT_RD_FLAG, options.getRdFlag());
     assertEquals(AddressResolverOptions.DEFAULT_SEARCH_DOMAINS, options.getSearchDomains());
     assertEquals(AddressResolverOptions.DEFAULT_NDOTS, options.getNdots());
+    assertEquals(AddressResolverOptions.DEFAULT_USE_TCP_FOR_FALLBACK_DNS_RESOLVING, options.isUseTcpForFallbackDnsResolving());
   }
 
   @Test