public async Task <int> WriteAsync(byte[] buffer, int offset, int length, StreamMode mode)
{
Utilities.DebugCheckStreamArguments(buffer, offset, length, mode);
int result = 0;
for (;;)
{
if (mOffset == 16)
{
mEncoder.TransformBlock(mBuffer1, 0, 16, mBuffer2, 0);
var written = await mOutput.WriteAsync(mBuffer2, 0, 16, StreamMode.Complete).ConfigureAwait(false);
System.Diagnostics.Debug.Assert(written == 16);
mOffset = 0;
}
int copy = Math.Min(16 - mOffset, length);
System.Diagnostics.Debug.Assert(copy > 0);
Buffer.BlockCopy(buffer, offset, mBuffer1, mOffset, copy);
mOffset += copy;
result += copy;
offset += copy;
length -= copy;
if (length == 0 || mode == StreamMode.Partial)
{
return(result);
}
}
}
private async Task TransferLoop()
{
System.Diagnostics.Debug.WriteLine("PERF: EncoderConnection enters transfer loop. Avoid this if possible.");
var buffer = new byte[0x10000];
var offset = 0;
var ending = 0;
for (;;)
{
if (!mComplete && ending < buffer.Length)
{
var fetched = await mEncoderOutputToConnectionInput.ReadAsync(buffer, ending, buffer.Length - ending, StreamMode.Partial).ConfigureAwait(false);
System.Diagnostics.Debug.Assert(0 <= fetched && fetched <= buffer.Length - ending);
if (fetched == 0)
{
mComplete = true;
}
else
{
ending += fetched;
}
}
if (offset < ending)
{
var written = await mConnectionOutputToEncoderInput.WriteAsync(buffer, offset, ending - offset, StreamMode.Partial).ConfigureAwait(false);
System.Diagnostics.Debug.Assert(0 < written && written <= ending - offset);
offset += written;
}
if (offset == ending)
{
offset = 0;
ending = 0;
if (mComplete)
{
await mConnectionOutputToEncoderInput.CompleteAsync().ConfigureAwait(false);
return;
}
}
}
}
private async Task TransferLoop()
{
System.Diagnostics.Debug.WriteLine("PERF: EncoderInput enters transfer loop. Avoid this if possible.");
var buffer = new byte[0x10000];
for (;;)
{
var fetched = await mSession.ReadInternalAsync(buffer, 0, buffer.Length, StreamMode.Partial).ConfigureAwait(false);
System.Diagnostics.Debug.Assert(0 <= fetched && fetched <= buffer.Length);
if (fetched == 0)
{
await mEncoderInput.CompleteAsync().ConfigureAwait(false);
return;
}
var written = await mEncoderInput.WriteAsync(buffer, 0, fetched, StreamMode.Complete).ConfigureAwait(false);
System.Diagnostics.Debug.Assert(written == fetched);
mLength += written;
mChecksum = CRC.Update(mChecksum, buffer, 0, written);
}
}
public override async Task <NetStreamResult> Execute(IConsumeContext <TKey, TMessage> consumeContext, CancellationToken token, NetStreamResult result)
{
if (result != null && result.HasValue && _writer != null)
{
await _writer.WriteAsync(result);
}
return(await base.Next.Execute(consumeContext, token, result));
}
public Task <StreamResponse> WriteToStreamAsync(
StreamId streamId,
IReadOnlyCollection <object> events,
StreamVersion?version = default,
StreamWriteOptions?options = default,
CancellationToken cancellationToken = default)
=> streamWriter
.WriteAsync(
streamId,
Arguments.EnsureNoNullValues(events, nameof(events)),
version ?? StreamVersion.Any,
options,
cancellationToken);
long LZMA.Master.LZMA.ISeqOutStream.Write(LZMA.P <byte> buf, long size)
{
System.Diagnostics.Debug.Assert(size > 0);
var buffer = buf.mBuffer;
var offset = buf.mOffset;
var result = size;
while (size > Int32.MaxValue)
{
int written;
try { written = mStream.WriteAsync(buffer, offset, Int32.MaxValue, StreamMode.Partial).GetAwaiter().GetResult(); }
catch (OperationCanceledException) { return(0); }
if (written <= 0)
{
throw new InvalidOperationException("IOutputStream.WriteAsync returned an invalid result.");
}
offset += written;
size -= written;
}
if (size > 0)
{
int written;
try { written = mStream.WriteAsync(buffer, offset, (int)size, StreamMode.Complete).GetAwaiter().GetResult(); }
catch (OperationCanceledException) { return(0); }
if (written != size)
{
throw new InvalidOperationException("IOutputStream.WriteAsync returned an invalid result.");
}
}
return(result);
}
public async Task Handle(IConsumeContext <TKey, TMessage> consumeContext)
{
var response = _handle(consumeContext);
await _writer.WriteAsync(response);
}
