Make the initial window size for H2 configurable

.changes/next-release/feature-NettyNIOHTTPClient-8901f81.json

@@ -0,0 +1,5 @@
+{
+    "type": "feature",
+    "category": "Netty NIO HTTP Client",
+    "description": "`SETTINGS_INITIAL_WINDOW_SIZE` is now configurable on HTTP/2 connections opened by the Netty client using `Http2Configuration#initialWindowSize(Integer)` along with `NettyNioAsyncHttpClient.Builder#http2Configuration(Http2Configuration)`. See https://tools.ietf.org/html/rfc7540#section-6.5.2 for more information."
+}

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

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2010-2019 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;
+
+import software.amazon.awssdk.annotations.SdkPublicApi;
+import software.amazon.awssdk.utils.Validate;
+import software.amazon.awssdk.utils.builder.CopyableBuilder;
+import software.amazon.awssdk.utils.builder.ToCopyableBuilder;
+
+/**
+ * Configuration specific to HTTP/2 connections.
+ */
+@SdkPublicApi
+public final class Http2Configuration implements ToCopyableBuilder<Http2Configuration.Builder, Http2Configuration> {
+    private final Long maxStreams;
+    private final Integer initialWindowSize;
+
+    private Http2Configuration(DefaultBuilder builder) {
+        this.maxStreams = builder.maxStreams;
+        this.initialWindowSize = builder.initialWindowSize;
+    }
+
+    /**
+     * @return The maximum number of streams to be created per HTTP/2 connection.
+     */
+    public Long maxStreams() {
+        return maxStreams;
+    }
+
+    /**
+     * @return The initial window size for an HTTP/2 stream.
+     */
+    public Integer initialWindowSize() {
+        return initialWindowSize;
+    }
+
+    @Override
+    public Builder toBuilder() {
+        return new DefaultBuilder(this);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        Http2Configuration that = (Http2Configuration) o;
+
+        if (maxStreams != null ? !maxStreams.equals(that.maxStreams) : that.maxStreams != null) {
+            return false;
+        }
+
+        return initialWindowSize != null ? initialWindowSize.equals(that.initialWindowSize) : that.initialWindowSize == null;
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = maxStreams != null ? maxStreams.hashCode() : 0;
+        result = 31 * result + (initialWindowSize != null ? initialWindowSize.hashCode() : 0);
+        return result;
+    }
+
+    public static Builder builder() {
+        return new DefaultBuilder();
+    }
+
+    public interface Builder extends CopyableBuilder<Builder, Http2Configuration> {
+
+        /**
+         * Sets the max number of concurrent streams per connection.
+         *
+         * <p>Note that this cannot exceed the value of the MAX_CONCURRENT_STREAMS setting returned by the service. If it
+         * does the service setting is used instead.</p>
+         *
+         * @param maxStreams Max concurrent HTTP/2 streams per connection.
+         * @return This builder for method chaining.
+         */
+        Builder maxStreams(Long maxStreams);
+
+        /**
+         * Sets initial window size of a stream. This setting is only respected when the HTTP/2 protocol is used.
+         *
+         * See <a href="https://tools.ietf.org/html/rfc7540#section-6.5.2">https://tools.ietf.org/html/rfc7540#section-6.5.2</a>
+         * for more information about this parameter.
+         *
+         * @param initialWindowSize The initial window size of a stream.
+         * @return This builder for method chaining.
+         */
+        Builder initialWindowSize(Integer initialWindowSize);
+    }
+
+    private static final class DefaultBuilder implements Builder {
+        private Long maxStreams;
+        private Integer initialWindowSize;
+
+        private DefaultBuilder() {
+        }
+
+        private DefaultBuilder(Http2Configuration http2Configuration) {
+            this.maxStreams = http2Configuration.maxStreams;
+            this.initialWindowSize = http2Configuration.initialWindowSize;
+        }
+
+        @Override
+        public Builder maxStreams(Long maxStreams) {
+            this.maxStreams = Validate.isPositiveOrNull(maxStreams, "maxStreams");
+            return this;
+        }
+
+        public void setMaxStreams(Long maxStreams) {
+            maxStreams(maxStreams);
+        }
+
+        @Override
+        public Builder initialWindowSize(Integer initialWindowSize) {
+            this.initialWindowSize = Validate.isPositiveOrNull(initialWindowSize, "initialWindowSize");
+            return this;
+        }
+
+        public void setInitialWindowSize(Integer initialWindowSize) {
+            initialWindowSize(initialWindowSize);
+        }
+
+        @Override
+        public Http2Configuration build() {
+            return new Http2Configuration(this);
+        }
+    }
+}

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

