org.apache.hadoop.fs.s3a.Constants#software.amazon.awssdk.http.SdkHttpClient源码实例Demo

public LambdaWrapper(final CredentialsProvider providerCredentialsProvider,
                     final LogPublisher platformEventsLogger,
                     final CloudWatchLogPublisher providerEventsLogger,
                     final MetricsPublisher providerMetricsPublisher,
                     final SchemaValidator validator,
                     final Serializer serializer,
                     final SdkHttpClient httpClient) {

    this.providerCredentialsProvider = providerCredentialsProvider;
    this.providerCloudWatchProvider = new CloudWatchProvider(this.providerCredentialsProvider, httpClient);
    this.cloudWatchLogsProvider = new CloudWatchLogsProvider(this.providerCredentialsProvider, httpClient);
    this.providerEventsLogger = providerEventsLogger;
    this.platformLambdaLogger = platformEventsLogger;
    this.providerMetricsPublisher = providerMetricsPublisher;
    this.serializer = serializer;
    this.validator = validator;
    this.typeReference = getTypeReference();
}
 

protected void createClientBuilders(List<AmazonClientTransportsBuildItem> clients,
        BuildProducer<AmazonClientBuilderBuildItem> builderProducer,
        Function<RuntimeValue<SdkHttpClient.Builder>, RuntimeValue<AwsClientBuilder>> syncFunc,
        Function<RuntimeValue<SdkAsyncHttpClient.Builder>, RuntimeValue<AwsClientBuilder>> asyncFunc) {

    for (AmazonClientTransportsBuildItem client : clients) {
        if (configName().equals(client.getAwsClientName())) {
            RuntimeValue<AwsClientBuilder> syncBuilder = null;
            RuntimeValue<AwsClientBuilder> asyncBuilder = null;
            if (client.getSyncClassName().isPresent()) {
                syncBuilder = syncFunc.apply(client.getSyncTransport());
            }
            if (client.getAsyncClassName().isPresent()) {
                asyncBuilder = asyncFunc.apply(client.getAsyncTransport());
            }
            builderProducer.produce(new AmazonClientBuilderBuildItem(client.getAwsClientName(), syncBuilder, asyncBuilder));
        }
    }
}
 

@Test
public void sign_WithoutUsingSdkClient_ThroughExecutionAttributes() throws Exception {
    Aws4Signer signer = Aws4Signer.create();
    SdkHttpFullRequest httpFullRequest = generateBasicRequest();

    // sign the request
    SdkHttpFullRequest signedRequest = signer.sign(httpFullRequest, constructExecutionAttributes());

    SdkHttpClient httpClient = ApacheHttpClient.builder().build();

    HttpExecuteRequest request = HttpExecuteRequest.builder()
                                                   .request(signedRequest)
                                                   .contentStreamProvider(signedRequest.contentStreamProvider().orElse(null))
                                                   .build();

    HttpExecuteResponse response = httpClient.prepareRequest(request)
                                             .call();

    assertEquals("Non success http status code", 200, response.httpResponse().statusCode());

    String actualResult = IoUtils.toUtf8String(response.responseBody().get());
    assertEquals(getExpectedResult(), actualResult);
}
 

@Test
public void test_SignMethod_WithModeledParam_And_WithoutUsingSdkClient() throws Exception {
    Aws4Signer signer = Aws4Signer.create();
    SdkHttpFullRequest httpFullRequest = generateBasicRequest();

    // sign the request
    SdkHttpFullRequest signedRequest = signer.sign(httpFullRequest, constructSignerParams());

    SdkHttpClient httpClient = ApacheHttpClient.builder().build();

    HttpExecuteRequest request = HttpExecuteRequest.builder()
                                                   .request(signedRequest)
                                                   .contentStreamProvider(signedRequest.contentStreamProvider().orElse(null))
                                                   .build();
    HttpExecuteResponse response = httpClient.prepareRequest(request)
                                             .call();

    assertEquals("Non success http status code", 200, response.httpResponse().statusCode());

    String actualResult = IoUtils.toUtf8String(response.responseBody().get());
    assertEquals(getExpectedResult(), actualResult);
}
 

