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)
{
}
