public static async Task CopyToAsync(this Stream stream, IWritableChannel channel)
{
while (true)
{
var end = channel.BeginWrite();
var block = end.Block;
try
{
int bytesRead = await stream.ReadAsync(block.Array, block.End, block.Data.Offset + block.Data.Count - block.End);
if (bytesRead == 0)
{
channel.CompleteWriting();
break;
}
else
{
end.UpdateEnd(bytesRead);
await channel.EndWriteAsync(end);
}
}
catch (Exception error)
{
channel.CompleteWriting(error);
break;
}
}
}
public static async Task CopyToAsync(this Stream stream, IWritableChannel channel)
{
while (true)
{
var buffer = channel.Alloc(2048);
try
{
int bytesRead = await stream.ReadAsync(buffer.Memory.Array, buffer.Memory.Offset, buffer.Memory.Length);
if (bytesRead == 0)
{
channel.CompleteWriting();
break;
}
else
{
buffer.UpdateWritten(bytesRead);
await channel.WriteAsync(buffer);
}
}
catch (Exception error)
{
channel.CompleteWriting(error);
break;
}
}
}
public static async Task CopyToAsync(this Stream stream, IWritableChannel channel)
{
byte[] managed = null;
while (true)
{
var buffer = channel.Alloc(2048);
try
{
ArraySegment <byte> data;
unsafe
{
if (!buffer.Memory.TryGetArray(null, out data))
{
// The span is backed by native memory so we need to use a managed array to read
// from the stream and copy that back to the native buffer
if (managed == null)
{
managed = new byte[2048];
}
data = new ArraySegment <byte>(managed);
}
}
int bytesRead = await stream.ReadAsync(data.Array, data.Offset, data.Count);
if (managed != null)
{
buffer.Write(new Span <byte>(managed, 0, bytesRead));
}
else
{
buffer.CommitBytes(bytesRead);
}
if (bytesRead == 0)
{
channel.CompleteWriting();
break;
}
else
{
await buffer.FlushAsync();
}
}
catch (Exception error)
{
channel.CompleteWriting(error);
break;
}
}
}
private static async Task ProcessClient <TContext>(IHttpApplication <TContext> application, IReadableChannel input, IWritableChannel output)
{
var connection = new HttpConnection <TContext>(application, input, output);
await connection.ProcessAllRequests();
output.CompleteWriting();
input.CompleteReading();
}
public async Task Execute(IReadableChannel input, IWritableChannel output)
{
while (true)
{
var inputBuffer = await input.ReadAsync();
if (inputBuffer.IsEmpty && input.Completion.IsCompleted)
{
break;
}
var writerBuffer = output.Alloc(2048);
var span = inputBuffer.FirstSpan;
if (span.Length > 0)
{
unsafe
{
_inflater.SetInput((IntPtr)span.UnsafePointer, span.Length);
int written = _inflater.Inflate((IntPtr)writerBuffer.Memory.UnsafePointer, writerBuffer.Memory.Length);
writerBuffer.CommitBytes(written);
var consumed = span.Length - _inflater.AvailableInput;
inputBuffer = inputBuffer.Slice(0, consumed);
}
}
inputBuffer.Consumed();
await writerBuffer.FlushAsync();
}
input.CompleteReading();
output.CompleteWriting();
_inflater.Dispose();
}
public async Task Execute(IReadableChannel input, IWritableChannel output)
{
while (true)
{
await input;
var inputBuffer = input.BeginRead();
if (inputBuffer.IsEmpty && input.Completion.IsCompleted)
{
break;
}
var writerBuffer = output.Alloc(2048);
var span = inputBuffer.FirstSpan;
if (span.Length > 0)
{
_inflater.SetInput(span.BufferPtr, span.Length);
int written = _inflater.Inflate(writerBuffer.Memory.BufferPtr, writerBuffer.Memory.Length);
writerBuffer.UpdateWritten(written);
var consumed = span.Length - _inflater.AvailableInput;
inputBuffer = inputBuffer.Slice(0, consumed);
}
input.EndRead(inputBuffer);
await output.WriteAsync(writerBuffer);
}
input.CompleteReading();
output.CompleteWriting();
_inflater.Dispose();
}
public async Task Execute(IReadableChannel input, IWritableChannel output)
{
while (true)
{
var inputBuffer = await input;
if (inputBuffer.IsEmpty && input.Completion.IsCompleted)
{
break;
}
var writerBuffer = output.Alloc(2048);
var span = inputBuffer.FirstSpan;
_deflater.SetInput(span.BufferPtr, span.Length);
while (!_deflater.NeedsInput())
{
int written = _deflater.ReadDeflateOutput(writerBuffer.Memory.BufferPtr, writerBuffer.Memory.Length);
writerBuffer.CommitBytes(written);
}
var consumed = span.Length - _deflater.AvailableInput;
inputBuffer = inputBuffer.Slice(0, consumed);
inputBuffer.Consumed();
await writerBuffer.FlushAsync();
}
bool flushed;
do
{
// Need to do more stuff here
var writerBuffer = output.Alloc(2048);
int compressedBytes;
flushed = _deflater.Flush(writerBuffer.Memory.BufferPtr, writerBuffer.Memory.Length, out compressedBytes);
writerBuffer.CommitBytes(compressedBytes);
await writerBuffer.FlushAsync();
}while (flushed);
bool finished;
do
{
// Need to do more stuff here
var writerBuffer = output.Alloc(2048);
int compressedBytes;
finished = _deflater.Finish(writerBuffer.Memory.BufferPtr, writerBuffer.Memory.Length, out compressedBytes);
writerBuffer.CommitBytes(compressedBytes);
await writerBuffer.FlushAsync();
}while (!finished);
input.CompleteReading();
output.CompleteWriting();
_deflater.Dispose();
}