@Test
public void test_SignMethod_WithModeledParam_And_WithoutUsingSdkClient() throws Exception {
    AwsS3V4Signer signer = AwsS3V4Signer.create();
    SdkHttpFullRequest httpFullRequest = generateBasicGetRequest();

    // sign the request
    SdkHttpFullRequest signedRequest = signer.sign(httpFullRequest, constructSignerParams());

    SdkHttpClient httpClient = ApacheHttpClient.builder().build();

    HttpExecuteResponse response = httpClient.prepareRequest(HttpExecuteRequest.builder().request(signedRequest).build())
                                             .call();

    assertEquals("Non success http status code", 200, response.httpResponse().statusCode());

    String actualResult = IoUtils.toUtf8String(response.responseBody().get());
    assertEquals(CONTENT, actualResult);
}
 

@Test
public void test_SignMethod_WithExecutionAttributes_And_WithoutUsingSdkClient() throws Exception {
    AwsS3V4Signer signer = AwsS3V4Signer.create();
    SdkHttpFullRequest httpFullRequest = generateBasicGetRequest();

    // sign the request
    SdkHttpFullRequest signedRequest = signer.sign(httpFullRequest, constructExecutionAttributes());

    SdkHttpClient httpClient = ApacheHttpClient.builder().build();

    HttpExecuteResponse response = httpClient.prepareRequest(HttpExecuteRequest.builder().request(signedRequest).build())
                                             .call();

    assertEquals("Non success http status code", 200, response.httpResponse().statusCode());

    String actualResult = IoUtils.toUtf8String(response.responseBody().get());
    assertEquals(CONTENT, actualResult);
}
 

