public IPipelineReader CreateReader(IPipelineReader reader, Func <IPipelineReader, IPipelineWriter, Task> produce)
{
var newReader = new PipelineReaderWriter(_pool);
Execute(reader, newReader, produce);
return(newReader);
}
private static async Task <int> ReadAsyncAwaited(this IPipelineReader input, Span <byte> destination)
{
while (true)
{
var result = await input.ReadAsync();
var inputBuffer = result.Buffer;
var fin = result.IsCompleted;
var sliced = inputBuffer.Slice(0, destination.Length);
sliced.CopyTo(destination);
int actual = sliced.Length;
input.Advance(sliced.End);
if (actual != 0)
{
return(actual);
}
else if (fin)
{
return(0);
}
}
}
public static async Task CopyToAsync(this IPipelineReader input, IPipelineWriter output)
{
while (true)
{
var result = await input.ReadAsync();
var inputBuffer = result.Buffer;
var fin = result.IsCompleted;
try
{
if (inputBuffer.IsEmpty && fin)
{
return;
}
var buffer = output.Alloc();
buffer.Append(inputBuffer);
await buffer.FlushAsync();
}
finally
{
input.Advance(inputBuffer.End);
}
}
}
public static ValueTask <int> ReadAsync(this IPipelineReader input, Span <byte> destination)
{
while (true)
{
var awaiter = input.ReadAsync();
if (!awaiter.IsCompleted)
{
break;
}
var result = awaiter.GetResult();
var inputBuffer = result.Buffer;
var fin = result.IsCompleted;
var sliced = inputBuffer.Slice(0, destination.Length);
sliced.CopyTo(destination);
int actual = sliced.Length;
input.Advance(sliced.End);
if (actual != 0)
{
return(new ValueTask <int>(actual));
}
else if (fin)
{
return(new ValueTask <int>(0));
}
}
return(new ValueTask <int>(input.ReadAsyncAwaited(destination)));
}
private async void Consume(IPipelineReader input)
{
while (true)
{
var result = await input.ReadAsync();
var buffer = result.Buffer;
try
{
if (buffer.IsEmpty && result.IsCompleted)
{
break;
}
await WriteAsync(buffer);
}
finally
{
input.Advance(buffer.End);
}
}
input.Complete();
}
public IPipelineReader CreateReader(IPipelineReader reader, Func <IPipelineReader, IPipelineWriter, Task> produce)
{
var pipe = new Pipe(_pool);
Execute(reader, pipe, produce);
return(pipe);
}
public HttpConnection(IHttpApplication <TContext> application, IPipelineReader input, IPipelineWriter output)
{
_application = application;
_input = input;
_output = output;
_requestBody = new HttpRequestStream <TContext>(this);
_responseBody = new HttpResponseStream <TContext>(this);
}
public static async Task <ReadableBuffer> ReadToEndAsync(this IPipelineReader input)
{
while (true)
{
// Wait for more data
var result = await input.ReadAsync();
if (result.IsCompleted)
{
// Read all the data, return it
return(result.Buffer);
}
// Don't advance the buffer so remains in buffer
input.Advance(result.Buffer.Start, result.Buffer.End);
}
}
private static async Task CopyCompletedAsync(IPipelineReader input, IPipelineWriter output)
{
var result = await input.ReadAsync();
var inputBuffer = result.Buffer;
while (true)
{
try
{
if (inputBuffer.IsEmpty && result.IsCompleted)
{
return;
}
var buffer = output.Alloc();
buffer.Append(inputBuffer);
await buffer.FlushAsync();
}
finally
{
input.Advance(inputBuffer.End);
}
var awaiter = input.ReadAsync();
if (!awaiter.IsCompleted)
{
// No more data
break;
}
result = await input.ReadAsync();
inputBuffer = result.Buffer;
}
}
public static async Task CopyToAsync(this IPipelineReader input, Stream stream, int bufferSize, CancellationToken cancellationToken)
{
// TODO: Use bufferSize argument
while (!cancellationToken.IsCancellationRequested)
{
var result = await input.ReadAsync();
var inputBuffer = result.Buffer;
try
{
if (inputBuffer.IsEmpty && result.IsCompleted)
{
return;
}
await inputBuffer.CopyToAsync(stream);
}
finally
{
input.Advance(inputBuffer.End);
}
}
}
private static async Task CopyCompletedAsync(IPipelineReader input, IPipelineWriter output)
{
var result = await input.ReadAsync();
var inputBuffer = result.Buffer;
while (true)
{
try
{
if (inputBuffer.IsEmpty && result.IsCompleted)
{
return;
}
var buffer = output.Alloc();
buffer.Append(inputBuffer);
await buffer.FlushAsync();
}
finally
{
input.Advance(inputBuffer.End);
}
var awaiter = input.ReadAsync();
if (!awaiter.IsCompleted)
{
// No more data
break;
}
result = await input.ReadAsync();
inputBuffer = result.Buffer;
}
}
private async void Consume(IPipelineReader input)
{
while (true)
{
var result = await input.ReadAsync();
var buffer = result.Buffer;
try
{
if (buffer.IsEmpty && result.IsCompleted)
{
break;
}
await WriteAsync(buffer);
}
finally
{
input.Advance(buffer.End);
}
}
input.Complete();
}
public static IPipelineReader CreateGZipCompressReader(this PipelineFactory factory, IPipelineReader reader, CompressionLevel compressionLevel)
{
var deflater = new WritableDeflateTransform(compressionLevel, ZLibNative.GZip_DefaultWindowBits);
return(factory.CreateReader(reader, deflater.Execute));
}
public static IPipelineReader CreateGZipDecompressReader(this PipelineFactory factory, IPipelineReader reader)
{
var inflater = new ReadableDeflateTransform(ZLibNative.GZip_DefaultWindowBits);
return(factory.CreateReader(reader, inflater.Execute));
}
public async Task Execute(IPipelineReader reader, IPipelineWriter writer)
{
while (true)
{
var result = await reader.ReadAsync();
var inputBuffer = result.Buffer;
if (inputBuffer.IsEmpty)
{
if (result.IsCompleted)
{
break;
}
reader.Advance(inputBuffer.End);
continue;
}
var writerBuffer = writer.Alloc();
var memory = inputBuffer.First;
if (memory.Length > 0)
{
unsafe
{
void *pointer;
if (memory.TryGetPointer(out pointer))
{
_inflater.SetInput((IntPtr)pointer, memory.Length);
void *writePointer;
writerBuffer.Ensure();
if (writerBuffer.Memory.TryGetPointer(out writePointer))
{
int written = _inflater.Inflate((IntPtr)writePointer, writerBuffer.Memory.Length);
writerBuffer.Advance(written);
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
var consumed = memory.Length - _inflater.AvailableInput;
inputBuffer = inputBuffer.Slice(0, consumed);
}
}
reader.Advance(inputBuffer.End);
await writerBuffer.FlushAsync();
}
reader.Complete();
writer.Complete();
_inflater.Dispose();
}
public static IPipelineReader DeflateDecompress(this IPipelineReader reader, PipelineFactory factory)
{
var inflater = new ReadableDeflateTransform(ZLibNative.Deflate_DefaultWindowBits);
return(factory.CreateReader(reader, inflater.Execute));
}
public PipelineHttpContent(IPipelineReader output)
{
_output = output;
}
private async void Execute(IPipelineReader reader, Pipe pipe, Func <IPipelineReader, IPipelineWriter, Task> produce)
{
await pipe.ReadingStarted;
await produce(reader, pipe);
}
private async void Execute(IPipelineReader reader, PipelineReaderWriter writer, Func<IPipelineReader, IPipelineWriter, Task> produce)
{
await writer.ReadingStarted;
await produce(reader, writer);
}
public static IPipelineReader CreateGZipDecompressReader(this PipelineFactory factory, IPipelineReader reader)
{
var inflater = new ReadableDeflateTransform(ZLibNative.GZip_DefaultWindowBits);
return factory.CreateReader(reader, inflater.Execute);
}
public async Task Execute(IPipelineReader reader, IPipelineWriter writer)
{
while (true)
{
var result = await reader.ReadAsync();
var inputBuffer = result.Buffer;
if (inputBuffer.IsEmpty)
{
if (result.IsCompleted)
{
break;
}
reader.Advance(inputBuffer.End);
continue;
}
var writerBuffer = writer.Alloc();
var memory = inputBuffer.First;
if (memory.Length > 0)
{
unsafe
{
void* pointer;
if (memory.TryGetPointer(out pointer))
{
_inflater.SetInput((IntPtr)pointer, memory.Length);
void* writePointer;
writerBuffer.Ensure();
if (writerBuffer.Memory.TryGetPointer(out writePointer))
{
int written = _inflater.Inflate((IntPtr)writePointer, writerBuffer.Memory.Length);
writerBuffer.Advance(written);
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
var consumed = memory.Length - _inflater.AvailableInput;
inputBuffer = inputBuffer.Slice(0, consumed);
}
}
reader.Advance(inputBuffer.End);
await writerBuffer.FlushAsync();
}
reader.Complete();
writer.Complete();
_inflater.Dispose();
}
public static void Advance(this IPipelineReader input, ReadCursor cursor)
{
input.Advance(cursor, cursor);
}
public static Task CopyToAsync(this IPipelineReader input, Stream stream)
{
return(input.CopyToAsync(stream, 4096, CancellationToken.None));
}
public PipelineHttpContent(IPipelineReader output)
{
_output = output;
}
public async Task Execute(IPipelineReader reader, IPipelineWriter writer)
{
while (true)
{
var result = await reader.ReadAsync();
var inputBuffer = result.Buffer;
if (inputBuffer.IsEmpty)
{
if (result.IsCompleted)
{
break;
}
reader.Advance(inputBuffer.End);
continue;
}
var writerBuffer = writer.Alloc();
var memory = inputBuffer.First;
unsafe
{
// TODO: Pin pointer if not pinned
void *inPointer;
if (memory.TryGetPointer(out inPointer))
{
_deflater.SetInput((IntPtr)inPointer, memory.Length);
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
}
while (!_deflater.NeedsInput())
{
unsafe
{
void *outPointer;
writerBuffer.Ensure();
if (writerBuffer.Memory.TryGetPointer(out outPointer))
{
int written = _deflater.ReadDeflateOutput((IntPtr)outPointer, writerBuffer.Memory.Length);
writerBuffer.Advance(written);
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
}
}
var consumed = memory.Length - _deflater.AvailableInput;
inputBuffer = inputBuffer.Slice(0, consumed);
reader.Advance(inputBuffer.End);
await writerBuffer.FlushAsync();
}
bool flushed = false;
do
{
// Need to do more stuff here
var writerBuffer = writer.Alloc();
unsafe
{
void *pointer;
writerBuffer.Ensure();
var memory = writerBuffer.Memory;
if (memory.TryGetPointer(out pointer))
{
int compressedBytes;
flushed = _deflater.Flush((IntPtr)pointer, memory.Length, out compressedBytes);
writerBuffer.Advance(compressedBytes);
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
}
await writerBuffer.FlushAsync();
}while (flushed);
bool finished = false;
do
{
// Need to do more stuff here
var writerBuffer = writer.Alloc();
unsafe
{
void *pointer;
writerBuffer.Ensure();
var memory = writerBuffer.Memory;
if (memory.TryGetPointer(out pointer))
{
int compressedBytes;
finished = _deflater.Finish((IntPtr)pointer, memory.Length, out compressedBytes);
writerBuffer.Advance(compressedBytes);
}
}
await writerBuffer.FlushAsync();
}while (!finished);
reader.Complete();
writer.Complete();
_deflater.Dispose();
}
public IPipelineReader CreateReader(IPipelineReader reader, Func<IPipelineReader, IPipelineWriter, Task> produce)
{
var newReader = new PipelineReaderWriter(_pool);
Execute(reader, newReader, produce);
return newReader;
}
public static IPipelineReader CreateGZipCompressReader(this PipelineFactory factory, IPipelineReader reader, CompressionLevel compressionLevel)
{
var deflater = new WritableDeflateTransform(compressionLevel, ZLibNative.GZip_DefaultWindowBits);
return factory.CreateReader(reader, deflater.Execute);
}
public async Task Execute(IPipelineReader reader, IPipelineWriter writer)
{
while (true)
{
var result = await reader.ReadAsync();
var inputBuffer = result.Buffer;
if (inputBuffer.IsEmpty)
{
if (result.IsCompleted)
{
break;
}
reader.Advance(inputBuffer.End);
continue;
}
var writerBuffer = writer.Alloc();
var memory = inputBuffer.First;
unsafe
{
// TODO: Pin pointer if not pinned
void* inPointer;
if (memory.TryGetPointer(out inPointer))
{
_deflater.SetInput((IntPtr)inPointer, memory.Length);
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
}
while (!_deflater.NeedsInput())
{
unsafe
{
void* outPointer;
writerBuffer.Ensure();
if (writerBuffer.Memory.TryGetPointer(out outPointer))
{
int written = _deflater.ReadDeflateOutput((IntPtr)outPointer, writerBuffer.Memory.Length);
writerBuffer.Advance(written);
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
}
}
var consumed = memory.Length - _deflater.AvailableInput;
inputBuffer = inputBuffer.Slice(0, consumed);
reader.Advance(inputBuffer.End);
await writerBuffer.FlushAsync();
}
bool flushed = false;
do
{
// Need to do more stuff here
var writerBuffer = writer.Alloc();
unsafe
{
void* pointer;
writerBuffer.Ensure();
var memory = writerBuffer.Memory;
if (memory.TryGetPointer(out pointer))
{
int compressedBytes;
flushed = _deflater.Flush((IntPtr)pointer, memory.Length, out compressedBytes);
writerBuffer.Advance(compressedBytes);
}
else
{
throw new InvalidOperationException("Pointer needs to be pinned");
}
}
await writerBuffer.FlushAsync();
}
while (flushed);
bool finished = false;
do
{
// Need to do more stuff here
var writerBuffer = writer.Alloc();
unsafe
{
void* pointer;
writerBuffer.Ensure();
var memory = writerBuffer.Memory;
if (memory.TryGetPointer(out pointer))
{
int compressedBytes;
finished = _deflater.Finish((IntPtr)pointer, memory.Length, out compressedBytes);
writerBuffer.Advance(compressedBytes);
}
}
await writerBuffer.FlushAsync();
}
while (!finished);
reader.Complete();
writer.Complete();
_deflater.Dispose();
}
private async void Execute(IPipelineReader reader, PipelineReaderWriter writer, Func <IPipelineReader, IPipelineWriter, Task> produce)
{
await writer.ReadingStarted;
await produce(reader, writer);
}
