Make the PING health check period configurable

Author: dagnir

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

@@ -15,6 +15,8 @@
 
 package software.amazon.awssdk.http.nio.netty;
 
+import java.time.Duration;
+
 import software.amazon.awssdk.annotations.SdkPublicApi;
 import software.amazon.awssdk.utils.Validate;
 import software.amazon.awssdk.utils.builder.CopyableBuilder;
@@ -27,10 +29,12 @@
 public final class Http2Configuration implements ToCopyableBuilder<Http2Configuration.Builder, Http2Configuration> {
     private final Long maxStreams;
     private final Integer initialWindowSize;
+    private final Duration healthCheckPingPeriod;
 
     private Http2Configuration(DefaultBuilder builder) {
         this.maxStreams = builder.maxStreams;
         this.initialWindowSize = builder.initialWindowSize;
+        this.healthCheckPingPeriod = builder.healthCheckPingPeriod;
     }
 
     /**
@@ -47,6 +51,13 @@ public Integer initialWindowSize() {
         return initialWindowSize;
     }
 
+    /**
+     * @return The health check period for an HTTP/2 connection.
+     */
+    public Duration healthCheckPingPeriod() {
+        return healthCheckPingPeriod;
+    }
+
     @Override
     public Builder toBuilder() {
         return new DefaultBuilder(this);
@@ -106,18 +117,31 @@ public interface Builder extends CopyableBuilder<Builder, Http2Configuration> {
          * @return This builder for method chaining.
          */
         Builder initialWindowSize(Integer initialWindowSize);
+
+        /**
+         * Sets the period that the Netty client will send {@code PING} frames to the remote endpoint to check the
+         * health of the connection. The default value is {@link
+         * software.amazon.awssdk.http.nio.netty.internal.NettyConfiguration#HTTP2_CONNECTION_PING_TIMEOUT_SECONDS}. To
+         * disable this feature, set a duration of {@link Integer#MAX_VALUE} milliseconds or greater.
+         *
+         * @param healthCheckPingPeriod The ping period.
+         * @return This builder for method chaining.
+         */
+        Builder healthCheckPingPeriod(Duration healthCheckPingPeriod);
     }
 
     private static final class DefaultBuilder implements Builder {
         private Long maxStreams;
         private Integer initialWindowSize;
+        private Duration healthCheckPingPeriod;
 
         private DefaultBuilder() {
         }
 
         private DefaultBuilder(Http2Configuration http2Configuration) {
             this.maxStreams = http2Configuration.maxStreams;
             this.initialWindowSize = http2Configuration.initialWindowSize;
+            this.healthCheckPingPeriod = http2Configuration.healthCheckPingPeriod;
         }
 
         @Override
@@ -140,6 +164,16 @@ public void setInitialWindowSize(Integer initialWindowSize) {
             initialWindowSize(initialWindowSize);
         }
 
+        @Override
+        public Builder healthCheckPingPeriod(Duration healthCheckPingPeriod) {
+            this.healthCheckPingPeriod = healthCheckPingPeriod;
+            return this;
+        }
+
+        public void setHealthCheckPingPeriod(Duration healthCheckPingPeriod) {
+            healthCheckPingPeriod(healthCheckPingPeriod);
+        }
+
         @Override
         public Http2Configuration build() {
             return new Http2Configuration(this);

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

@@ -106,6 +106,7 @@ private NettyNioAsyncHttpClient(DefaultBuilder builder, AttributeMap serviceDefa
                                              .protocol(protocol)
                                              .maxStreams(maxStreams)
                                              .initialWindowSize(initialWindowSize)
+                                             .healthCheckPingPeriod(resolveHealthCheckPingPeriod(http2Configuration))
                                              .sdkEventLoopGroup(sdkEventLoopGroup)
                                              .sslProvider(resolveSslProvider(builder))
                                              .proxyConfiguration(builder.proxyConfiguration)
@@ -176,6 +177,13 @@ private int resolveInitialWindowSize(Http2Configuration http2Configuration) {
         return http2Configuration.initialWindowSize();
     }
 
+    private Duration resolveHealthCheckPingPeriod(Http2Configuration http2Configuration) {
+        if (http2Configuration != null) {
+            return http2Configuration.healthCheckPingPeriod();
+        }
+        return null;
+    }
+
     private SdkEventLoopGroup nonManagedEventLoopGroup(SdkEventLoopGroup eventLoopGroup) {
         return SdkEventLoopGroup.create(new NonManagedEventLoopGroup(eventLoopGroup.eventLoopGroup()),
                                         eventLoopGroup.channelFactory());

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

@@ -31,6 +31,7 @@
 import java.net.InetSocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.time.Duration;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
@@ -81,6 +82,7 @@ public void channelCreated(Channel ch) throws Exception {
     private final NettyConfiguration configuration;
     private final Protocol protocol;
     private final long maxStreams;
+    private final Duration healthCheckPingPeriod;
     private final int initialWindowSize;
     private final SslProvider sslProvider;
     private final ProxyConfiguration proxyConfiguration;
@@ -91,6 +93,7 @@ private AwaitCloseChannelPoolMap(Builder builder) {
         this.configuration = builder.configuration;
         this.protocol = builder.protocol;
         this.maxStreams = builder.maxStreams;
+        this.healthCheckPingPeriod = builder.healthCheckPingPeriod;
         this.initialWindowSize = builder.initialWindowSize;
         this.sslProvider = builder.sslProvider;
         this.proxyConfiguration = builder.proxyConfiguration;
@@ -118,6 +121,7 @@ protected SimpleChannelPoolAwareChannelPool newPool(URI key) {
                                                                                         sslContext,
                                                                                         maxStreams,
                                                                                         initialWindowSize,
+                                                                                        healthCheckPingPeriod,
                                                                                         channelPoolRef,
                                                                                         configuration,
                                                                                         key);
@@ -297,6 +301,7 @@ public static class Builder {
         private Protocol protocol;
         private long maxStreams;
         private int initialWindowSize;
+        private Duration healthCheckPingPeriod;
         private SslProvider sslProvider;
         private ProxyConfiguration proxyConfiguration;
 
@@ -333,6 +338,11 @@ public Builder initialWindowSize(int initialWindowSize) {
             return this;
         }
 
+        public Builder healthCheckPingPeriod(Duration healthCheckPingPeriod) {
+            this.healthCheckPingPeriod = healthCheckPingPeriod;
+            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

@@ -35,6 +35,7 @@
 import io.netty.handler.ssl.SslContext;
 import io.netty.handler.ssl.SslHandler;
 import java.net.URI;
+import java.time.Duration;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicReference;
 import javax.net.ssl.SSLEngine;
@@ -54,6 +55,7 @@ public final class ChannelPipelineInitializer extends AbstractChannelPoolHandler
     private final SslContext sslCtx;
     private final long clientMaxStreams;
     private final int clientInitialWindowSize;
+    private final Duration healthCheckPingPeriod;
     private final AtomicReference<ChannelPool> channelPoolRef;
     private final NettyConfiguration configuration;
     private final URI poolKey;
@@ -62,13 +64,15 @@ public ChannelPipelineInitializer(Protocol protocol,
                                       SslContext sslCtx,
                                       long clientMaxStreams,
                                       int clientInitialWindowSize,
+                                      Duration healthCheckPingPeriod,
                                       AtomicReference<ChannelPool> channelPoolRef,
                                       NettyConfiguration configuration,
                                       URI poolKey) {
         this.protocol = protocol;
         this.sslCtx = sslCtx;
         this.clientMaxStreams = clientMaxStreams;
         this.clientInitialWindowSize = clientInitialWindowSize;
+        this.healthCheckPingPeriod = healthCheckPingPeriod;
         this.channelPoolRef = channelPoolRef;
         this.configuration = configuration;
         this.poolKey = poolKey;
@@ -141,7 +145,11 @@ private void configureHttp2(Channel ch, ChannelPipeline pipeline) {
         pipeline.addLast(codec);
         pipeline.addLast(new Http2MultiplexHandler(new NoOpChannelInitializer()));
         pipeline.addLast(new Http2SettingsFrameHandler(ch, clientMaxStreams, channelPoolRef));
-        pipeline.addLast(new Http2PingHandler(HTTP2_CONNECTION_PING_TIMEOUT_SECONDS * 1_000));
+        if (healthCheckPingPeriod == null) {
+            pipeline.addLast(new Http2PingHandler(HTTP2_CONNECTION_PING_TIMEOUT_SECONDS * 1_000));
+        } else if (healthCheckPingPeriod.toMillis() <= Integer.MAX_VALUE) {
+            pipeline.addLast(new Http2PingHandler((int) healthCheckPingPeriod.toMillis()));
+        }
     }
 
     private void configureHttp11(Channel ch, ChannelPipeline pipeline) {