@Override
protected SdkHttpClient createSdkHttpClient(SdkHttpClientOptions options) {
    ApacheHttpClient.Builder builder = ApacheHttpClient.builder();

    AttributeMap.Builder attributeMap = AttributeMap.builder();

    if (options.tlsTrustManagersProvider() != null) {
        builder.tlsTrustManagersProvider(options.tlsTrustManagersProvider());
    }

    if (options.trustAll()) {
        attributeMap.put(TRUST_ALL_CERTIFICATES, options.trustAll());
    }

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

@Test
public void routePlannerIsInvoked() throws Exception {
    mockProxyServer.resetToDefaultMappings();
    mockProxyServer.addStubMapping(WireMock.any(urlPathEqualTo("/"))
                                           .willReturn(aResponse().proxiedFrom("http://localhost:" + mockServer.port()))
                                           .build());

    SdkHttpClient client = ApacheHttpClient.builder()
                                           .httpRoutePlanner(
                                               (host, request, context) ->
                                                   new HttpRoute(
                                                       new HttpHost("localhost", mockProxyServer.httpsPort(), "https")
                                                   )
                                           )
                                           .buildWithDefaults(AttributeMap.builder()
                                                                          .put(TRUST_ALL_CERTIFICATES, Boolean.TRUE)
                                                                          .build());

    testForResponseCodeUsingHttps(client, HttpURLConnection.HTTP_OK);

    mockProxyServer.verify(1, RequestPatternBuilder.allRequests());
}
 

/**
 * @param configuration The Apache client configuration
 * @return An instance of {@link SdkHttpClient}
 */
@Bean(preDestroy = "close")
@Singleton
@Requires(property = UrlConnectionClientFactory.HTTP_SERVICE_IMPL, notEquals = UrlConnectionClientFactory.URL_CONNECTION_SDK_HTTP_SERVICE)
public SdkHttpClient apacheClient(ApacheClientConfiguration configuration) {
    return doCreateClient(configuration);
}
 

/**
 * @param configuration The Apache client configuration
 * @return An instance of {@link SdkHttpClient}
 */
@Bean(preDestroy = "close")
@Singleton
@Requires(property = UrlConnectionClientFactory.HTTP_SERVICE_IMPL, value = APACHE_SDK_HTTP_SERVICE)
public SdkHttpClient systemPropertyClient(ApacheClientConfiguration configuration) {
    return doCreateClient(configuration);
}
 

/**
 * Creates an {@link software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient} client if there are no other clients configured.
 *
 * @param configuration The URLConnection client configuration
 * @return An instance of {@link SdkHttpClient}
 */
@Bean(preDestroy = "close")
@Singleton
@Requires(missingBeans = SdkHttpClient.class)
public SdkHttpClient urlConnectionClient(UrlConnectionClientConfiguration configuration) {
    return doCreateClient(configuration);
}
 

public ServiceHandlerWrapper(final CredentialsProvider providerLoggingCredentialsProvider,
                             final CloudWatchLogPublisher providerEventsLogger,
                             final LogPublisher platformEventsLogger,
                             final MetricsPublisher providerMetricsPublisher,
                             final SchemaValidator validator,
                             final Serializer serializer,
                             final ServiceClient client,
                             final SdkHttpClient httpClient) {
    super(providerLoggingCredentialsProvider, platformEventsLogger, providerEventsLogger, providerMetricsPublisher, validator,
          serializer, httpClient);
    this.serviceClient = client;
}
 

/**
 * This .ctor provided for testing
 */
public WrapperOverride(final CredentialsProvider providerLoggingCredentialsProvider,
                       final LogPublisher platformEventsLogger,
                       final CloudWatchLogPublisher providerEventsLogger,
                       final MetricsPublisher providerMetricsPublisher,
                       final SchemaValidator validator,
                       final SdkHttpClient httpClient) {
    super(providerLoggingCredentialsProvider, platformEventsLogger, providerEventsLogger, providerMetricsPublisher, validator,
          new Serializer(), httpClient);
}
 

public RuntimeValue<AwsClientBuilder> createSyncBuilder(KmsConfig config, RuntimeValue<SdkHttpClient.Builder> transport) {
    KmsClientBuilder builder = KmsClient.builder();
    if (transport != null) {
        builder.httpClientBuilder(transport.getValue());
    }
    return new RuntimeValue<>(builder);
}
 

public RuntimeValue<AwsClientBuilder> createSyncBuilder(SesConfig config, RuntimeValue<SdkHttpClient.Builder> transport) {
    SesClientBuilder builder = SesClient.builder();
    if (transport != null) {
        builder.httpClientBuilder(transport.getValue());
    }
    return new RuntimeValue<>(builder);
}
 

public RuntimeValue<AwsClientBuilder> createSyncBuilder(DynamodbConfig config,
        RuntimeValue<SdkHttpClient.Builder> transport) {
    DynamoDbClientBuilder builder = DynamoDbClient.builder();
    builder.endpointDiscoveryEnabled(config.enableEndpointDiscovery);

    if (transport != null) {
        builder.httpClientBuilder(transport.getValue());
    }
    return new RuntimeValue<>(builder);
}
 

public void createTransportBuilders(List<AmazonClientBuildItem> amazonClients,
        AmazonClientTransportRecorder recorder,
        SyncHttpClientBuildTimeConfig buildSyncConfig,
        RuntimeValue<SyncHttpClientConfig> syncConfig,
        RuntimeValue<NettyHttpClientConfig> asyncConfig,
        BuildProducer<AmazonClientTransportsBuildItem> clientTransports) {

    Optional<AmazonClientBuildItem> matchingClientBuildItem = amazonClients.stream()
            .filter(c -> c.getAwsClientName().equals(configName()))
            .findAny();

    matchingClientBuildItem.ifPresent(client -> {
        RuntimeValue<SdkHttpClient.Builder> syncTransport = null;
        RuntimeValue<SdkAsyncHttpClient.Builder> asyncTransport = null;

        if (client.getSyncClassName().isPresent()) {
            syncTransport = recorder.configureSync(configName(), buildSyncConfig,
                    syncConfig);
        }

        if (client.getAsyncClassName().isPresent()) {
            asyncTransport = recorder.configureAsync(configName(), asyncConfig);
        }

        clientTransports.produce(
                new AmazonClientTransportsBuildItem(
                        client.getSyncClassName(), client.getAsyncClassName(),
                        syncTransport,
                        asyncTransport,
                        client.getAwsClientName()));
    });

}
 

private SdkHttpClient mockSdkHttpClient(SdkHttpResponse response, String body) throws Exception {
    ExecutableHttpRequest abortableCallable = Mockito.mock(ExecutableHttpRequest.class);
    SdkHttpClient mockClient = Mockito.mock(SdkHttpClient.class);

    Mockito.when(mockClient.prepareRequest(Mockito.any())).thenReturn(abortableCallable);
    Mockito.when(abortableCallable.call()).thenReturn(HttpExecuteResponse.builder()
            .response(response)
            .responseBody(AbortableInputStream.create(
                    new ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8))
            ))
            .build()
    );
    return mockClient;
}
 

