public PipeWriterCompletionWatcherTests(ITestOutputHelper logger) : base(logger) { this.monitored = this.writer.OnCompleted(this.OnCompleted, this.state); }
public ExceptionConvertingPipeWriter(PipeWriter output) => _output = output;
protected static async Task FlushAsync(PipeWriter writableBuffer) { await writableBuffer.FlushAsync().AsTask().DefaultTimeout(); }
static ValueTask <FlushResult> WriteMessagesAsync( PipeWriter writer, string message) => writer.WriteAsync(Encoding.ASCII.GetBytes(message));
private async Task Updates(PipeWriter pipeWriter, int count) { OutputUpdates(pipeWriter, await Db.LoadMultipleUpdatesRows(count)); }
public void ThrowsOnAdvanceWithNoMemory() { PipeWriter buffer = Pipe.Writer; Assert.Throws <ArgumentOutOfRangeException>(() => buffer.Advance(1)); }
private void WriteBuffer(PipeWriter writer, ReadOnlyMemory <byte> buffer) { CheckChannelOpen(); writer.Write(buffer.Span); }
protected async override ValueTask <WriteResult> WritePayloadAsync(PipeWriter pw, CancellationToken cancellationToken) { await pw.WriteAsync(_memory).AsNonGenericValueTask(); return(WriteResult.Written); }
/// <summary> /// Initializes a new instance of the <see cref="PipelinedSimpleModulusEncryptor"/> class. /// </summary> /// <param name="target">The target pipe writer.</param> /// <param name="encryptionKeys">The encryption keys.</param> public PipelinedSimpleModulusEncryptor(PipeWriter target, uint[] encryptionKeys) : this(target, SimpleModulusKeys.CreateEncryptionKeys(encryptionKeys)) { }
protected virtual async Task FillPipeAsync(PipeWriter writer) { var options = Options; var cts = _cts; var supplyController = _packagePipe as ISupplyController; if (supplyController != null) { cts.Token.Register(() => { supplyController.SupplyEnd(); }); } while (!cts.IsCancellationRequested) { try { if (supplyController != null) { await supplyController.SupplyRequired(); if (cts.IsCancellationRequested) { break; } } var bufferSize = options.ReceiveBufferSize; var maxPackageLength = options.MaxPackageLength; if (bufferSize <= 0) { bufferSize = 1024 * 4; //4k } var memory = writer.GetMemory(bufferSize); var bytesRead = await FillPipeWithDataAsync(memory, cts.Token); if (bytesRead == 0) { if (!CloseReason.HasValue) { CloseReason = Channel.CloseReason.RemoteClosing; } break; } LastActiveTime = DateTimeOffset.Now; // Tell the PipeWriter how much was read writer.Advance(bytesRead); } catch (Exception e) { if (!IsIgnorableException(e)) { OnError("Exception happened in ReceiveAsync", e); if (!CloseReason.HasValue) { CloseReason = cts.IsCancellationRequested ? Channel.CloseReason.LocalClosing : Channel.CloseReason.SocketError; } } else if (!CloseReason.HasValue) { CloseReason = Channel.CloseReason.RemoteClosing; } break; } // Make the data available to the PipeReader var result = await writer.FlushAsync(); if (result.IsCompleted) { break; } } // Signal to the reader that we're done writing writer.Complete(); Out.Writer.Complete();// TODO: should complete the output right now? }
/// <summary> /// Initializes a new instance of the <see cref="PipelinedSimpleModulusEncryptor"/> class. /// </summary> /// <param name="target">The target pipe writer.</param> public PipelinedSimpleModulusEncryptor(PipeWriter target) : this(target, DefaultServerKey) { }
public CharWriter(PipeWriter inner) { Inner = inner; }
/// <summary> /// Initializes a new instance of the <see cref="DuplexPipe"/> class /// that only allows writing. The <see cref="Input"/> property will report completed reading. /// </summary> /// <param name="output">The writer.</param> public DuplexPipe(PipeWriter output) : this(input : null, output) { }
private static async Task WriteMessageCoreAsyncAwaited(this PipeWriter pipeWriter, byte[] messageData, HttpContextServerCallContext serverCallContext, bool flush, Task startAsyncTask) { await startAsyncTask; await pipeWriter.WriteMessageCoreAsync(messageData, serverCallContext, flush); }
private void WritePackageWithEncoder <TPackage>(PipeWriter writer, IPackageEncoder <TPackage> packageEncoder, TPackage package) { CheckChannelOpen(); packageEncoder.Encode(writer, package); }
private async Task Fortunes(PipeWriter pipeWriter) { OutputFortunes(pipeWriter, await Db.LoadFortunesRows()); }
public CompletionPipeWriter(PipeWriter inner) { _inner = inner; }
public DuplexPipe(PipeReader reader, PipeWriter writer) { Input = reader; Output = writer; }
public MockDuplexPipe(PipeReader input, PipeWriter output) { Input = input; Output = output; }
public static PipeWriter WriteEmpty(this PipeWriter Writer, int count) { Writer.GetSpan(count).Slice(0, count).Fill(0); Writer.Advance(count); return(Writer); }
/// <summary> /// Initializes a new instance of the <see cref="PipeMessageHandler"/> class. /// </summary> /// <param name="writer">The writer to use for transmitting messages.</param> /// <param name="reader">The reader to use for receiving messages.</param> /// <param name="formatter">The formatter used to serialize messages.</param> public PipeMessageHandler(PipeWriter writer, PipeReader reader, IJsonRpcMessageFormatter formatter) : base(formatter) { this.Reader = reader; this.Writer = writer; }
Task IAsyncBinaryReader.CopyToAsync(PipeWriter output, CancellationToken token) => input.CopyToAsync(output, token);
async Task FlushAsync(PipeWriter buffer) { await buffer.FlushAsync(); }
async Task CopyDataAsync(CachedResponseBody body, PipeWriter writer, CancellationToken cancellationToken) { await body.CopyToAsync(writer, cancellationToken); await writer.CompleteAsync(); }
protected virtual void ConfigureServerInputOutput(PipeReader clientOutput, PipeWriter serverInput, DebugAdapterServerOptions options) => options.WithInput(clientOutput).WithOutput(serverInput);
public PassThroughPipeWriter(PipeWriter output) { _output = output; }
private static BufferWriter <WriterAdapter> GetWriter(PipeWriter pipeWriter) => new BufferWriter <WriterAdapter>(new WriterAdapter(pipeWriter));
/// <inheritdoc /> public IPipelinedEncryptor CreateEncryptor(PipeWriter target) { // At least until season 6, there is no encryption from server to client. // ex700 may require packet twister here. return(null); }
public WriterAdapter(PipeWriter writer) => Writer = writer;
public static void CreatePipe(out Stream reader, out Stream writer) { RubyPipe pipe = new RubyPipe(); reader = pipe; writer = new PipeWriter(pipe); }
/// <summary> /// Initializes a new instance of the <see cref="PipelinedXor32Encryptor"/> class. /// </summary> /// <param name="target">The target.</param> public PipelinedXor32Encryptor(PipeWriter target) : this(target, DefaultKeys.Xor32Key) { }