Java Code Examples for software.amazon.awssdk.http.async.SdkAsyncHttpClient#Builder

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));
        }
    }
}
 

public RuntimeValue<AwsClientBuilder> createAsyncBuilder(KmsConfig config,
        RuntimeValue<SdkAsyncHttpClient.Builder> transport) {

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

public RuntimeValue<AwsClientBuilder> createAsyncBuilder(SesConfig config,
        RuntimeValue<SdkAsyncHttpClient.Builder> transport) {

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

public RuntimeValue<AwsClientBuilder> createAsyncBuilder(SqsConfig config,
        RuntimeValue<SdkAsyncHttpClient.Builder> transport) {

    SqsAsyncClientBuilder builder = SqsAsyncClient.builder();

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

public RuntimeValue<AwsClientBuilder> createAsyncBuilder(SnsConfig config,
        RuntimeValue<SdkAsyncHttpClient.Builder> transport) {

    SnsAsyncClientBuilder builder = SnsAsyncClient.builder();

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

public RuntimeValue<AwsClientBuilder> createAsyncBuilder(DynamodbConfig config,
        RuntimeValue<SdkAsyncHttpClient.Builder> transport) {

    DynamoDbAsyncClientBuilder builder = DynamoDbAsyncClient.builder();
    builder.endpointDiscoveryEnabled(config.enableEndpointDiscovery);

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

public RuntimeValue<AwsClientBuilder> createAsyncBuilder(S3Config config,
        RuntimeValue<SdkAsyncHttpClient.Builder> transport) {

    S3AsyncClientBuilder builder = S3AsyncClient.builder();
    configureS3Client(builder, config);

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

public AmazonClientTransportsBuildItem(Optional<DotName> syncClassName, Optional<DotName> asyncClassName,
        RuntimeValue<Builder> syncTransport,
        RuntimeValue<SdkAsyncHttpClient.Builder> asyncTransport,
        String awsClientName) {
    this.syncClassName = syncClassName;
    this.asyncClassName = asyncClassName;
    this.syncTransport = syncTransport;
    this.asyncTransport = asyncTransport;
    this.awsClientName = awsClientName;
}
 

@Test
public void asyncHttpClientFromBuilderShutdown() {
    SdkAsyncHttpClient httpClient = mock(SdkAsyncHttpClient.class);
    SdkAsyncHttpClient.Builder httpClientBuilder = mock(SdkAsyncHttpClient.Builder.class);

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

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

public RuntimeValue<SdkAsyncHttpClient.Builder> getAsyncTransport() {
    return asyncTransport;
}
 

public RuntimeValue<SdkAsyncHttpClient.Builder> configureAsync(String clientName,
        RuntimeValue<NettyHttpClientConfig> asyncConfigRuntime) {
    NettyNioAsyncHttpClient.Builder builder = NettyNioAsyncHttpClient.builder();
    NettyHttpClientConfig asyncConfig = asyncConfigRuntime.getValue();
    validateNettyClientConfig(clientName, asyncConfig);

    builder.connectionAcquisitionTimeout(asyncConfig.connectionAcquisitionTimeout);
    builder.connectionMaxIdleTime(asyncConfig.connectionMaxIdleTime);
    builder.connectionTimeout(asyncConfig.connectionTimeout);
    asyncConfig.connectionTimeToLive.ifPresent(builder::connectionTimeToLive);
    builder.maxConcurrency(asyncConfig.maxConcurrency);
    builder.maxPendingConnectionAcquires(asyncConfig.maxPendingConnectionAcquires);
    builder.protocol(asyncConfig.protocol);
    builder.readTimeout(asyncConfig.readTimeout);
    builder.writeTimeout(asyncConfig.writeTimeout);
    asyncConfig.sslProvider.ifPresent(builder::sslProvider);
    builder.useIdleConnectionReaper(asyncConfig.useIdleConnectionReaper);

    if (asyncConfig.http2.initialWindowSize.isPresent() || asyncConfig.http2.maxStreams.isPresent()) {
        Http2Configuration.Builder http2Builder = Http2Configuration.builder();
        asyncConfig.http2.initialWindowSize.ifPresent(http2Builder::initialWindowSize);
        asyncConfig.http2.maxStreams.ifPresent(http2Builder::maxStreams);
        asyncConfig.http2.healthCheckPingPeriod.ifPresent(http2Builder::healthCheckPingPeriod);
        builder.http2Configuration(http2Builder.build());
    }

    if (asyncConfig.proxy.enabled && asyncConfig.proxy.endpoint.isPresent()) {
        software.amazon.awssdk.http.nio.netty.ProxyConfiguration.Builder proxyBuilder = software.amazon.awssdk.http.nio.netty.ProxyConfiguration
                .builder().scheme(asyncConfig.proxy.endpoint.get().getScheme())
                .host(asyncConfig.proxy.endpoint.get().getHost())
                .nonProxyHosts(new HashSet<>(asyncConfig.proxy.nonProxyHosts.orElse(Collections.emptyList())));

        if (asyncConfig.proxy.endpoint.get().getPort() != -1) {
            proxyBuilder.port(asyncConfig.proxy.endpoint.get().getPort());
        }
        builder.proxyConfiguration(proxyBuilder.build());
    }

    getTlsKeyManagersProvider(asyncConfig.tlsManagersProvider).ifPresent(builder::tlsKeyManagersProvider);

    if (asyncConfig.eventLoop.override) {
        SdkEventLoopGroup.Builder eventLoopBuilder = SdkEventLoopGroup.builder();
        asyncConfig.eventLoop.numberOfThreads.ifPresent(eventLoopBuilder::numberOfThreads);
        if (asyncConfig.eventLoop.threadNamePrefix.isPresent()) {
            eventLoopBuilder.threadFactory(
                    new ThreadFactoryBuilder().threadNamePrefix(asyncConfig.eventLoop.threadNamePrefix.get()).build());
        }
        builder.eventLoopGroupBuilder(eventLoopBuilder);
    }

    return new RuntimeValue<>(builder);
}
 

@Override
public SdkAsyncHttpClient.Builder createAsyncHttpClientFactory() {
    return NettyNioAsyncHttpClient.builder();
}
 

@SdkTestInternalApi
protected SdkDefaultClientBuilder(SdkHttpClient.Builder defaultHttpClientBuilder,
                                  SdkAsyncHttpClient.Builder defaultAsyncHttpClientBuilder) {
    this.defaultHttpClientBuilder = defaultHttpClientBuilder;
    this.defaultAsyncHttpClientBuilder = defaultAsyncHttpClientBuilder;
}
 

@SdkTestInternalApi
AwsDefaultClientBuilder(SdkHttpClient.Builder defaultHttpClientBuilder,
                        SdkAsyncHttpClient.Builder defaultAsyncHttpClientFactory) {
    super(defaultHttpClientBuilder, defaultAsyncHttpClientFactory);
}