@Test
public void getObject_PresignedHttpRequestCanBeInvokedDirectlyBySdk() throws IOException {
    PresignedGetObjectRequest presigned =
        presigner.presignGetObject(r -> r.signatureDuration(Duration.ofMinutes(5))
                                         .getObjectRequest(gor -> gor.bucket(testBucket)
                                                                     .key(testGetObjectKey)
                                                                     .requestPayer(RequestPayer.REQUESTER)));

    assertThat(presigned.isBrowserExecutable()).isFalse();

    SdkHttpClient httpClient = ApacheHttpClient.builder().build(); // or UrlConnectionHttpClient.builder().build()

    ContentStreamProvider requestPayload = presigned.signedPayload()
                                                    .map(SdkBytes::asContentStreamProvider)
                                                    .orElse(null);

    HttpExecuteRequest request = HttpExecuteRequest.builder()
                                                   .request(presigned.httpRequest())
                                                   .contentStreamProvider(requestPayload)
                                                   .build();

    HttpExecuteResponse response = httpClient.prepareRequest(request).call();

    assertThat(response.responseBody()).isPresent();
    try (InputStream responseStream = response.responseBody().get()) {
        assertThat(IoUtils.toUtf8String(responseStream)).isEqualTo(testObjectContent);
    }
}
 

@Test
public void putObject_PresignedHttpRequestCanBeInvokedDirectlyBySdk() throws IOException {
    String objectKey = generateRandomObjectKey();
    S3TestUtils.addCleanupTask(S3PresignerIntegrationTest.class,
                               () -> client.deleteObject(r -> r.bucket(testBucket).key(objectKey)));

    PresignedPutObjectRequest presigned =
        presigner.presignPutObject(r -> r.signatureDuration(Duration.ofMinutes(5))
                                         .putObjectRequest(por -> por.bucket(testBucket).key(objectKey)));

    assertThat(presigned.isBrowserExecutable()).isFalse();

    SdkHttpClient httpClient = ApacheHttpClient.builder().build(); // or UrlConnectionHttpClient.builder().build()

    ContentStreamProvider requestPayload = () -> new StringInputStream(testObjectContent);

    HttpExecuteRequest request = HttpExecuteRequest.builder()
                                                   .request(presigned.httpRequest())
                                                   .contentStreamProvider(requestPayload)
                                                   .build();

    HttpExecuteResponse response = httpClient.prepareRequest(request).call();

    assertThat(response.responseBody()).isPresent();
    assertThat(response.httpResponse().isSuccessful()).isTrue();
    response.responseBody().ifPresent(AbortableInputStream::abort);
    String content = client.getObjectAsBytes(r -> r.bucket(testBucket).key(objectKey)).asUtf8String();
    assertThat(content).isEqualTo(testObjectContent);
}
 

