| | | 1 | | // Copyright (c) ZeroC, Inc. |
| | | 2 | | |
| | | 3 | | using IceRpc.Transports; |
| | | 4 | | using System.Buffers; |
| | | 5 | | using System.IO.Pipelines; |
| | | 6 | | |
| | | 7 | | namespace IceRpc.Internal; |
| | | 8 | | |
| | | 9 | | /// <summary>Provides a multiplexed stream decorator that allows <see cref="IceRpcProtocolConnection" /> to intercept |
| | | 10 | | /// the completion of the stream input and output.</summary> |
| | | 11 | | internal sealed class MultiplexedStreamDecorator : IMultiplexedStream |
| | | 12 | | { |
| | 1442 | 13 | | public ulong Id => _decoratee.Id; |
| | | 14 | | |
| | 7154 | 15 | | public bool IsBidirectional => _decoratee.IsBidirectional; |
| | | 16 | | |
| | 0 | 17 | | public bool IsRemote => _decoratee.IsRemote; |
| | | 18 | | |
| | 13 | 19 | | public bool IsStarted => _decoratee.IsStarted; |
| | | 20 | | |
| | 2266 | 21 | | public Task WritesClosed => _decoratee.WritesClosed; |
| | | 22 | | |
| | 2239 | 23 | | public PipeReader Input => _input ?? _decoratee.Input; |
| | | 24 | | |
| | 3282 | 25 | | public PipeWriter Output => _output ?? _decoratee.Output; |
| | | 26 | | |
| | | 27 | | private readonly IMultiplexedStream _decoratee; |
| | | 28 | | private readonly PipeReader? _input; |
| | | 29 | | private readonly PipeWriter? _output; |
| | | 30 | | |
| | | 31 | | /// <summary>Constructs a multiplexed stream decorator.</summary> |
| | | 32 | | /// <param name="decoratee">The decoratee.</param> |
| | | 33 | | /// <param name="onCompleted">An action that is executed when stream input or output is completed; it's executed |
| | | 34 | | /// up to 2 times for a bidirectional stream, and up to 1 time for a unidirectional stream.</param> |
| | 2861 | 35 | | internal MultiplexedStreamDecorator(IMultiplexedStream decoratee, Action onCompleted) |
| | 2861 | 36 | | { |
| | 2861 | 37 | | _decoratee = decoratee; |
| | | 38 | | |
| | 2861 | 39 | | if (decoratee.IsBidirectional || decoratee.IsRemote) |
| | 1850 | 40 | | { |
| | 1850 | 41 | | _input = new InputDecorator(decoratee.Input, onCompleted); |
| | 1850 | 42 | | } |
| | 2861 | 43 | | if (decoratee.IsBidirectional || !decoratee.IsRemote) |
| | 1852 | 44 | | { |
| | 1852 | 45 | | _output = new OutputDecorator((ReadOnlySequencePipeWriter)decoratee.Output, onCompleted); |
| | 1852 | 46 | | } |
| | 2861 | 47 | | } |
| | | 48 | | |
| | | 49 | | private class InputDecorator : PipeReader |
| | | 50 | | { |
| | | 51 | | private readonly PipeReader _decoratee; |
| | | 52 | | private bool _isCompleted; |
| | | 53 | | private readonly Action _onCompleted; |
| | | 54 | | |
| | | 55 | | public override void AdvanceTo(SequencePosition consumed) => |
| | 1911 | 56 | | _decoratee.AdvanceTo(consumed); |
| | | 57 | | |
| | | 58 | | public override void AdvanceTo(SequencePosition consumed, SequencePosition examined) => |
| | 5 | 59 | | _decoratee.AdvanceTo(consumed, examined); |
| | | 60 | | |
| | | 61 | | // When leaveOpen is false, we use the default implementation of AsStream: we want the disposal of the stream |
| | | 62 | | // to call Complete on this decorator. |
| | | 63 | | public override Stream AsStream(bool leaveOpen = false) => |
| | 4 | 64 | | leaveOpen ? _decoratee.AsStream(leaveOpen) : base.AsStream(leaveOpen); |
| | | 65 | | |
| | 0 | 66 | | public override void CancelPendingRead() => _decoratee.CancelPendingRead(); |
| | | 67 | | |
| | | 68 | | public override void Complete(Exception? exception = null) |
| | 1882 | 69 | | { |
| | 1882 | 70 | | if (!_isCompleted) |
| | 1846 | 71 | | { |
| | 1846 | 72 | | _isCompleted = true; |
| | 1846 | 73 | | _decoratee.Complete(exception); |
| | 1846 | 74 | | _onCompleted(); |
| | 1846 | 75 | | } |
| | 1882 | 76 | | } |
| | | 77 | | |
| | | 78 | | public override Task CopyToAsync(PipeWriter destination, CancellationToken cancellationToken = default) => |
| | 0 | 79 | | _decoratee.CopyToAsync(destination, cancellationToken); |
| | | 80 | | |
| | | 81 | | public override Task CopyToAsync(Stream destination, CancellationToken cancellationToken = default) => |
| | 0 | 82 | | _decoratee.CopyToAsync(destination, cancellationToken); |
| | | 83 | | |
| | | 84 | | public override ValueTask<ReadResult> ReadAsync(CancellationToken cancellationToken = default) => |
| | 1867 | 85 | | _decoratee.ReadAsync(cancellationToken); |
| | | 86 | | |
| | 76 | 87 | | public override bool TryRead(out ReadResult result) => _decoratee.TryRead(out result); |
| | | 88 | | |
| | | 89 | | protected override ValueTask<ReadResult> ReadAtLeastAsyncCore( |
| | | 90 | | int minimumSize, |
| | 26 | 91 | | CancellationToken cancellationToken) => _decoratee.ReadAtLeastAsync(minimumSize, cancellationToken); |
| | | 92 | | |
| | 1850 | 93 | | internal InputDecorator(PipeReader decoratee, Action onCompleted) |
| | 1850 | 94 | | { |
| | 1850 | 95 | | _decoratee = decoratee; |
| | 1850 | 96 | | _onCompleted = onCompleted; |
| | 1850 | 97 | | } |
| | | 98 | | } |
| | | 99 | | |
| | | 100 | | private class OutputDecorator : ReadOnlySequencePipeWriter |
| | | 101 | | { |
| | 0 | 102 | | public override bool CanGetUnflushedBytes => _decoratee.CanGetUnflushedBytes; |
| | | 103 | | |
| | 3682 | 104 | | public override long UnflushedBytes => _decoratee.UnflushedBytes; |
| | | 105 | | |
| | | 106 | | private readonly ReadOnlySequencePipeWriter _decoratee; |
| | | 107 | | private bool _isCompleted; |
| | | 108 | | private readonly Action _onCompleted; |
| | | 109 | | |
| | 8560 | 110 | | public override void Advance(int bytes) => _decoratee.Advance(bytes); |
| | | 111 | | |
| | | 112 | | // When leaveOpen is false, we use the default implementation of AsStream: we want the disposal of the stream |
| | | 113 | | // to call Complete on this decorator. |
| | | 114 | | public override Stream AsStream(bool leaveOpen = false) => |
| | 4 | 115 | | leaveOpen ? _decoratee.AsStream(leaveOpen) : base.AsStream(leaveOpen); |
| | | 116 | | |
| | 0 | 117 | | public override void CancelPendingFlush() => _decoratee.CancelPendingFlush(); |
| | | 118 | | |
| | | 119 | | public override void Complete(Exception? exception = null) |
| | 1856 | 120 | | { |
| | 1856 | 121 | | if (!_isCompleted) |
| | 1852 | 122 | | { |
| | 1852 | 123 | | _isCompleted = true; |
| | 1852 | 124 | | _decoratee.Complete(exception); |
| | 1852 | 125 | | _onCompleted(); |
| | 1852 | 126 | | } |
| | 1856 | 127 | | } |
| | | 128 | | |
| | | 129 | | public override ValueTask<FlushResult> FlushAsync(CancellationToken cancellationToken = default) => |
| | 9 | 130 | | _decoratee.FlushAsync(cancellationToken); |
| | | 131 | | |
| | 0 | 132 | | public override Memory<byte> GetMemory(int sizeHint = 0) => _decoratee.GetMemory(sizeHint); |
| | | 133 | | |
| | 8562 | 134 | | public override Span<byte> GetSpan(int sizeHint = 0) => _decoratee.GetSpan(sizeHint); |
| | | 135 | | |
| | | 136 | | public override ValueTask<FlushResult> WriteAsync( |
| | | 137 | | ReadOnlyMemory<byte> source, |
| | 8 | 138 | | CancellationToken cancellationToken = default) => _decoratee.WriteAsync(source, cancellationToken); |
| | | 139 | | |
| | | 140 | | public override ValueTask<FlushResult> WriteAsync( |
| | | 141 | | ReadOnlySequence<byte> source, |
| | | 142 | | bool endStream, |
| | | 143 | | CancellationToken cancellationToken = default) => |
| | 1832 | 144 | | _decoratee.WriteAsync(source, endStream, cancellationToken); |
| | | 145 | | |
| | 1852 | 146 | | internal OutputDecorator(ReadOnlySequencePipeWriter decoratee, Action onCompleted) |
| | 1852 | 147 | | { |
| | 1852 | 148 | | _decoratee = decoratee; |
| | 1852 | 149 | | _onCompleted = onCompleted; |
| | 1852 | 150 | | } |
| | | 151 | | } |
| | | 152 | | } |