Http2 ping

src/libraries/Common/src/System/Net/Http/HttpHandlerDefaults.cs

@@ -29,7 +29,7 @@ internal static class HttpHandlerDefaults
         public static readonly TimeSpan DefaultExpect100ContinueTimeout = TimeSpan.FromSeconds(1);
         public static readonly TimeSpan DefaultKeepAlivePingTimeout = TimeSpan.FromSeconds(20);
         public static readonly TimeSpan DefaultKeepAlivePingDelay = TimeSpan.FromSeconds(0);
-        public const bool DefaultKeepAlivePingWithoutRequests = true;
+        public const HttpKeepAlivePingPolicy DefaultKeepAlivePingPolicy = HttpKeepAlivePingPolicy.Always;
         public static readonly TimeSpan DefaultConnectTimeout = Timeout.InfiniteTimeSpan;
 
     }

src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs

@@ -576,6 +576,25 @@ public async Task PingPong()
             Assert.Equal(pingData, pingAck.Data);
         }
 
+        public async Task<PingFrame> ReadPingAsync(TimeSpan timeout)
+        {
+            Frame frame = await ReadFrameAsync(timeout).ConfigureAwait(false);
+            Assert.NotNull(frame);
+            Assert.Equal(FrameType.Ping, frame.Type);
+            Assert.Equal(0, frame.StreamId);
+            Assert.False(frame.AckFlag);
+
+            PingFrame ping = frame as PingFrame;
+            Assert.NotNull(ping);
+            return ping;
+        }
+
+        public async Task SendPingAckAsync(byte[] payload)
+        {
+            PingFrame pingAck = new PingFrame(payload, FrameFlags.Ack, 0);
+            await WriteFrameAsync(pingAck).ConfigureAwait(false);
+        }
+
         public async Task SendDefaultResponseHeadersAsync(int streamId)
         {
             byte[] headers = new byte[] { 0x88 };   // Encoding for ":status: 200"

src/libraries/System.Net.Http/ref/System.Net.Http.cs

@@ -295,7 +295,7 @@ public SocketsHttpHandler() { }
         public System.TimeSpan Expect100ContinueTimeout { get { throw null; } set { } }
         public System.TimeSpan KeepAlivePingDelay { get { throw null; } set { } }
         public System.TimeSpan KeepAlivePingTimeout { get { throw null; } set { } }
-        public bool KeepAlivePingWithoutRequests { get { throw null; } set { } }
+        public HttpKeepAlivePingPolicy KeepAlivePingPolicy { get { throw null; } set { } }
         public int MaxAutomaticRedirections { get { throw null; } set { } }
         public int MaxConnectionsPerServer { get { throw null; } set { } }
         public int MaxResponseDrainSize { get { throw null; } set { } }
@@ -314,6 +314,11 @@ protected override void Dispose(bool disposing) { }
         protected internal override System.Net.Http.HttpResponseMessage Send(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { throw null; }
         protected internal override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { throw null; }
     }
+    public enum HttpKeepAlivePingPolicy
+    {
+        WithActiveRequests,
+        Always
+    }
     public partial class StreamContent : System.Net.Http.HttpContent
     {
         public StreamContent(System.IO.Stream content) { }

src/libraries/System.Net.Http/src/System.Net.Http.csproj

@@ -143,6 +143,7 @@
     <Compile Include="System\Net\Http\SocketsHttpHandler\FailedProxyCache.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2Connection.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2ConnectionException.cs" />
+    <Compile Include="System\Net\Http\SocketsHttpHandler\Http2KeepAlive.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2ProtocolErrorCode.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2ProtocolException.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2Stream.cs" />
@@ -164,6 +165,7 @@
     <Compile Include="System\Net\Http\SocketsHttpHandler\HttpContentReadStream.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\HttpContentStream.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\HttpContentWriteStream.cs" />
+    <Compile Include="System\Net\Http\SocketsHttpHandler\HttpKeepAlivePingPolicy.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\IHttpTrace.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\IMultiWebProxy.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\MultiProxy.cs" />

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs

@@ -95,90 +95,7 @@ internal sealed partial class Http2Connection : HttpConnectionBase, IDisposable
         // Channel options for creating _writeChannel
         private static readonly UnboundedChannelOptions s_channelOptions = new UnboundedChannelOptions() { SingleReader = true };
 
-
-        private readonly Http2KeepAlive _keepAlive;
-
-        internal enum KeepAliveState
-        {
-            None,
-            PingSent
-        }
-
-        internal enum KeepAliveVerifyAction
-        {
-            None,
-            SendPing,
-            Throw
-        }
-
-        internal class Http2KeepAlive
-        {
-
-            private long _pingPayload;
-
-            private readonly TimeSpan _keepAliveInterval;
-            private readonly TimeSpan _keepAliveTimeout;
-            private DateTimeOffset _nextPingRequestTimestamp;
-            private DateTimeOffset _pingTimeoutTimestamp;
-
-            private KeepAliveState _state;
-
-            public Http2KeepAlive(TimeSpan keepAliveInterval, TimeSpan keepAliveTimeout)
-            {
-                _keepAliveInterval = keepAliveInterval;
-                _keepAliveTimeout = keepAliveTimeout;
-                _nextPingRequestTimestamp = DateTimeOffset.Now.Add(keepAliveInterval);
-            }
-
-            public long PingPayload => _pingPayload;
-
-            public void ProcessFrame()
-            {
-                _nextPingRequestTimestamp = DateTimeOffset.Now.Add(_keepAliveInterval);
-            }
-
-            public bool ProcessPingAck(long payload)
-            {
-                if (_state != KeepAliveState.PingSent)
-                    return false;
-                if (Interlocked.Read(ref _pingPayload) != payload)
-                    return false;
-                _state = KeepAliveState.None;
-                return true;
-            }
-
-            public KeepAliveVerifyAction VerifyKeepAlive()
-            {
-                var now = DateTimeOffset.Now;
-                switch (_state)
-                {
-                    case KeepAliveState.None:
-                        // Check whether keep alive interval has passed since last frame received
-                        if (_keepAliveInterval > TimeSpan.Zero && now > _nextPingRequestTimestamp)
-                        {
-                            // Ping will be sent immeditely after this method finishes.
-                            // Set the status directly to ping sent and set the timestamp
-                            _state = KeepAliveState.PingSent;
-                            // System clock only has 1 second of precision, so the clock could be up to 1 second in the past.
-                            // To err on the side of caution, add a second to the clock when calculating the ping sent time.
-                            _pingTimeoutTimestamp = now.Add(_keepAliveTimeout);
-                            Interlocked.Increment(ref _pingPayload);
-                            return KeepAliveVerifyAction.SendPing;
-                        }
-                        break;
-                    case KeepAliveState.PingSent:
-                        if (_keepAliveTimeout != TimeSpan.MaxValue)
-                        {
-                            if (now > _pingTimeoutTimestamp)
-                                return KeepAliveVerifyAction.Throw;
-                        }
-
-                        break;
-                }
-
-                return KeepAliveVerifyAction.None;
-            }
-        }
+        private Http2KeepAlive _keepAlive;
 
         public Http2Connection(HttpConnectionPool pool, Stream stream)
         {
@@ -201,7 +118,7 @@ public Http2Connection(HttpConnectionPool pool, Stream stream)
             _maxConcurrentStreams = int.MaxValue;
             _pendingWindowUpdate = 0;
 
-            _keepAlive = new Http2KeepAlive(_pool.Settings._keepAlivePingDelay, _pool.Settings._keepAlivePingTimeout);
+            _keepAlive = new Http2KeepAlive(this, _pool.Settings);
 
             if (NetEventSource.Log.IsEnabled()) TraceConnection(stream);
         }
@@ -1048,15 +965,7 @@ internal void HeartBeat()
         {
             try
             {
-                switch (_keepAlive.VerifyKeepAlive())
-                {
-                    case KeepAliveVerifyAction.SendPing:
-                        SendPingAsync(_keepAlive.PingPayload);
-                        break;
-                    case KeepAliveVerifyAction.Throw:
-                        ThrowProtocolError();
-                        break;
-                }
+                _keepAlive.VerifyKeepAlive();
             }
             catch (Exception e)
             {

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2KeepAlive.cs

@@ -0,0 +1,99 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Net.Http.Headers;
+using System.Net.Http.HPack;
+using System.Net.Security;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+
+namespace System.Net.Http
+{
+    internal sealed partial class Http2Connection
+    {
+        internal enum KeepAliveState
+        {
+            None,
+            PingSent
+        }
+
+        internal class Http2KeepAlive
+        {
+
+            private long _pingPayload;
+
+            private readonly TimeSpan _keepAlivePingDelay;
+            private readonly TimeSpan _keepAlivePingTimeout;
+            private DateTimeOffset _nextPingRequestTimestamp;
+            private DateTimeOffset _pingTimeoutTimestamp;
+            private HttpKeepAlivePingPolicy _keepAlivePingPolicy;
+            private KeepAliveState _state;
+            private Http2Connection _connection;
+
+            public Http2KeepAlive(Http2Connection connection, HttpConnectionSettings settings)
+            {
+                _keepAlivePingDelay = settings._keepAlivePingDelay;
+                _keepAlivePingTimeout = settings._keepAlivePingTimeout;
+                _nextPingRequestTimestamp = DateTimeOffset.Now.Add(settings._keepAlivePingDelay);
+                _keepAlivePingPolicy = settings._keepAlivePingPolicy;
+                _connection = connection;
+            }
+
+            public void ProcessFrame()
+            {
+                _nextPingRequestTimestamp = DateTimeOffset.Now.Add(_keepAlivePingDelay);
+            }
+
+            public bool ProcessPingAck(long payload)
+            {
+                if (_state != KeepAliveState.PingSent)
+                    return false;
+                if (Interlocked.Read(ref _pingPayload) != payload)
+                    return false;
+                _state = KeepAliveState.None;
+                ProcessFrame();
+                return true;
+            }
+
+            public void VerifyKeepAlive()
+            {
+                if (_keepAlivePingPolicy == HttpKeepAlivePingPolicy.WithActiveRequests && _connection._httpStreams.Count == 0)
+                    return;
+
+                var now = DateTimeOffset.Now;
+                switch (_state)
+                {
+                    case KeepAliveState.None:
+                        // Check whether keep alive delay has passed since last frame received
+                        if (_keepAlivePingDelay > TimeSpan.Zero && now > _nextPingRequestTimestamp)
+                        {
+                            // Set the status directly to ping sent and set the timestamp
+                            _state = KeepAliveState.PingSent;
+                            _pingTimeoutTimestamp = now.Add(_keepAlivePingTimeout);
+                            Interlocked.Increment(ref _pingPayload);
+                            _connection.SendPingAsync(_pingPayload);
+                            return;
+                        }
+                        break;
+                    case KeepAliveState.PingSent:
+                        if (_keepAlivePingTimeout != TimeSpan.MaxValue)
+                        {
+                            if (now > _pingTimeoutTimestamp)
+                                Http2Connection.ThrowProtocolError();
+                        }
+
+                        break;
+                }
+            }
+        }
+    }
+}

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionSettings.cs

@@ -43,7 +43,7 @@ internal sealed class HttpConnectionSettings
         internal TimeSpan _expect100ContinueTimeout = HttpHandlerDefaults.DefaultExpect100ContinueTimeout;
         internal TimeSpan _keepAlivePingTimeout = HttpHandlerDefaults.DefaultKeepAlivePingTimeout;
         internal TimeSpan _keepAlivePingDelay = HttpHandlerDefaults.DefaultKeepAlivePingDelay;
-        internal bool _keepAlivePingWithoutRequests = HttpHandlerDefaults.DefaultKeepAlivePingWithoutRequests;
+        internal HttpKeepAlivePingPolicy _keepAlivePingPolicy = HttpHandlerDefaults.DefaultKeepAlivePingPolicy;
         internal TimeSpan _connectTimeout = HttpHandlerDefaults.DefaultConnectTimeout;
 
         internal Version _maxHttpVersion;
@@ -106,7 +106,8 @@ public HttpConnectionSettings CloneAndNormalize()
                 _allowUnencryptedHttp2 = _allowUnencryptedHttp2,
                 _assumePrenegotiatedHttp3ForTesting = _assumePrenegotiatedHttp3ForTesting,
                 _keepAlivePingTimeout = _keepAlivePingTimeout,
-                _keepAlivePingDelay = _keepAlivePingDelay
+                _keepAlivePingDelay = _keepAlivePingDelay,
+                _keepAlivePingPolicy = _keepAlivePingPolicy
             };
         }
 

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpKeepAlivePingPolicy.cs

@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Net.Http
+{
+    public enum HttpKeepAlivePingPolicy
+    {
+        WithActiveRequests,
+        Always
+    }
+}

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs

@@ -306,7 +306,15 @@ public TimeSpan KeepAlivePingTimeout
         }
 
 
-        public bool KeepAlivePingWithoutRequests => _settings._keepAlivePingWithoutRequests;
+        public HttpKeepAlivePingPolicy KeepAlivePingPolicy
+        {
+            get => _settings._keepAlivePingPolicy;
+            set
+            {
+                CheckDisposedOrStarted();
+                _settings._keepAlivePingPolicy = value;
+            }
+        }
 
         public IDictionary<string, object?> Properties =>
             _settings._properties ?? (_settings._properties = new Dictionary<string, object?>());