Now it's possible to configure NettyNioAsyncHttpClient in order to use a

non blocking DNS resolver.

Author: martinKindall

.changes/next-release/bugfix-NettyNIOHTTPClient-35595eb.json

@@ -0,0 +1,6 @@
+{
+    "category": "Netty NIO HTTP Client", 
+    "contributor": "martinKindall", 
+    "type": "bugfix", 
+    "description": "By default, Netty threads are blocked during dns resolution, namely InetAddress.getByName is used under the hood. Now, there's an option to configure the NettyNioAsyncHttpClient in order to use a non blocking dns resolution strategy."
+}

bom-internal/pom.xml

@@ -134,6 +134,16 @@
                 <artifactId>netty-buffer</artifactId>
                 <version>${netty.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.netty</groupId>
+                <artifactId>netty-resolver</artifactId>
+                <version>${netty.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.netty</groupId>
+                <artifactId>netty-resolver-dns</artifactId>
+                <version>${netty.version}</version>
+            </dependency>
             <dependency>
                 <groupId>org.reactivestreams</groupId>
                 <artifactId>reactive-streams</artifactId>

core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/util/ClassLoaderHelper.java

@@ -69,8 +69,7 @@ private static Class<?> loadClassViaContext(String fqcn) {
      * @throws ClassNotFoundException
      *             if failed to load the class
      */
-    public static Class<?> loadClass(String fqcn, Class<?>... classes)
-            throws ClassNotFoundException {
+    public static Class<?> loadClass(String fqcn, Class<?>... classes) throws ClassNotFoundException {
         return loadClass(fqcn, true, classes);
     }
 

http-clients/netty-nio-client/pom.xml

@@ -85,6 +85,15 @@
             <groupId>io.netty</groupId>
             <artifactId>netty-transport-classes-epoll</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-resolver</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-resolver-dns</artifactId>
+            <optional>true</optional>
+        </dependency>
 
         <!--Reactive Dependencies-->
         <dependency>

http-clients/netty-nio-client/src/main/java/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.java

@@ -103,6 +103,7 @@ private NettyNioAsyncHttpClient(DefaultBuilder builder, AttributeMap serviceDefa
                                              .sdkEventLoopGroup(sdkEventLoopGroup)
                                              .sslProvider(resolveSslProvider(builder))
                                              .proxyConfiguration(builder.proxyConfiguration)
+                                             .useNonBlockingDnsResolver(builder.useNonBlockingDnsResolver)
                                              .build();
     }
 
@@ -189,7 +190,7 @@ private Duration resolveHealthCheckPingPeriod(Http2Configuration http2Configurat
 
     private SdkEventLoopGroup nonManagedEventLoopGroup(SdkEventLoopGroup eventLoopGroup) {
         return SdkEventLoopGroup.create(new NonManagedEventLoopGroup(eventLoopGroup.eventLoopGroup()),
-                                        eventLoopGroup.channelFactory());
+                                        eventLoopGroup.channelFactory(), eventLoopGroup.channelType());
     }
 
     @Override
@@ -475,6 +476,15 @@ public interface Builder extends SdkAsyncHttpClient.Builder<NettyNioAsyncHttpCli
          * @return the builder for method chaining.
          */
         Builder http2Configuration(Consumer<Http2Configuration.Builder> http2ConfigurationBuilderConsumer);
+
+        /**
+         * Configure whether to use a non-blocking dns resolver or not. False by default, as netty's default dns resolver is
+         * blocking; it namely calls java.net.InetAddress.getByName.
+         * <p>
+         * When enabled, a non-blocking dns resolver will be used instead, by modifying netty's bootstrap configuration.
+         * See https://netty.io/news/2016/05/26/4-1-0-Final.html
+         */
+        Builder useNonBlockingDnsResolver(boolean useNonBlockingDnsResolver);
     }
 
     /**
@@ -492,6 +502,7 @@ private static final class DefaultBuilder implements Builder {
         private Http2Configuration http2Configuration;
         private SslProvider sslProvider;
         private ProxyConfiguration proxyConfiguration;
+        private boolean useNonBlockingDnsResolver;
 
         private DefaultBuilder() {
         }
@@ -716,6 +727,16 @@ public void setHttp2Configuration(Http2Configuration http2Configuration) {
             http2Configuration(http2Configuration);
         }
 
+        @Override
+        public Builder useNonBlockingDnsResolver(boolean useNonBlockingDnsResolver) {
+            this.useNonBlockingDnsResolver = useNonBlockingDnsResolver;
+            return this;
+        }
+
+        public void setUseNonBlockingDnsResolver(boolean useNonBlockingDnsResolver) {
+            useNonBlockingDnsResolver(useNonBlockingDnsResolver);
+        }
+
         @Override
         public SdkAsyncHttpClient buildWithDefaults(AttributeMap serviceDefaults) {
             if (standardOptions.get(SdkHttpConfigurationOption.TLS_NEGOTIATION_TIMEOUT) == null) {

http-clients/netty-nio-client/src/main/java/software/amazon/awssdk/http/nio/netty/SdkEventLoopGroup.java

@@ -19,18 +19,20 @@
 import io.netty.channel.ChannelFactory;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.DatagramChannel;
+import io.netty.channel.socket.nio.NioDatagramChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
 import java.util.Optional;
 import java.util.concurrent.ThreadFactory;
 import software.amazon.awssdk.annotations.SdkPublicApi;
-import software.amazon.awssdk.http.nio.netty.internal.utils.SocketChannelResolver;
+import software.amazon.awssdk.http.nio.netty.internal.utils.ChannelResolver;
 import software.amazon.awssdk.utils.ThreadFactoryBuilder;
 import software.amazon.awssdk.utils.Validate;
 
 /**
- * Provides {@link EventLoopGroup} and {@link ChannelFactory} for {@link NettyNioAsyncHttpClient}.
+ * Provides {@link EventLoopGroup}, {@link ChannelFactory} and {@link DatagramChannel} for {@link NettyNioAsyncHttpClient}.
  * <p>
- * There are three ways to create a new instance.
+ * There are four ways to create a new instance.
  *
  * <ul>
  * <li>using {@link #builder()} to provide custom configuration of {@link EventLoopGroup}.
@@ -39,11 +41,15 @@
  *
  * <li>Using {@link #create(EventLoopGroup)} to provide a custom {@link EventLoopGroup}. {@link ChannelFactory} will
  * be resolved based on the type of {@link EventLoopGroup} provided via
- * {@link SocketChannelResolver#resolveSocketChannelFactory(EventLoopGroup)}
+ * {@link ChannelResolver#resolveSocketChannelFactory(EventLoopGroup)}. {@link DatagramChannel} will be resolved based
+ * on the type of {@link EventLoopGroup} provided via {@link ChannelResolver#resolveDatagramChannel(EventLoopGroup)}
  * </li>
  *
- * <li>Using {@link #create(EventLoopGroup, ChannelFactory)} to provide a custom {@link EventLoopGroup} and
- * {@link ChannelFactory}
+ * <li>Using {@link #create(EventLoopGroup, ChannelFactory)} to provide a custom
+ * {@link EventLoopGroup} and {@link ChannelFactory}</li>
+ *
+ * <li>Using {@link #create(EventLoopGroup, ChannelFactory, Class)} to provide a custom
+ * {@link EventLoopGroup}, {@link ChannelFactory} and {@link DatagramChannel}
  * </ul>
  *
  * <p>
@@ -63,12 +69,23 @@ public final class SdkEventLoopGroup {
 
     private final EventLoopGroup eventLoopGroup;
     private final ChannelFactory<? extends Channel> channelFactory;
+    private final Class<? extends DatagramChannel> channelType;
 
     SdkEventLoopGroup(EventLoopGroup eventLoopGroup, ChannelFactory<? extends Channel> channelFactory) {
         Validate.paramNotNull(eventLoopGroup, "eventLoopGroup");
         Validate.paramNotNull(channelFactory, "channelFactory");
         this.eventLoopGroup = eventLoopGroup;
         this.channelFactory = channelFactory;
+        this.channelType = resolveChannelType();
+    }
+
+    SdkEventLoopGroup(EventLoopGroup eventLoopGroup, ChannelFactory<? extends Channel> channelFactory,
+                      Class<? extends DatagramChannel> channelType) {
+        Validate.paramNotNull(eventLoopGroup, "eventLoopGroup");
+        Validate.paramNotNull(channelFactory, "channelFactory");
+        this.eventLoopGroup = eventLoopGroup;
+        this.channelFactory = channelFactory;
+        this.channelType = channelType;
     }
 
     /**
@@ -77,6 +94,7 @@ public final class SdkEventLoopGroup {
     private SdkEventLoopGroup(DefaultBuilder builder) {
         this.eventLoopGroup = resolveEventLoopGroup(builder);
         this.channelFactory = resolveChannelFactory();
+        this.channelType = resolveChannelType();
     }
 
     /**
@@ -93,6 +111,13 @@ public ChannelFactory<? extends Channel> channelFactory() {
         return channelFactory;
     }
 
+    /**
+     * @return the {@link ChannelFactory} to be used with Netty Http Client.
+     */
+    public Class<? extends DatagramChannel> channelType() {
+        return channelType;
+    }
+
     /**
      * Creates a new instance of SdkEventLoopGroup with {@link EventLoopGroup} and {@link ChannelFactory}
      * to be used with {@link NettyNioAsyncHttpClient}.
@@ -105,6 +130,20 @@ public static SdkEventLoopGroup create(EventLoopGroup eventLoopGroup, ChannelFac
         return new SdkEventLoopGroup(eventLoopGroup, channelFactory);
     }
 
+    /**
+     * Creates a new instance of SdkEventLoopGroup with {@link EventLoopGroup}, {@link ChannelFactory}
+     * and {@link DatagramChannel} to be used with {@link NettyNioAsyncHttpClient}.
+     *
+     * @param eventLoopGroup the EventLoopGroup to be used
+     * @param channelFactory the channel factor to be used
+     * @param channelType the channel type to be used
+     * @return a new instance of SdkEventLoopGroup
+     */
+    public static SdkEventLoopGroup create(EventLoopGroup eventLoopGroup, ChannelFactory<? extends Channel> channelFactory,
+                                           Class<? extends DatagramChannel> channelType) {
+        return new SdkEventLoopGroup(eventLoopGroup, channelFactory, channelType);
+    }
+
     /**
      * Creates a new instance of SdkEventLoopGroup with {@link EventLoopGroup}.
      *
@@ -116,7 +155,8 @@ public static SdkEventLoopGroup create(EventLoopGroup eventLoopGroup, ChannelFac
      * @return a new instance of SdkEventLoopGroup
      */
     public static SdkEventLoopGroup create(EventLoopGroup eventLoopGroup) {
-        return create(eventLoopGroup, SocketChannelResolver.resolveSocketChannelFactory(eventLoopGroup));
+        return create(eventLoopGroup, ChannelResolver.resolveSocketChannelFactory(eventLoopGroup),
+                      ChannelResolver.resolveDatagramChannel(eventLoopGroup));
     }
 
     public static Builder builder() {
@@ -146,6 +186,10 @@ private ChannelFactory<? extends Channel> resolveChannelFactory() {
         return NioSocketChannel::new;
     }
 
+    private Class<? extends DatagramChannel> resolveChannelType() {
+        return NioDatagramChannel.class;
+    }
+
     /**
      * A builder for {@link SdkEventLoopGroup}.
      *

http-clients/netty-nio-client/src/main/java/software/amazon/awssdk/http/nio/netty/internal/AwaitCloseChannelPoolMap.java

@@ -83,6 +83,7 @@ public void channelCreated(Channel ch) throws Exception {
     private final ProxyConfiguration proxyConfiguration;
     private final BootstrapProvider bootstrapProvider;
     private final SslContextProvider sslContextProvider;
+    private final boolean useNonBlockingDnsResolver;
 
     private AwaitCloseChannelPoolMap(Builder builder, Function<Builder, BootstrapProvider> createBootStrapProvider) {
         this.configuration = builder.configuration;
@@ -94,6 +95,7 @@ private AwaitCloseChannelPoolMap(Builder builder, Function<Builder, BootstrapPro
         this.proxyConfiguration = builder.proxyConfiguration;
         this.bootstrapProvider = createBootStrapProvider.apply(builder);
         this.sslContextProvider = new SslContextProvider(configuration, protocol, sslProvider);
+        this.useNonBlockingDnsResolver = builder.useNonBlockingDnsResolver;
     }
 
     private AwaitCloseChannelPoolMap(Builder builder) {
@@ -179,7 +181,7 @@ public void close() {
     private Bootstrap createBootstrap(URI poolKey) {
         String host = bootstrapHost(poolKey);
         int port = bootstrapPort(poolKey);
-        return bootstrapProvider.createBootstrap(host, port);
+        return bootstrapProvider.createBootstrap(host, port, useNonBlockingDnsResolver);
     }
 
 
@@ -278,6 +280,7 @@ public static class Builder {
         private Duration healthCheckPingPeriod;
         private SslProvider sslProvider;
         private ProxyConfiguration proxyConfiguration;
+        private boolean useNonBlockingDnsResolver;
 
         private Builder() {
         }
@@ -327,6 +330,11 @@ public Builder proxyConfiguration(ProxyConfiguration proxyConfiguration) {
             return this;
         }
 
+        public Builder useNonBlockingDnsResolver(boolean useNonBlockingDnsResolver) {
+            this.useNonBlockingDnsResolver = useNonBlockingDnsResolver;
+            return this;
+        }
+
         public AwaitCloseChannelPoolMap build() {
             return new AwaitCloseChannelPoolMap(this);
         }

http-clients/netty-nio-client/src/main/java/software/amazon/awssdk/http/nio/netty/internal/BootstrapProvider.java

@@ -43,19 +43,27 @@ public class BootstrapProvider {
 
     /**
      * Creates a Bootstrap for a specific host and port with an unresolved InetSocketAddress as the remoteAddress.
-     * @param host The unresolved remote hostname
-     * @param port The remote port
-     * @return A newly created Bootstrap using the configuration this provider was initialized with, and having an
-     * unresolved remote address.
+     *
+     * @param host                      The unresolved remote hostname
+     * @param port                      The remote port
+     * @param useNonBlockingDnsResolver If true, uses the default non-blocking DNS resolver from Netty. Otherwise, the default
+     *                                  JDK blocking DNS resolver will be used.
+     * @return A newly created Bootstrap using the configuration this provider was initialized with, and having an unresolved
+     * remote address.
      */
-    public Bootstrap createBootstrap(String host, int port) {
+    public Bootstrap createBootstrap(String host, int port, boolean useNonBlockingDnsResolver) {
         Bootstrap bootstrap =
             new Bootstrap()
                 .group(sdkEventLoopGroup.eventLoopGroup())
                 .channelFactory(sdkEventLoopGroup.channelFactory())
                 .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, nettyConfiguration.connectTimeoutMillis())
                 .option(ChannelOption.SO_KEEPALIVE, nettyConfiguration.tcpKeepAlive())
                 .remoteAddress(InetSocketAddress.createUnresolved(host, port));
+
+        if (useNonBlockingDnsResolver) {
+            bootstrap.resolver(DnsResolverLoader.init(sdkEventLoopGroup.channelType()));
+        }
+
         sdkChannelOptions.channelOptions().forEach(bootstrap::option);
 
         return bootstrap;

http-clients/netty-nio-client/src/main/java/software/amazon/awssdk/http/nio/netty/internal/DnsResolverLoader.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.awssdk.http.nio.netty.internal;
+
+import io.netty.channel.socket.DatagramChannel;
+import io.netty.resolver.AddressResolverGroup;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.InetSocketAddress;
+import software.amazon.awssdk.annotations.SdkProtectedApi;
+import software.amazon.awssdk.utils.internal.ClassLoaderHelper;
+
+/**
+ * Utility class for instantiating netty dns resolvers only if they're available on the class path.
+ */
+@SdkProtectedApi
+public class DnsResolverLoader {
+
+    private DnsResolverLoader() {
+    }
+
+    public static AddressResolverGroup<InetSocketAddress> init(Class<? extends DatagramChannel> channelType) {
+        try {
+            Class<?> addressResolver = ClassLoaderHelper.loadClass(getAddressResolverGroup(), false, (Class) null);
+            Class<?> dnsNameResolverBuilder = ClassLoaderHelper.loadClass(getDnsNameResolverBuilder(), false, (Class) null);
+
+            Object dnsResolverObj = dnsNameResolverBuilder.newInstance();
+            Method method = dnsResolverObj.getClass().getMethod("channelType", Class.class);
+            method.invoke(dnsResolverObj, channelType);
+
+            Object e = addressResolver.getConstructor(dnsNameResolverBuilder).newInstance(dnsResolverObj);
+            return (AddressResolverGroup<InetSocketAddress>) e;
+        } catch (ClassNotFoundException e) {
+            throw new IllegalStateException("Cannot find module io.netty.resolver.dns "
+                                            + " To use netty non blocking dns," +
+                                            " the 'netty-resolver-dns' module from io.netty must be on the class path. ", e);
+        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException | InstantiationException e) {
+            throw new IllegalStateException("Failed to create AddressResolverGroup", e);
+        }
+    }
+
+    private static String getAddressResolverGroup() {
+        return "io.netty.resolver.dns.DnsAddressResolverGroup";
+    }
+
+    private static String getDnsNameResolverBuilder() {
+        return "io.netty.resolver.dns.DnsNameResolverBuilder";
+    }
+}

http-clients/netty-nio-client/src/main/java/software/amazon/awssdk/http/nio/netty/internal/SharedSdkEventLoopGroup.java

@@ -59,7 +59,7 @@ public static synchronized SdkEventLoopGroup get() {
 
         referenceCount++;
         return SdkEventLoopGroup.create(new ReferenceCountingEventLoopGroup(sharedSdkEventLoopGroup.eventLoopGroup()),
-                                        sharedSdkEventLoopGroup.channelFactory());
+                                        sharedSdkEventLoopGroup.channelFactory(), sharedSdkEventLoopGroup.channelType());
     }
 
     /**