@@ -42,6 +42,7 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.function.Consumer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import software.amazon.awssdk.annotations.SdkPublicApi;
@@ -77,6 +78,7 @@ public final class NettyNioAsyncHttpClient implements SdkAsyncHttpClient {
 
     private static final Logger log = LoggerFactory.getLogger(NettyNioAsyncHttpClient.class);
     private static final long MAX_STREAMS_ALLOWED = 4294967295L; // unsigned 32-bit, 2^32 -1
+    private static final int DEFAULT_INITIAL_WINDOW_SIZE = 1_048_576; // 1MiB
 
     // Override connection idle timeout for Netty http client to reduce the frequency of "server failed to complete the
     // response error". see https://github.com/aws/aws-sdk-java-v2/issues/1122
@@ -91,13 +93,19 @@ public final class NettyNioAsyncHttpClient implements SdkAsyncHttpClient {
     private NettyNioAsyncHttpClient(DefaultBuilder builder, AttributeMap serviceDefaultsMap) {
         this.configuration = new NettyConfiguration(serviceDefaultsMap);
         Protocol protocol = serviceDefaultsMap.get(SdkHttpConfigurationOption.PROTOCOL);
-        long maxStreams = builder.maxHttp2Streams == null ? MAX_STREAMS_ALLOWED : builder.maxHttp2Streams;
         this.sdkEventLoopGroup = eventLoopGroup(builder);
+
+        Http2Configuration http2Configuration = builder.http2Configuration;
+
+        long maxStreams = resolveMaxHttp2Streams(builder.maxHttp2Streams, http2Configuration);
+        int initialWindowSize = resolveInitialWindowSize(http2Configuration);
+
         this.pools = AwaitCloseChannelPoolMap.builder()
                                              .sdkChannelOptions(builder.sdkChannelOptions)
                                              .configuration(configuration)
                                              .protocol(protocol)
                                              .maxStreams(maxStreams)
+                                             .initialWindowSize(initialWindowSize)
                                              .sdkEventLoopGroup(sdkEventLoopGroup)
                                              .sslProvider(resolveSslProvider(builder))
                                              .proxyConfiguration(builder.proxyConfiguration)
@@ -149,6 +157,25 @@ private SslProvider resolveSslProvider(DefaultBuilder builder) {
         return SslContext.defaultClientProvider();
     }
 
+    private long resolveMaxHttp2Streams(Integer topLevelValue, Http2Configuration http2Configuration) {
+        if (topLevelValue != null) {
+            return topLevelValue;
+        }
+
+        if (http2Configuration == null || http2Configuration.maxStreams() == null) {
+            return MAX_STREAMS_ALLOWED;
+        }
+
+        return Math.min(http2Configuration.maxStreams(), MAX_STREAMS_ALLOWED);
+    }
+
+    private int resolveInitialWindowSize(Http2Configuration http2Configuration) {
+        if (http2Configuration == null || http2Configuration.initialWindowSize() == null) {
+            return DEFAULT_INITIAL_WINDOW_SIZE;
+        }
+        return http2Configuration.initialWindowSize();
+    }
+
     private SdkEventLoopGroup nonManagedEventLoopGroup(SdkEventLoopGroup eventLoopGroup) {
         return SdkEventLoopGroup.create(new NonManagedEventLoopGroup(eventLoopGroup.eventLoopGroup()),
                                         eventLoopGroup.channelFactory());
@@ -343,6 +370,9 @@ public interface Builder extends SdkAsyncHttpClient.Builder<NettyNioAsyncHttpCli
          *
          * @param maxHttp2Streams Max concurrent HTTP/2 streams per connection.
          * @return This builder for method chaining.
+         *
+         * @deprecated Use {@link #http2Configuration(Http2Configuration)} along with
+         * {@link Http2Configuration.Builder#maxStreams(Integer)} instead.
          */
         Builder maxHttp2Streams(Integer maxHttp2Streams);
 
@@ -380,6 +410,28 @@ public interface Builder extends SdkAsyncHttpClient.Builder<NettyNioAsyncHttpCli
          * @return The builder for method chaining.
          */
         Builder tlsKeyManagersProvider(TlsKeyManagersProvider keyManagersProvider);
+
+        /**
+         * Set the HTTP/2 specific configuration for this client.
+         * <p>
+         * <b>Note:</b>If {@link #maxHttp2Streams(Integer)} and {@link Http2Configuration#maxStreams()} are both set,
+         * the value set using {@link #maxHttp2Streams(Integer)} takes precedence.
+         *
+         * @param http2Configuration The HTTP/2 configuration object.
+         * @return the builder for method chaining.
+         */
+        Builder http2Configuration(Http2Configuration http2Configuration);
+
+        /**
+         * Set the HTTP/2 specific configuration for this client.
+         * <p>
+         * <b>Note:</b>If {@link #maxHttp2Streams(Integer)} and {@link Http2Configuration#maxStreams()} are both set,
+         * the value set using {@link #maxHttp2Streams(Integer)} takes precedence.
+         *
+         * @param http2ConfigurationBuilderConsumer The consumer of the HTTP/2 configuration builder object.
+         * @return the builder for method chaining.
+         */
+        Builder http2Configuration(Consumer<Http2Configuration.Builder> http2ConfigurationBuilderConsumer);
     }
 
     /**
@@ -394,6 +446,7 @@ private static final class DefaultBuilder implements Builder {
         private SdkEventLoopGroup eventLoopGroup;
         private SdkEventLoopGroup.Builder eventLoopGroupBuilder;
         private Integer maxHttp2Streams;
+        private Http2Configuration http2Configuration;
         private SslProvider sslProvider;
         private ProxyConfiguration proxyConfiguration;
 
@@ -568,6 +621,23 @@ public Builder tlsKeyManagersProvider(TlsKeyManagersProvider tlsKeyManagersProvi
             return this;
         }
 
+        @Override
+        public Builder http2Configuration(Http2Configuration http2Configuration) {
+            this.http2Configuration = http2Configuration;
+            return this;
+        }
+
+        @Override
+        public Builder http2Configuration(Consumer<Http2Configuration.Builder> http2ConfigurationBuilderConsumer) {
+            Http2Configuration.Builder builder = Http2Configuration.builder();
+            http2ConfigurationBuilderConsumer.accept(builder);
+            return http2Configuration(builder.build());
+        }
+
+        public void setHttp2Configuration(Http2Configuration http2Configuration) {
+            http2Configuration(http2Configuration);
+        }
+
         @Override
         public SdkAsyncHttpClient buildWithDefaults(AttributeMap serviceDefaults) {
             return new NettyNioAsyncHttpClient(this, standardOptions.build()

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

@@ -81,6 +81,7 @@ public void channelCreated(Channel ch) throws Exception {
     private final NettyConfiguration configuration;
     private final Protocol protocol;
     private final long maxStreams;
+    private final int initialWindowSize;
     private final SslProvider sslProvider;
     private final ProxyConfiguration proxyConfiguration;
 
@@ -90,6 +91,7 @@ private AwaitCloseChannelPoolMap(Builder builder) {
         this.configuration = builder.configuration;
         this.protocol = builder.protocol;
         this.maxStreams = builder.maxStreams;
+        this.initialWindowSize = builder.initialWindowSize;
         this.sslProvider = builder.sslProvider;
         this.proxyConfiguration = builder.proxyConfiguration;
     }
@@ -112,8 +114,13 @@ protected SimpleChannelPoolAwareChannelPool newPool(URI key) {
 
         AtomicReference<ChannelPool> channelPoolRef = new AtomicReference<>();
 
-        ChannelPipelineInitializer pipelineInitializer =
-            new ChannelPipelineInitializer(protocol, sslContext, maxStreams, channelPoolRef, configuration, key);
+        ChannelPipelineInitializer pipelineInitializer = new ChannelPipelineInitializer(protocol,
+                                                                                        sslContext,
+                                                                                        maxStreams,
+                                                                                        initialWindowSize,
+                                                                                        channelPoolRef,
+                                                                                        configuration,
+                                                                                        key);
 
         BetterSimpleChannelPool tcpChannelPool;
         ChannelPool baseChannelPool;
@@ -289,6 +296,7 @@ public static class Builder {
         private NettyConfiguration configuration;
         private Protocol protocol;
         private long maxStreams;
+        private int initialWindowSize;
         private SslProvider sslProvider;
         private ProxyConfiguration proxyConfiguration;
 
@@ -320,6 +328,11 @@ public Builder maxStreams(long maxStreams) {
             return this;
         }
 
+        public Builder initialWindowSize(int initialWindowSize) {
+            this.initialWindowSize = initialWindowSize;
+            return this;
+        }
+
         public Builder sslProvider(SslProvider sslProvider) {
             this.sslProvider = sslProvider;
             return this;

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

@@ -53,19 +53,22 @@ public final class ChannelPipelineInitializer extends AbstractChannelPoolHandler
     private final Protocol protocol;
     private final SslContext sslCtx;
     private final long clientMaxStreams;
+    private final int clientInitialWindowSize;
     private final AtomicReference<ChannelPool> channelPoolRef;
     private final NettyConfiguration configuration;
     private final URI poolKey;
 
     public ChannelPipelineInitializer(Protocol protocol,
                                       SslContext sslCtx,
                                       long clientMaxStreams,
+                                      int clientInitialWindowSize,
                                       AtomicReference<ChannelPool> channelPoolRef,
                                       NettyConfiguration configuration,
                                       URI poolKey) {
         this.protocol = protocol;
         this.sslCtx = sslCtx;
         this.clientMaxStreams = clientMaxStreams;
+        this.clientInitialWindowSize = clientInitialWindowSize;
         this.channelPoolRef = channelPoolRef;
         this.configuration = configuration;
         this.poolKey = poolKey;
@@ -125,7 +128,7 @@ private void configureHttp2(Channel ch, ChannelPipeline pipeline) {
         Http2FrameCodec codec =
             Http2FrameCodecBuilder.forClient()
                                   .headerSensitivityDetector((name, value) -> lowerCase(name.toString()).equals("authorization"))
-                                  .initialSettings(Http2Settings.defaultSettings().initialWindowSize(1_048_576))
+                                  .initialSettings(Http2Settings.defaultSettings().initialWindowSize(clientInitialWindowSize))
                                   .frameLogger(new Http2FrameLogger(LogLevel.DEBUG))
                                   .build();