private HttpExecuteResponse execute(PresignedRequest presigned, String payload) throws IOException {
    SdkHttpClient httpClient = ApacheHttpClient.builder().build();

    ContentStreamProvider requestPayload = payload == null ? null : () -> new StringInputStream(payload);

    HttpExecuteRequest request = HttpExecuteRequest.builder()
                                                   .request(presigned.httpRequest())
                                                   .contentStreamProvider(requestPayload)
                                                   .build();

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

private HttpExecuteResponse makeRequestWithHttpClient(SdkHttpClient httpClient) throws IOException {
    SdkHttpRequest httpRequest = SdkHttpFullRequest.builder()
            .method(SdkHttpMethod.GET)
            .protocol("https")
            .host("localhost:" + wireMockServer.httpsPort())
            .build();

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

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

/**
 * Used by the SDK to create a {@link SdkHttpClient} with service-default values if no other values have been configured
 *
 * @param serviceDefaults Service specific defaults. Keys will be one of the constants defined in
 * {@link SdkHttpConfigurationOption}.
 * @return an instance of {@link SdkHttpClient}
 */
@Override
public SdkHttpClient buildWithDefaults(AttributeMap serviceDefaults) {
    return new UrlConnectionHttpClient(standardOptions.build()
                                                      .merge(serviceDefaults)
                                                      .merge(SdkHttpConfigurationOption.GLOBAL_HTTP_DEFAULTS),
                                       null);
}
 

@Override
protected SdkHttpClient createSdkHttpClient(SdkHttpClientOptions options) {
    UrlConnectionHttpClient.Builder builder = UrlConnectionHttpClient.builder();
    AttributeMap.Builder attributeMap = AttributeMap.builder();

    if (options.tlsTrustManagersProvider() != null) {
        builder.tlsTrustManagersProvider(options.tlsTrustManagersProvider());
    }

    if (options.trustAll()) {
        attributeMap.put(TRUST_ALL_CERTIFICATES, options.trustAll());
    }

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

@Test
public void httpClientFromBuilderShutdown() {
    SdkHttpClient httpClient = mock(SdkHttpClient.class);
    SdkHttpClient.Builder httpClientBuilder = mock(SdkHttpClient.Builder.class);

    when(httpClientBuilder.buildWithDefaults(any())).thenReturn(httpClient);

    syncClientBuilder().httpClientBuilder(httpClientBuilder).build().close();
    verify(httpClient).close();
}
 

/**
 * Finalize which sync HTTP client will be used for the created client.
 */
private SdkHttpClient resolveSyncHttpClient(SdkClientConfiguration config) {
    Validate.isTrue(config.option(SdkClientOption.SYNC_HTTP_CLIENT) == null || httpClientBuilder == null,
                    "The httpClient and the httpClientBuilder can't both be configured.");

    return Either.fromNullable(config.option(SdkClientOption.SYNC_HTTP_CLIENT), httpClientBuilder)
                 .map(e -> e.map(NonManagedSdkHttpClient::new, b -> b.buildWithDefaults(childHttpConfig())))
                 .orElseGet(() -> defaultHttpClientBuilder.buildWithDefaults(childHttpConfig()));
}
 

@Override
public SdkHttpClient buildWithDefaults(AttributeMap serviceDefaults) {
    // TODO We create and build every time. Do we want to cache it instead of the service binding?
    return DEFAULT_CHAIN
            .loadService()
            .map(SdkHttpService::createHttpClientBuilder)
            .map(f -> f.buildWithDefaults(serviceDefaults))
            .orElseThrow(
                () -> SdkClientException.builder()
                                        .message("Unable to load an HTTP implementation from any provider in the " +
                                                 "chain. You must declare a dependency on an appropriate HTTP " +
                                                 "implementation or pass in an SdkHttpClient explicitly to the " +
                                                 "client builder.")
                                        .build());
}
 

public AmazonSyncHttpClient build() {
    SdkHttpClient sdkHttpClient = this.httpClient != null ? this.httpClient : testSdkHttpClient();
    return new AmazonSyncHttpClient(testClientConfiguration().toBuilder()
                                                             .option(SdkClientOption.SYNC_HTTP_CLIENT, sdkHttpClient)
                                                             .applyMutation(this::configureRetryPolicy)
                                                             .applyMutation(this::configureAdditionalHeaders)
                                                             .option(SdkClientOption.API_CALL_TIMEOUT, apiCallTimeout)
                                                             .option(SdkClientOption.API_CALL_ATTEMPT_TIMEOUT, apiCallAttemptTimeout)
                                                             .build());
}
 

@Test
public void clientFactoryProvided_ClientIsManagedBySdk() {
    TestClient client = testClientBuilder().httpClientBuilder((SdkHttpClient.Builder) serviceDefaults -> {
        Assertions.assertThat(serviceDefaults).isEqualTo(MOCK_DEFAULTS);
        return mock(SdkHttpClient.class);
    })
            .build();
    assertThat(client.clientConfiguration.option(SdkClientOption.SYNC_HTTP_CLIENT))
            .isNotInstanceOf(SdkDefaultClientBuilder.NonManagedSdkHttpClient.class);
    verify(defaultHttpClientFactory, never()).buildWithDefaults(any());
}
 

@Test
public void explicitClientProvided_ClientIsNotManagedBySdk() {
    TestClient client = testClientBuilder()

            .httpClient(mock(SdkHttpClient.class))
            .build();
    assertThat(client.clientConfiguration.option(SdkClientOption.SYNC_HTTP_CLIENT))
            .isInstanceOf(SdkDefaultClientBuilder.NonManagedSdkHttpClient.class);
    verify(defaultHttpClientFactory, never()).buildWithDefaults(any());
}