Adds DNS resolver configuration option for ApacheHttpClient

.changes/next-release/feature-AWSSDKforJavav2-418a15a.json

@@ -0,0 +1,6 @@
+{
+    "category": "Apache HTTP Client",
+    "contributor": "", 
+    "type": "feature", 
+    "description": "Add DNS resolver override support for Apache HTTP Client"
+}

http-clients/apache-client/src/main/java/software/amazon/awssdk/http/apache/ApacheHttpClient.java

@@ -51,6 +51,7 @@
 import org.apache.http.config.RegistryBuilder;
 import org.apache.http.config.SocketConfig;
 import org.apache.http.conn.ConnectionKeepAliveStrategy;
+import org.apache.http.conn.DnsResolver;
 import org.apache.http.conn.HttpClientConnectionManager;
 import org.apache.http.conn.routing.HttpRoutePlanner;
 import org.apache.http.conn.socket.ConnectionSocketFactory;
@@ -393,6 +394,11 @@ public interface Builder extends SdkHttpClient.Builder<ApacheHttpClient.Builder>
          */
         Builder useIdleConnectionReaper(Boolean useConnectionReaper);
 
+        /**
+         * Configuration that defines a DNS resolver. If no matches are found, the default resolver is used.
+         */
+        Builder dnsResolver(DnsResolver dnsResolver);
+
         /**
          * Configuration that defines an HTTP route planner that computes the route an HTTP request should take.
          * May not be used in conjunction with {@link #proxyConfiguration(ProxyConfiguration)}.
@@ -441,6 +447,7 @@ private static final class DefaultBuilder implements Builder {
         private Boolean expectContinueEnabled;
         private HttpRoutePlanner httpRoutePlanner;
         private CredentialsProvider credentialsProvider;
+        private DnsResolver dnsResolver;
 
         private DefaultBuilder() {
         }
@@ -551,6 +558,16 @@ public void setUseIdleConnectionReaper(Boolean useIdleConnectionReaper) {
             useIdleConnectionReaper(useIdleConnectionReaper);
         }
 
+        @Override
+        public Builder dnsResolver(DnsResolver dnsResolver) {
+            this.dnsResolver = dnsResolver;
+            return this;
+        }
+
+        public void setDnsResolver(DnsResolver dnsResolver) {
+            dnsResolver(dnsResolver);
+        }
+
         @Override
         public Builder httpRoutePlanner(HttpRoutePlanner httpRoutePlanner) {
             this.httpRoutePlanner = httpRoutePlanner;
@@ -620,7 +637,7 @@ public HttpClientConnectionManager create(ApacheHttpClient.DefaultBuilder config
                     createSocketFactoryRegistry(sslsf),
                     null,
                     DefaultSchemePortResolver.INSTANCE,
-                    null,
+                    configuration.dnsResolver,
                     standardOptions.get(SdkHttpConfigurationOption.CONNECTION_TIME_TO_LIVE).toMillis(),
                     TimeUnit.MILLISECONDS);
 

http-clients/apache-client/src/test/java/software/amazon/awssdk/http/apache/ApacheHttpClientTest.java

@@ -17,9 +17,13 @@
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import java.net.InetAddress;
 import java.net.URI;
+import java.net.UnknownHostException;
 import org.apache.http.client.CredentialsProvider;
+import org.apache.http.conn.DnsResolver;
 import org.apache.http.conn.routing.HttpRoutePlanner;
+import org.apache.http.impl.conn.SystemDefaultDnsResolver;
 import org.junit.After;
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -112,7 +116,6 @@ public void credentialProviderCantBeUsedWithProxyCredentials_SystemProperties()
         }).isInstanceOf(IllegalArgumentException.class);
     }
 
-
     @Test
     public void credentialProviderCanBeUsedWithProxy() {
         ProxyConfiguration proxyConfig = ProxyConfiguration.builder()
@@ -123,4 +126,23 @@ public void credentialProviderCanBeUsedWithProxy() {
                         .credentialsProvider(Mockito.mock(CredentialsProvider.class))
                         .build();
     }
+
+    @Test
+    public void dnsResolverCanBeUsed() {
+        DnsResolver dnsResolver = new SystemDefaultDnsResolver() {
+            @Override
+            public InetAddress[] resolve(final String host) throws UnknownHostException {
+                if (host.equalsIgnoreCase("my.host.com")) {
+                    return new InetAddress[] { InetAddress.getByName("127.0.0.1") };
+                } else {
+                    return super.resolve(host);
+                }
+            }
+        };
+
+        ApacheHttpClient.builder()
+                        .dnsResolver(dnsResolver)
+                        .build()
+                        .close();
+    }
 }

http-clients/apache-client/src/test/java/software/amazon/awssdk/http/apache/ApacheHttpClientWireMockTest.java

@@ -16,6 +16,7 @@
 package software.amazon.awssdk.http.apache;
 
 import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
+import static com.github.tomakehurst.wiremock.client.WireMock.any;
 import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
 import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;
 import static org.mockito.Mockito.verify;
@@ -25,21 +26,30 @@
 import com.github.tomakehurst.wiremock.client.WireMock;
 import com.github.tomakehurst.wiremock.junit.WireMockRule;
 import com.github.tomakehurst.wiremock.matching.RequestPatternBuilder;
+import java.io.IOException;
 import java.net.HttpURLConnection;
+import java.net.InetAddress;
+import java.net.URI;
+import java.net.UnknownHostException;
 import org.apache.http.HttpHost;
 import org.apache.http.auth.AuthScope;
 import org.apache.http.auth.Credentials;
 import org.apache.http.auth.UsernamePasswordCredentials;
 import org.apache.http.client.CredentialsProvider;
+import org.apache.http.conn.DnsResolver;
 import org.apache.http.conn.HttpClientConnectionManager;
 import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.impl.conn.SystemDefaultDnsResolver;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
+import software.amazon.awssdk.http.HttpExecuteRequest;
 import software.amazon.awssdk.http.SdkHttpClient;
 import software.amazon.awssdk.http.SdkHttpClientTestSuite;
+import software.amazon.awssdk.http.SdkHttpFullRequest;
+import software.amazon.awssdk.http.SdkHttpMethod;
 import software.amazon.awssdk.http.apache.internal.ApacheHttpRequestConfig;
 import software.amazon.awssdk.http.apache.internal.impl.ConnectionManagerAwareHttpClient;
 import software.amazon.awssdk.utils.AttributeMap;
@@ -148,4 +158,69 @@ public void clear() {
 
         mockProxyServer.verify(2, RequestPatternBuilder.allRequests());
     }
+
+    @Test
+    public void overrideDnsResolver_WithDnsMatchingResolver_successful() throws Exception {
+        overrideDnsResolver("magic.local.host");
+    }
+
+    @Test(expected = UnknownHostException.class)
+    public void overrideDnsResolver_WithUnknownHost_throwsException() throws Exception {
+        overrideDnsResolver("sad.local.host");
+    }
+
+    @Test
+    public void overrideDnsResolver_WithLocalhost_successful() throws Exception {
+        overrideDnsResolver("localhost");
+    }
+
+    @Test
+    public void explicitNullDnsResolver_WithLocalhost_successful() throws Exception {
+        overrideDnsResolver("localhost", true);
+    }
+
+    private void overrideDnsResolver(String hostName) throws IOException {
+        overrideDnsResolver(hostName, false);
+    }
+
+    private void overrideDnsResolver(String hostName, boolean nullifyResolver) throws IOException {
+
+        DnsResolver dnsResolver = new SystemDefaultDnsResolver() {
+            @Override
+            public InetAddress[] resolve(final String host) throws UnknownHostException {
+                if (host.equalsIgnoreCase("magic.local.host")) {
+                    return new InetAddress[] { InetAddress.getByName("127.0.0.1") };
+                } else {
+                    return super.resolve(host);
+                }
+            }
+        };
+        if (nullifyResolver) {
+            dnsResolver = null;
+        }
+
+        SdkHttpClient client = ApacheHttpClient.builder()
+                                               .dnsResolver(dnsResolver)
+                                               .buildWithDefaults(AttributeMap.builder()
+                                                                              .put(TRUST_ALL_CERTIFICATES, Boolean.TRUE)
+                                                                              .build());
+
+        mockProxyServer.resetToDefaultMappings();
+        mockProxyServer.stubFor(any(urlPathEqualTo("/")).willReturn(aResponse().withStatus(HttpURLConnection.HTTP_OK)));
+
+        URI uri = URI.create("https://" + hostName + ":" + mockProxyServer.httpsPort());
+        SdkHttpFullRequest req = SdkHttpFullRequest.builder()
+                                                   .uri(uri)
+                                                   .method(SdkHttpMethod.POST)
+                                                   .putHeader("Host", uri.getHost())
+                                                   .build();
+
+        client.prepareRequest(HttpExecuteRequest.builder()
+                                                .request(req)
+                                                .contentStreamProvider(req.contentStreamProvider().orElse(null))
+                                                .build())
+              .call();
+
+        mockProxyServer.verify(1, RequestPatternBuilder.allRequests());
+    }
 }