| | | 1 | | // Copyright (c) ZeroC, Inc. |
| | | 2 | | |
| | | 3 | | using System.Buffers; |
| | | 4 | | using System.Diagnostics; |
| | | 5 | | using System.IO.Pipelines; |
| | | 6 | | |
| | | 7 | | namespace IceRpc.Transports.Slic.Internal; |
| | | 8 | | |
| | | 9 | | /// <summary>A helper class to write data to a duplex connection. Its methods shouldn't be called concurrently. The data |
| | | 10 | | /// written to this writer is copied and buffered with an internal pipe. The data from the pipe is written on the duplex |
| | | 11 | | /// connection with a background task.</summary> |
| | | 12 | | internal class SlicDuplexConnectionWriter : IBufferWriter<byte>, IAsyncDisposable |
| | | 13 | | { |
| | 1540 | 14 | | internal Task WriterTask { get; private init; } |
| | | 15 | | |
| | | 16 | | private readonly IDuplexConnection _connection; |
| | 700 | 17 | | private readonly CancellationTokenSource _disposeCts = new(); |
| | | 18 | | private Task? _disposeTask; |
| | | 19 | | private readonly Pipe _pipe; |
| | | 20 | | |
| | 89833 | 21 | | public void Advance(int bytes) => _pipe.Writer.Advance(bytes); |
| | | 22 | | |
| | | 23 | | /// <inheritdoc/> |
| | | 24 | | public ValueTask DisposeAsync() |
| | 699 | 25 | | { |
| | 699 | 26 | | _disposeTask ??= PerformDisposeAsync(); |
| | 699 | 27 | | return new(_disposeTask); |
| | | 28 | | |
| | | 29 | | async Task PerformDisposeAsync() |
| | 699 | 30 | | { |
| | 699 | 31 | | _disposeCts.Cancel(); |
| | | 32 | | |
| | 699 | 33 | | await WriterTask.ConfigureAwait(false); |
| | | 34 | | |
| | 699 | 35 | | _pipe.Reader.Complete(); |
| | 699 | 36 | | _pipe.Writer.Complete(); |
| | | 37 | | |
| | 699 | 38 | | _disposeCts.Dispose(); |
| | 699 | 39 | | } |
| | 699 | 40 | | } |
| | | 41 | | |
| | | 42 | | /// <inheritdoc/> |
| | 0 | 43 | | public Memory<byte> GetMemory(int sizeHint = 0) => _pipe.Writer.GetMemory(sizeHint); |
| | | 44 | | |
| | | 45 | | /// <inheritdoc/> |
| | 89833 | 46 | | public Span<byte> GetSpan(int sizeHint = 0) => _pipe.Writer.GetSpan(sizeHint); |
| | | 47 | | |
| | | 48 | | /// <summary>Constructs a duplex connection writer.</summary> |
| | | 49 | | /// <param name="connection">The duplex connection to write to.</param> |
| | | 50 | | /// <param name="pool">The memory pool to use.</param> |
| | | 51 | | /// <param name="minimumSegmentSize">The minimum segment size for buffers allocated from <paramref |
| | | 52 | | /// name="pool"/>.</param> |
| | 700 | 53 | | internal SlicDuplexConnectionWriter(IDuplexConnection connection, MemoryPool<byte> pool, int minimumSegmentSize) |
| | 700 | 54 | | { |
| | 700 | 55 | | _connection = connection; |
| | | 56 | | |
| | | 57 | | // We set pauseWriterThreshold to 0 because Slic implements flow-control at the stream level. So there's no need |
| | | 58 | | // to limit the amount of data buffered by the writer pipe. The amount of data buffered is limited to |
| | | 59 | | // (MaxBidirectionalStreams + MaxUnidirectionalStreams) * PeerPauseWriterThreshold bytes. |
| | 700 | 60 | | _pipe = new Pipe(new PipeOptions( |
| | 700 | 61 | | pool: pool, |
| | 700 | 62 | | minimumSegmentSize: minimumSegmentSize, |
| | 700 | 63 | | pauseWriterThreshold: 0, |
| | 700 | 64 | | useSynchronizationContext: false)); |
| | | 65 | | |
| | 700 | 66 | | WriterTask = Task.Run( |
| | 700 | 67 | | async () => |
| | 700 | 68 | | { |
| | 700 | 69 | | try |
| | 700 | 70 | | { |
| | 4836 | 71 | | while (true) |
| | 4836 | 72 | | { |
| | 4836 | 73 | | ReadResult readResult = await _pipe.Reader.ReadAsync(_disposeCts.Token).ConfigureAwait(false); |
| | 700 | 74 | | |
| | 4288 | 75 | | if (!readResult.Buffer.IsEmpty) |
| | 4189 | 76 | | { |
| | 4189 | 77 | | await _connection.WriteAsync(readResult.Buffer, _disposeCts.Token).ConfigureAwait(false); |
| | 4178 | 78 | | _pipe.Reader.AdvanceTo(readResult.Buffer.End); |
| | 4178 | 79 | | } |
| | 700 | 80 | | |
| | 4277 | 81 | | if (readResult.IsCompleted) |
| | 141 | 82 | | { |
| | 141 | 83 | | await _connection.ShutdownWriteAsync(_disposeCts.Token).ConfigureAwait(false); |
| | 139 | 84 | | break; |
| | 700 | 85 | | } |
| | 4136 | 86 | | } |
| | 139 | 87 | | _pipe.Reader.Complete(); |
| | 139 | 88 | | } |
| | 556 | 89 | | catch (OperationCanceledException) |
| | 556 | 90 | | { |
| | 700 | 91 | | // DisposeAsync was called. |
| | 556 | 92 | | } |
| | 4 | 93 | | catch (Exception exception) |
| | 4 | 94 | | { |
| | 4 | 95 | | _pipe.Reader.Complete(exception); |
| | 4 | 96 | | } |
| | 1399 | 97 | | }); |
| | 700 | 98 | | } |
| | | 99 | | |
| | | 100 | | internal void Flush() |
| | 12854 | 101 | | { |
| | 12854 | 102 | | ValueTask<FlushResult> flushResult = _pipe.Writer.FlushAsync(CancellationToken.None); |
| | | 103 | | |
| | | 104 | | // PauseWriterThreshold is 0 so FlushAsync should always complete synchronously. |
| | 12854 | 105 | | Debug.Assert(flushResult.IsCompletedSuccessfully); |
| | 12854 | 106 | | } |
| | | 107 | | |
| | | 108 | | /// <summary>Requests the shut down of the duplex connection writes after the buffered data is written on the |
| | | 109 | | /// duplex connection.</summary> |
| | | 110 | | internal void Shutdown() => |
| | | 111 | | // Completing the pipe writer makes the background write task complete successfully. |
| | 141 | 112 | | _pipe.Writer.Complete(); |
| | | 113 | | } |