Add ProxyConfiguration support for UrlConnectionHttpClient

[joviegas]

Motivation and Context

Raised a new request for #2986

Resolves #2458. The goal of this change is to add full proxy support to the UrlConnectionHttpClient so that our project can remove the Apache HTTP Client and instead rely on Java builtins. This change must support HTTP and HTTPS proxies with username/password authorization.

Modifications

Adds HTTP proxy support to the UrlConnectionHttpClient by using largely the same ProxyConfiguration class as is in the Apache HTTP Client. If the user configures a proxy using the builder, and the request isn't going to a non-proxy host, then the request will go through the application proxy using Java's builtin Proxy class.

Testing

Manually tested using a local squid proxy via HTTP without authentication.

Screenshots (if appropriate)

Types of changes

• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)

Checklist

• I have read the CONTRIBUTING document
• Local run of mvn install succeeds
• My code follows the code style of this project
• My change requires a change to the Javadoc documentation
• I have updated the Javadoc documentation accordingly
• I have added tests to cover my changes
• All new and existing tests passed
• I have added a changelog entry. Adding a new entry must be accomplished by running the scripts/new-change script and following the instructions. Commit the new file created by the script in .changes/next-release with your changes.
• My change is to implement 1.11 parity feature and I have updated LaunchChangelog

License

• I confirm that this pull request can be released under the Apache 2 license

Misc

• tested in EC2 with below code
• launched squid server in ec2
• Not https testing for squid with Auth is bit complicated, I haved tested auth with http. and rest of cases as in test cases

package software.amazon.awssdk.http.urlconnection;

import static org.assertj.core.api.Assertions.assertThat;
import static software.amazon.awssdk.http.SdkHttpConfigurationOption.TRUST_ALL_CERTIFICATES;

import java.io.IOException;
import java.net.URI;
import java.util.List;
import java.util.Map;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import software.amazon.awssdk.http.HttpExecuteRequest;
import software.amazon.awssdk.http.HttpExecuteResponse;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpMethod;
import software.amazon.awssdk.http.SdkHttpRequest;
import software.amazon.awssdk.utils.AttributeMap;
import software.amazon.awssdk.utils.IoUtils;

/**
 * Tests to ensure that {@link UrlConnectionHttpClient} can properly support TLS client authentication.
 */
public class ProxyConfigurationMockTest {
    public static final String HOST_IP_ADDRESS = "xx.xxx.xxx.xxx";
    public static final String HOST_IP_ADDRESS_WITH_AUTH = "yy.yyy.yyy.yyy";
    @Rule
    public ExpectedException thrown = ExpectedException.none();
    private SdkHttpClient client;

