Add new KeepAliveInterval option in QuicClientTransportOptions

src/IceRpc.Transports.Quic/Internal/QuicMultiplexedListener.cs

@@ -61,6 +61,9 @@ internal QuicMultiplexedListener(
             DefaultCloseErrorCode = (int)MultiplexedConnectionCloseError.Aborted,
             DefaultStreamErrorCode = 0,
             IdleTimeout = quicTransportOptions.IdleTimeout,
+#if NET9_0_OR_GREATER
+            KeepAliveInterval = Timeout.InfiniteTimeSpan, // the server doesn't send PING frames
+#endif
             ServerAuthenticationOptions = authenticationOptions,
             MaxInboundBidirectionalStreams = options.MaxBidirectionalStreams,
             MaxInboundUnidirectionalStreams = options.MaxUnidirectionalStreams

src/IceRpc.Transports.Quic/QuicClientTransport.cs

@@ -65,6 +65,9 @@ public IMultiplexedConnection CreateConnection(
             DefaultCloseErrorCode = (int)MultiplexedConnectionCloseError.Aborted,
             DefaultStreamErrorCode = 0,
             IdleTimeout = _quicTransportOptions.IdleTimeout,
+#if NET9_0_OR_GREATER
+            KeepAliveInterval = _quicTransportOptions.KeepAliveInterval,
+#endif
             LocalEndPoint = _quicTransportOptions.LocalNetworkAddress,
             RemoteEndPoint = endpoint,
             MaxInboundBidirectionalStreams = options.MaxBidirectionalStreams,

src/IceRpc.Transports.Quic/QuicTransportOptions.cs

@@ -9,9 +9,11 @@ public record class QuicTransportOptions
 {
     /// <summary>Gets or sets the idle timeout. This timeout is used to monitor the transport connection health. If no
     /// data is received within the idle timeout period, the transport connection is aborted.</summary>
-    /// <value>The idle timeout. Defaults to <see cref="TimeSpan.Zero" /> meaning that the underlying QUIC
-    /// implementation default will be used.</value>
-    public TimeSpan IdleTimeout { get; set; } = TimeSpan.Zero;
+    /// <value>The idle timeout. Defaults to 30 seconds. <see cref="TimeSpan.Zero" /> means "use the default value
+    /// provided by the underlying implementation".</value>
+    /// <remarks>The idle timeout is negotiated by QUIC during connection establishment. The actual idle timeout value
+    /// for a connection can be lower than the value you've set here.</remarks>
+    public TimeSpan IdleTimeout { get; set; } = TimeSpan.FromSeconds(30);
 }
 
 /// <summary>The options class for configuring <see cref="QuicClientTransport"/>.</summary>
@@ -22,6 +24,22 @@ public sealed record class QuicClientTransportOptions : QuicTransportOptions
     /// establishment.</summary>
     /// <value>The address and port to bind to. Defaults to <see langword="null" />.</value>
     public IPEndPoint? LocalNetworkAddress { get; set; }
+
+    /// <summary>Gets or sets the interval at which the client sends QUIC PING frames to the server to keep the
+    /// connection alive.</summary>
+    /// <value>The keep-alive interval. Defaults to 15 seconds. <see cref="TimeSpan.Zero" /> means: use the default
+    /// value provided by the underlying implementation. <see cref="Timeout.InfiniteTimeSpan" /> means: never send
+    /// PING frames.</value>
+    /// <remarks>Unlike the idle timeout, the keep-alive interval is not negotiated during connection establishment. We
+    /// recommend setting this interval at half the negotiated idle timeout value to keep a healthy connection alive
+    /// forever - really until it's closed due to inactivity at the RPC level via the
+    /// <see cref="ConnectionOptions.InactivityTimeout" />.
+    /// This option is a stop-gap: ideally the .NET QUIC implementation would provide a way to automatically send PING
+    /// frames to keep the connection alive based on the negotiated idle timeout. See
+    /// <see href="https://github.com/microsoft/msquic/issues/3880" />.</remarks>
+    /// <remarks>This option is only implemented for .NET 9.0. With .NET 8.0, neither the client nor the server sends
+    /// PING frames to keep the connection alive.</remarks>
+    public TimeSpan KeepAliveInterval { get; set; } = TimeSpan.FromSeconds(15);
 }
 
 /// <summary>The options class for configuring <see cref="QuicServerTransport"/>.</summary>

tests/IceRpc.Compressor.Tests/CompressorInterceptorTests.cs

@@ -43,7 +43,7 @@ public async Task Compress_request_payload(
             new BrotliStream(outStream, CompressionMode.Decompress) :
             new DeflateStream(outStream, CompressionMode.Decompress);
         var decompressedPayload = new byte[4096];
-        await decompressedStream.ReadAsync(decompressedPayload);
+        await decompressedStream.ReadAtLeastAsync(decompressedPayload, _payload.Length);
         Assert.That(decompressedPayload, Is.EqualTo(_payload));
         payloadWriter.Complete();
     }

tests/IceRpc.Compressor.Tests/CompressorMiddlewareTests.cs

@@ -45,7 +45,7 @@ public async Task Compress_response_payload(
             new BrotliStream(outStream, CompressionMode.Decompress) :
             new DeflateStream(outStream, CompressionMode.Decompress);
         byte[] decompressedPayload = new byte[4096];
-        await decompressedStream.ReadAsync(decompressedPayload);
+        await decompressedStream.ReadAtLeastAsync(decompressedPayload, _payload.Length);
         Assert.That(decompressedPayload, Is.EqualTo(_payload));
         payloadWriter.Complete();
     }

tests/IceRpc.Quic.Tests/Transports/QuicIdleTimeoutTests.cs

@@ -26,7 +26,7 @@ public void FixtureSetUp()
     /// timeout.</summary>
     /// <remarks>The behavior shown by this test is not desirable for IceRPC: we would prefer QUIC or IceRPC's QUIC
     /// wrapper to keep this connection alive when there is an outstanding request.
-    /// See https://github.com/icerpc/icerpc-csharp/issues/3353.</remarks>
+    /// See <see href="https://github.com/icerpc/icerpc-csharp/issues/3353" />.</remarks>
     [Test]
     public async Task Quic_connection_idle_after_idle_timeout([Values]bool configureServer)
     {
@@ -60,14 +60,56 @@ public async Task Quic_connection_idle_after_idle_timeout([Values]bool configure
         // Act / Assert
         var startTime = TimeSpan.FromMilliseconds(Environment.TickCount64);
 
-        Assert.That(readResult.Buffer.ToArray(), Is.EqualTo(data));
-
         Assert.That(
             async () => await sut.Local.Input.ReadAsync().AsTask(),
             Throws.InstanceOf<IceRpcException>().With.Property("IceRpcError").EqualTo(IceRpcError.ConnectionIdle));
 
         Assert.That(
             TimeSpan.FromMilliseconds(Environment.TickCount64) - startTime,
             Is.GreaterThan(TimeSpan.FromMilliseconds(490)));
+
+        Assert.That(readResult.Buffer.ToArray(), Is.EqualTo(data));
+    }
+
+    /// <summary>Verifies the QUIC connection is kept alive by the keep alive interval.</summary>
+    [Test]
+    public async Task Quic_connection_kept_alive_by_keep_alive_interval()
+    {
+        // Arrange
+        var services = new ServiceCollection().AddQuicTest();
+
+        services.AddOptions<QuicServerTransportOptions>("server").Configure(
+            options => options.IdleTimeout = TimeSpan.FromMilliseconds(500));
+
+        services.AddOptions<QuicClientTransportOptions>("client").Configure(
+            options => options.KeepAliveInterval = TimeSpan.FromMilliseconds(250));
+
+        await using ServiceProvider provider = services.BuildServiceProvider(validateScopes: true);
+
+        var clientServerConnection = provider.GetRequiredService<ClientServerMultiplexedConnection>();
+        await clientServerConnection.AcceptAndConnectAsync();
+        using var sut = await clientServerConnection.CreateAndAcceptStreamAsync(bidirectional: true);
+
+        // Simulate a request
+        var data = new byte[] { 0x1, 0x2, 0x3 };
+        await sut.Local.Output.WriteAsync(data);
+        ReadResult readResult = await sut.Remote.Input.ReadAsync();
+
+        // Act/Assert
+
+        // Without the keep-alive interval, the idle timer aborts the connection after 500ms.
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+
+#if NET9_0_OR_GREATER
+        Assert.That(
+            async () => await sut.Local.Input.ReadAsync(cts.Token),
+            Throws.InstanceOf<OperationCanceledException>());
+#else
+        Assert.That(
+            async () => await sut.Local.Input.ReadAsync().AsTask(),
+            Throws.InstanceOf<IceRpcException>().With.Property("IceRpcError").EqualTo(IceRpcError.ConnectionIdle));
+#endif
+
+        Assert.That(readResult.Buffer.ToArray(), Is.EqualTo(data));
     }
 }