| | | 1 | | // Copyright (c) ZeroC, Inc. |
| | | 2 | | |
| | | 3 | | using System.Buffers; |
| | | 4 | | using System.IO.Pipelines; |
| | | 5 | | |
| | | 6 | | namespace IceRpc.Transports.Slic.Internal; |
| | | 7 | | |
| | | 8 | | /// <summary>A helper class to write data to a duplex connection. Its methods shouldn't be called concurrently. The data |
| | | 9 | | /// written to this writer is copied and buffered with an internal pipe. The data from the pipe is written on the duplex |
| | | 10 | | /// connection with a background task.</summary> |
| | | 11 | | internal class SlicDuplexConnectionWriter : IBufferWriter<byte>, IAsyncDisposable |
| | | 12 | | { |
| | 1741 | 13 | | internal Task WriterTask { get; private init; } |
| | | 14 | | |
| | | 15 | | private readonly IDuplexConnection _connection; |
| | 799 | 16 | | private readonly CancellationTokenSource _disposeCts = new(); |
| | | 17 | | private Task? _disposeTask; |
| | | 18 | | private readonly Pipe _pipe; |
| | | 19 | | |
| | 81769 | 20 | | public void Advance(int bytes) => _pipe.Writer.Advance(bytes); |
| | | 21 | | |
| | | 22 | | /// <inheritdoc/> |
| | | 23 | | public ValueTask DisposeAsync() |
| | 798 | 24 | | { |
| | 798 | 25 | | _disposeTask ??= PerformDisposeAsync(); |
| | 798 | 26 | | return new(_disposeTask); |
| | | 27 | | |
| | | 28 | | async Task PerformDisposeAsync() |
| | 798 | 29 | | { |
| | 798 | 30 | | _disposeCts.Cancel(); |
| | | 31 | | |
| | 798 | 32 | | await WriterTask.ConfigureAwait(false); |
| | | 33 | | |
| | 798 | 34 | | _pipe.Reader.Complete(); |
| | 798 | 35 | | _pipe.Writer.Complete(); |
| | | 36 | | |
| | 798 | 37 | | _disposeCts.Dispose(); |
| | 798 | 38 | | } |
| | 798 | 39 | | } |
| | | 40 | | |
| | | 41 | | /// <inheritdoc/> |
| | 0 | 42 | | public Memory<byte> GetMemory(int sizeHint = 0) => _pipe.Writer.GetMemory(sizeHint); |
| | | 43 | | |
| | | 44 | | /// <inheritdoc/> |
| | 81769 | 45 | | public Span<byte> GetSpan(int sizeHint = 0) => _pipe.Writer.GetSpan(sizeHint); |
| | | 46 | | |
| | | 47 | | /// <summary>Constructs a duplex connection writer.</summary> |
| | | 48 | | /// <param name="connection">The duplex connection to write to.</param> |
| | | 49 | | /// <param name="pool">The memory pool to use.</param> |
| | | 50 | | /// <param name="minimumSegmentSize">The minimum segment size for buffers allocated from <paramref |
| | | 51 | | /// name="pool"/>.</param> |
| | | 52 | | /// <param name="pauseWriterThreshold">The pipe pause writer threshold. When buffered data exceeds this value, <see |
| | | 53 | | /// cref="FlushAsync" /> blocks until the background writer task drains enough data from the pipe.</param> |
| | 799 | 54 | | internal SlicDuplexConnectionWriter( |
| | 799 | 55 | | IDuplexConnection connection, |
| | 799 | 56 | | MemoryPool<byte> pool, |
| | 799 | 57 | | int minimumSegmentSize, |
| | 799 | 58 | | int pauseWriterThreshold) |
| | 799 | 59 | | { |
| | 799 | 60 | | _connection = connection; |
| | | 61 | | |
| | 799 | 62 | | _pipe = new Pipe(new PipeOptions( |
| | 799 | 63 | | pool: pool, |
| | 799 | 64 | | minimumSegmentSize: minimumSegmentSize, |
| | 799 | 65 | | pauseWriterThreshold: pauseWriterThreshold, |
| | 799 | 66 | | // Match the algorithm PipeOptions uses for its defaults: resumeWriterThreshold = pauseWriterThreshold / 2. |
| | 799 | 67 | | // Without this override, the PipeOptions default of 32 KB would exceed pauseWriterThreshold for small |
| | 799 | 68 | | // thresholds and throw. When pauseWriterThreshold is 0, leave both at 0 to disable pausing. |
| | 799 | 69 | | resumeWriterThreshold: pauseWriterThreshold == 0 ? 0 : pauseWriterThreshold / 2, |
| | 799 | 70 | | useSynchronizationContext: false)); |
| | | 71 | | |
| | 799 | 72 | | WriterTask = Task.Run( |
| | 799 | 73 | | async () => |
| | 799 | 74 | | { |
| | 799 | 75 | | try |
| | 799 | 76 | | { |
| | 6836 | 77 | | while (true) |
| | 6836 | 78 | | { |
| | 6836 | 79 | | ReadResult readResult = await _pipe.Reader.ReadAsync(_disposeCts.Token).ConfigureAwait(false); |
| | 799 | 80 | | |
| | 6188 | 81 | | if (!readResult.Buffer.IsEmpty) |
| | 6085 | 82 | | { |
| | 6085 | 83 | | await _connection.WriteAsync(readResult.Buffer, _disposeCts.Token).ConfigureAwait(false); |
| | 6078 | 84 | | _pipe.Reader.AdvanceTo(readResult.Buffer.End); |
| | 6078 | 85 | | } |
| | 799 | 86 | | |
| | 6181 | 87 | | if (readResult.IsCompleted) |
| | 144 | 88 | | { |
| | 144 | 89 | | await _connection.ShutdownWriteAsync(_disposeCts.Token).ConfigureAwait(false); |
| | 142 | 90 | | break; |
| | 799 | 91 | | } |
| | 6037 | 92 | | } |
| | 142 | 93 | | _pipe.Reader.Complete(); |
| | 142 | 94 | | } |
| | 653 | 95 | | catch (OperationCanceledException) |
| | 653 | 96 | | { |
| | 799 | 97 | | // DisposeAsync was called. |
| | 653 | 98 | | } |
| | 3 | 99 | | catch (Exception exception) |
| | 3 | 100 | | { |
| | 3 | 101 | | _pipe.Reader.Complete(exception); |
| | 3 | 102 | | } |
| | 1597 | 103 | | }); |
| | 799 | 104 | | } |
| | | 105 | | |
| | | 106 | | /// <summary>Flushes the underlying pipe. May block when the buffered data exceeds the configured pause writer |
| | | 107 | | /// threshold.</summary> |
| | | 108 | | internal ValueTask<FlushResult> FlushAsync(CancellationToken cancellationToken) => |
| | 12356 | 109 | | _pipe.Writer.FlushAsync(cancellationToken); |
| | | 110 | | |
| | | 111 | | /// <summary>Requests the shut down of the duplex connection writes after the buffered data is written on the |
| | | 112 | | /// duplex connection.</summary> |
| | | 113 | | internal void Shutdown() => |
| | | 114 | | // Completing the pipe writer makes the background write task complete successfully. |
| | 144 | 115 | | _pipe.Writer.Complete(); |
| | | 116 | | } |