| | | 1 | | // Copyright (c) ZeroC, Inc. |
| | | 2 | | |
| | | 3 | | using System.Buffers; |
| | | 4 | | using System.Diagnostics; |
| | | 5 | | |
| | | 6 | | namespace IceRpc.Transports.Slic.Internal; |
| | | 7 | | |
| | | 8 | | /// <summary>Decorates <see cref="ReadAsync" /> to fail if no byte is received for over idle timeout. Also optionally |
| | | 9 | | /// decorates both <see cref="ReadAsync"/> and <see cref="WriteAsync" /> to schedule pings that prevent both the local |
| | | 10 | | /// and remote idle timers from expiring.</summary> |
| | | 11 | | internal class SlicDuplexConnectionDecorator : IDuplexConnection |
| | | 12 | | { |
| | | 13 | | private readonly IDuplexConnection _decoratee; |
| | 801 | 14 | | private TimeSpan _idleTimeout = Timeout.InfiniteTimeSpan; |
| | 801 | 15 | | private readonly CancellationTokenSource _readCts = new(); |
| | | 16 | | |
| | | 17 | | private readonly Timer? _readTimer; |
| | | 18 | | private readonly Timer? _writeTimer; |
| | | 19 | | |
| | | 20 | | public Task<TransportConnectionInformation> ConnectAsync(CancellationToken cancellationToken) => |
| | 779 | 21 | | _decoratee.ConnectAsync(cancellationToken); |
| | | 22 | | |
| | | 23 | | public void Dispose() |
| | 800 | 24 | | { |
| | 800 | 25 | | _decoratee.Dispose(); |
| | 800 | 26 | | _readCts.Dispose(); |
| | | 27 | | |
| | | 28 | | // Using Dispose is fine, there's no need to wait for the keep alive action to terminate if it's running. |
| | 800 | 29 | | _readTimer?.Dispose(); |
| | 800 | 30 | | _writeTimer?.Dispose(); |
| | 800 | 31 | | } |
| | | 32 | | |
| | | 33 | | public ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken) |
| | 29712 | 34 | | { |
| | 29712 | 35 | | return _idleTimeout == Timeout.InfiniteTimeSpan ? |
| | 29712 | 36 | | _decoratee.ReadAsync(buffer, cancellationToken) : |
| | 29712 | 37 | | PerformReadAsync(); |
| | | 38 | | |
| | | 39 | | async ValueTask<int> PerformReadAsync() |
| | 28950 | 40 | | { |
| | | 41 | | try |
| | 28950 | 42 | | { |
| | 28950 | 43 | | using CancellationTokenRegistration _ = cancellationToken.UnsafeRegister( |
| | 309 | 44 | | cts => ((CancellationTokenSource)cts!).Cancel(), |
| | 28950 | 45 | | _readCts); |
| | 28950 | 46 | | _readCts.CancelAfter(_idleTimeout); // enable idle timeout before reading |
| | | 47 | | |
| | 28950 | 48 | | int bytesRead = await _decoratee.ReadAsync(buffer, _readCts.Token).ConfigureAwait(false); |
| | | 49 | | |
| | | 50 | | // After each successful read, we schedule one ping some time in the future. |
| | 28395 | 51 | | if (bytesRead > 0) |
| | 28258 | 52 | | { |
| | 28258 | 53 | | ResetReadTimer(); |
| | 28258 | 54 | | } |
| | | 55 | | // When 0, the other side called ShutdownWriteAsync, so there is no point to send a ping since we can't |
| | | 56 | | // get back a pong. |
| | | 57 | | |
| | 28395 | 58 | | return bytesRead; |
| | | 59 | | } |
| | 282 | 60 | | catch (OperationCanceledException) |
| | 282 | 61 | | { |
| | 282 | 62 | | cancellationToken.ThrowIfCancellationRequested(); |
| | | 63 | | |
| | 1 | 64 | | throw new IceRpcException( |
| | 1 | 65 | | IceRpcError.ConnectionIdle, |
| | 1 | 66 | | $"The connection did not receive any bytes for over {_idleTimeout.TotalSeconds} s."); |
| | | 67 | | } |
| | | 68 | | finally |
| | 28950 | 69 | | { |
| | 28950 | 70 | | _readCts.CancelAfter(Timeout.InfiniteTimeSpan); // disable idle timeout if not canceled |
| | 28950 | 71 | | } |
| | 28395 | 72 | | } |
| | 29712 | 73 | | } |
| | | 74 | | |
| | | 75 | | public Task ShutdownWriteAsync(CancellationToken cancellationToken) => |
| | 144 | 76 | | _decoratee.ShutdownWriteAsync(cancellationToken); |
| | | 77 | | |
| | | 78 | | public ValueTask WriteAsync(ReadOnlySequence<byte> buffer, CancellationToken cancellationToken) |
| | 6086 | 79 | | { |
| | 6086 | 80 | | return _idleTimeout == Timeout.InfiniteTimeSpan ? |
| | 6086 | 81 | | _decoratee.WriteAsync(buffer, cancellationToken) : |
| | 6086 | 82 | | PerformWriteAsync(); |
| | | 83 | | |
| | | 84 | | async ValueTask PerformWriteAsync() |
| | 5714 | 85 | | { |
| | 5714 | 86 | | await _decoratee.WriteAsync(buffer, cancellationToken).ConfigureAwait(false); |
| | | 87 | | |
| | | 88 | | // After each successful write, we schedule one ping some time in the future. Since each ping is itself a |
| | | 89 | | // write, if there is no application activity at all, we'll send successive pings at regular intervals. |
| | 5708 | 90 | | ResetWriteTimer(); |
| | 5708 | 91 | | } |
| | 6086 | 92 | | } |
| | | 93 | | |
| | | 94 | | /// <summary>Constructs a decorator that does nothing until it is enabled by a call to <see cref="Enable"/>. |
| | | 95 | | /// </summary> |
| | 1602 | 96 | | internal SlicDuplexConnectionDecorator(IDuplexConnection decoratee) => _decoratee = decoratee; |
| | | 97 | | |
| | | 98 | | /// <summary>Constructs a decorator that does nothing until it is enabled by a call to <see cref="Enable"/>. |
| | | 99 | | /// </summary> |
| | | 100 | | internal SlicDuplexConnectionDecorator( |
| | | 101 | | IDuplexConnection decoratee, |
| | | 102 | | Action sendReadPing, |
| | | 103 | | Action sendWritePing) |
| | 398 | 104 | | : this(decoratee) |
| | 398 | 105 | | { |
| | 413 | 106 | | _readTimer = new Timer(_ => sendReadPing()); |
| | 399 | 107 | | _writeTimer = new Timer(_ => sendWritePing()); |
| | 398 | 108 | | } |
| | | 109 | | |
| | | 110 | | /// <summary>Sets the idle timeout and schedules pings once the connection is established.</summary>. |
| | | 111 | | internal void Enable(TimeSpan idleTimeout) |
| | 721 | 112 | | { |
| | 721 | 113 | | Debug.Assert(idleTimeout != Timeout.InfiniteTimeSpan); |
| | 721 | 114 | | _idleTimeout = idleTimeout; |
| | | 115 | | |
| | 721 | 116 | | ResetReadTimer(); |
| | 721 | 117 | | ResetWriteTimer(); |
| | 721 | 118 | | } |
| | | 119 | | |
| | | 120 | | /// <summary>Resets the read timer. We send a "read" ping when this timer expires.</summary> |
| | | 121 | | /// <remarks>This method is no-op unless this decorator is constructed with send ping actions.</remarks> |
| | 28979 | 122 | | private void ResetReadTimer() => _readTimer?.Change(_idleTimeout * 0.5, Timeout.InfiniteTimeSpan); |
| | | 123 | | |
| | | 124 | | /// <summary>Resets the write timer. We send a "write" ping when this timer expires.</summary> |
| | | 125 | | /// <remarks>This method is no-op unless this decorator is constructed with send ping actions.</remarks> |
| | | 126 | | // The write timer factor (0.6) was chosen to be greater than the read timer factor (0.5). This way, when the |
| | | 127 | | // connection is completely idle, the read timer expires before the write timer and has time to send a ping that |
| | | 128 | | // resets the write timer. This reduces the likelihood of duplicate "keep alive" pings. |
| | 6429 | 129 | | private void ResetWriteTimer() => _writeTimer?.Change(_idleTimeout * 0.6, Timeout.InfiniteTimeSpan); |
| | | 130 | | } |