    @BeforeClass
    public static void setUp() throws IOException {
        System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "");
        System.setProperty("jdk.http.auth.proxying.disabledSchemes", "");

    }

    @AfterClass
    public static void teardown()  {
        System.clearProperty("javax.net.ssl.trustStore");
        System.clearProperty("javax.net.ssl.trustStorePassword");
        System.clearProperty("javax.net.ssl.trustStoreType");
    }

    @After
    public void methodTeardown() {
        if (client != null) {
            client.close();
        }
        client = null;
    }


    private SdkHttpClient createSdkHttpsClient(ProxyConfiguration proxyConfiguration) {
        UrlConnectionHttpClient.Builder builder =
            UrlConnectionHttpClient.builder().proxyConfiguration(proxyConfiguration
            );
        AttributeMap.Builder attributeMap = AttributeMap.builder();
        attributeMap.put(TRUST_ALL_CERTIFICATES, true);
        return builder.buildWithDefaults(attributeMap.build());
    }


    private SdkHttpClient createHttpClientForHttpServer(ProxyConfiguration proxyConfiguration) {
        UrlConnectionHttpClient.Builder builder =
            UrlConnectionHttpClient.builder().proxyConfiguration(proxyConfiguration);
        AttributeMap.Builder attributeMap = AttributeMap.builder();

        return builder.buildWithDefaults(attributeMap.build());
    }


    @Test
    public void clientWithHttpsAndNoAuth() throws IOException {
        SdkHttpClient sdkHttpClient = createSdkHttpsClient(ProxyConfiguration.builder()
                                                                             .endpoint(URI.create("https://" + HOST_IP_ADDRESS + ":3128"))
                                                                             .build());
        HttpExecuteResponse httpExecuteResponse = makeRequestWithHttpsClient(sdkHttpClient);
        Map<String, List<String>> headers = httpExecuteResponse.httpResponse().headers();
        System.out.println(httpExecuteResponse.httpResponse().statusCode());
        String actualResult = IoUtils.toUtf8String(httpExecuteResponse.responseBody().get());

        System.out.println("actualResult" +actualResult);
        assertThat(httpExecuteResponse.httpResponse().statusCode()).isEqualTo(200);
    }

    @Test
    public void clientWithHttpsAndWrongPassword() throws IOException {
        SdkHttpClient sdkHttpClient = createSdkHttpsClient(ProxyConfiguration.builder()
                                                                             .endpoint(URI.create("https://" + HOST_IP_ADDRESS + ":3128"))
                                                                             .password("1232222456")
                                                                             .username("joviegas")
                                                                             .build());
        HttpExecuteResponse httpExecuteResponse = makeRequestWithHttpsClient(sdkHttpClient);
        Map<String, List<String>> headers = httpExecuteResponse.httpResponse().headers();
        System.out.println(headers);
        System.out.println(httpExecuteResponse.httpResponse().statusCode());
        assertThat(httpExecuteResponse.httpResponse().statusCode()).isEqualTo(200);
    }


    @Test
    public void clientWithHttpsAndPassword() throws IOException {
        SdkHttpClient sdkHttpClient = createSdkHttpsClient(ProxyConfiguration.builder()
                                                                             .endpoint(URI.create("https://" + HOST_IP_ADDRESS_WITH_AUTH + ":3128"))
                                                                             .password("123456")
                                                                             .username("user1")
                                                                             .build());
        HttpExecuteResponse httpExecuteResponse = makeRequestWithHttpsClient(sdkHttpClient);
        assertThat(httpExecuteResponse.httpResponse().statusCode()).isEqualTo(200);
    }

    @Test
    public void httpClientWithWrongPassword() throws IOException {
        SdkHttpClient sdkHttpClient = createHttpClientForHttpServer(ProxyConfiguration.builder()
                                                                                      .endpoint(URI.create("http://" + HOST_IP_ADDRESS_WITH_AUTH + ":3128"))
                                                                                      .password("123433356")
                                                                                      .username("joviegas")
                                                                                      .build());
        HttpExecuteResponse httpExecuteResponse = makeHttpRequest(sdkHttpClient);
        Map<String, List<String>> headers = httpExecuteResponse.httpResponse().headers();
        System.out.println(headers);
        System.out.println(httpExecuteResponse.httpResponse().statusCode());
        String actualResult = IoUtils.toUtf8String(httpExecuteResponse.responseBody().get());
        System.out.println("actualResult " + actualResult);
        assertThat(httpExecuteResponse.httpResponse().statusCode()).isEqualTo(407);
    }

    @Test
    public void httpClientWithCorrectPassword() throws IOException {
        SdkHttpClient sdkHttpClient = createHttpClientForHttpServer(
            ProxyConfiguration.builder()
                              .endpoint(URI.create("http://" + HOST_IP_ADDRESS_WITH_AUTH + ":3128"))
                              .password("123456")
                              .username("user1")
                              .build());
        HttpExecuteResponse httpExecuteResponse = makeHttpRequest(sdkHttpClient);
        assertThat(httpExecuteResponse.httpResponse().statusCode()).isEqualTo(200);
    }

    @Test
    public void httpClientWithNoAuth() throws IOException {
        SdkHttpClient sdkHttpClient = createHttpClientForHttpServer(
            ProxyConfiguration.builder()
                      //        .endpoint(URI.create("http://" + HOST_IP_ADDRESS + ":3128"))
                              .build());
        HttpExecuteResponse httpExecuteResponse = makeHttpRequest(sdkHttpClient);
        String actualResult = IoUtils.toUtf8String(httpExecuteResponse.responseBody().get());
        assertThat(httpExecuteResponse.httpResponse().statusCode()).isEqualTo(200);
    }


    private HttpExecuteResponse makeRequestWithHttpsClient(SdkHttpClient httpClient) throws IOException {
        SdkHttpRequest httpRequest = SdkHttpFullRequest.builder()
                                                       .method(SdkHttpMethod.GET)
                                                       .protocol("https")
                                                       .host("www.google.com")
                                                       .build();

        HttpExecuteRequest request = HttpExecuteRequest.builder()
                                                       .request(httpRequest)
                                                       .build();

        return httpClient.prepareRequest(request).call();
    }


    private HttpExecuteResponse makeHttpRequest(SdkHttpClient httpClient) throws IOException {
        SdkHttpRequest httpRequest = SdkHttpFullRequest.builder()
                                                       .method(SdkHttpMethod.GET)
                                                       .protocol("http")
                                                       .host("httpforever.com")
                                                       .build();

        HttpExecuteRequest request = HttpExecuteRequest.builder()
                                                       .request(httpRequest)
                                                       .build();

        return httpClient.prepareRequest(request).call();
    }
}

[dagnir]

nit: "URLConnection HTTP Client"

[joviegas]

Done

[dagnir]

this resolves the address at construction time, which is not what we want. We should use InetSocketAddress.createUnresolved()

[joviegas]

Done

[dagnir]

nit: for the test method name, can you include the expected outcome? It makes tests easier to read and reason about

[joviegas]

Done

[sonarqubecloud]

SonarCloud Quality Gate failed.   

0 Bugs
0 Vulnerabilities
0 Security Hotspots
2 Code Smells

72.8% Coverage
15.0% Duplication