public static IPipeReader DeflateDecompress(this IPipeReader reader, PipeFactory factory)
{
var inflater = new ReadableDeflateTransform(ZLibNative.Deflate_DefaultWindowBits);
var pipe = factory.Create();
var ignore = inflater.Execute(reader, pipe.Writer);
return(pipe.Reader);
}
public static IPipeReader CreateGZipCompressReader(this PipeFactory factory, IPipeReader reader, CompressionLevel compressionLevel)
{
var deflater = new WritableDeflateTransform(compressionLevel, ZLibNative.GZip_DefaultWindowBits);
var pipe = factory.Create();
var ignore = deflater.Execute(reader, pipe.Writer);
return(pipe.Reader);
}
public static IPipeReader ReadFile(this PipeFactory factory, string path)
{
var pipe = factory.Create();
var file = new FileReader(pipe.Writer);
file.OpenReadFile(path);
return(pipe.Reader);
}
public async Task ParseMessageAcrossMultipleReadsSuccess(string[] messageParts, string expectedMessage)
{
using (var pipeFactory = new PipeFactory())
{
var parser = new ServerSentEventsMessageParser();
var pipe = pipeFactory.Create();
byte[] message = null;
ReadCursor consumed = default, examined = default;
public BackpressureTests()
{
_pipeFactory = new PipeFactory();
_pipe = _pipeFactory.Create(new PipeOptions
{
MaximumSizeLow = 32,
MaximumSizeHigh = 64
});
}
public PipeTest()
{
_pipeFactory = new PipeFactory();
Pipe = _pipeFactory.Create(new PipeOptions()
{
MaximumSizeHigh = 65,
MaximumSizeLow = 6
});
}
public void EmptyWriteDoesNotThrow()
{
using (var factory = new PipeFactory())
{
var pipe = factory.Create();
var buffer = pipe.Writer.Alloc();
buffer.Write(new byte[0], 0, 0);
}
}
public void EnsureMoreThanPoolBlockSizeThrows()
{
using (var factory = new PipeFactory())
{
var pipe = factory.Create();
var buffer = pipe.Writer.Alloc();
Assert.Throws <ArgumentOutOfRangeException>(() => buffer.Ensure(8192));
}
}
public void WriteHex(int value, string hex)
{
using (var factory = new PipeFactory())
{
var pipe = factory.Create();
var buffer = pipe.Writer.Alloc();
buffer.Append(value, TextEncoder.Utf8, 'x');
Assert.Equal(hex, buffer.AsReadableBuffer().GetAsciiString());
}
}
private OutputProducer CreateOutputProducer(PipeOptions pipeOptions)
{
var pipe = _pipeFactory.Create(pipeOptions);
var serviceContext = new TestServiceContext();
var socketOutput = new OutputProducer(
pipe,
"0",
serviceContext.Log,
Mock.Of <ITimeoutControl>());
return(socketOutput);
}
public FrameConnectionTests()
{
_pipeFactory = new PipeFactory();
_frameConnectionContext = new FrameConnectionContext
{
ConnectionId = "0123456789",
ConnectionAdapters = new List <IConnectionAdapter>(),
ConnectionInformation = new MockConnectionInformation
{
PipeFactory = _pipeFactory
},
FrameConnectionId = long.MinValue,
Input = _pipeFactory.Create(),
Output = _pipeFactory.Create(),
ServiceContext = new TestServiceContext
{
SystemClock = new SystemClock()
}
};
_frameConnection = new FrameConnection(_frameConnectionContext);
}
public FrameTests()
{
_pipelineFactory = new PipeFactory();
_input = _pipelineFactory.Create();
var output = _pipelineFactory.Create();
_serviceContext = new TestServiceContext();
_timeoutControl = new Mock <ITimeoutControl>();
_frameContext = new FrameContext
{
ServiceContext = _serviceContext,
ConnectionInformation = new MockConnectionInformation
{
PipeFactory = _pipelineFactory
},
TimeoutControl = _timeoutControl.Object,
Input = _input.Reader,
Output = output
};
_frame = new TestFrame <object>(application: null, context: _frameContext);
_frame.Reset();
}
internal SocketConnection(Socket socket, PipeFactory factory)
{
socket.NoDelay = true;
_socket = socket;
if (factory == null)
{
_ownsFactory = true;
factory = new PipeFactory();
}
_factory = factory;
_input = PipeFactory.Create();
_output = PipeFactory.Create();
_receiveTask = ReceiveFromSocketAndPushToWriterAsync();
_sendTask = ReadFromReaderAndWriteToSocketAsync();
}
public async Task MultipleCompleteReaderWriterCauseDisposeOnlyOnce()
{
var pool = new DisposeTrackingBufferPool();
using (var factory = new PipeFactory(pool))
{
var readerWriter = factory.Create();
await readerWriter.Writer.WriteAsync(new byte[] { 1 });
readerWriter.Writer.Complete();
readerWriter.Reader.Complete();
Assert.Equal(1, pool.Disposed);
readerWriter.Writer.Complete();
readerWriter.Reader.Complete();
Assert.Equal(1, pool.Disposed);
}
}
public async Task FlushCallbackRunsOnWriterScheduler()
{
using (var factory = new PipeFactory())
{
using (var scheduler = new ThreadScheduler())
{
var pipe = factory.Create(new PipeOptions
{
MaximumSizeLow = 32,
MaximumSizeHigh = 64,
WriterScheduler = scheduler
});
var writableBuffer = pipe.Writer.Alloc(64);
writableBuffer.Advance(64);
var flushAsync = writableBuffer.FlushAsync();
Assert.False(flushAsync.IsCompleted);
Func <Task> doWrite = async() =>
{
var oid = Thread.CurrentThread.ManagedThreadId;
await flushAsync;
Assert.NotEqual(oid, Thread.CurrentThread.ManagedThreadId);
pipe.Writer.Complete();
Assert.Equal(Thread.CurrentThread.ManagedThreadId, scheduler.Thread.ManagedThreadId);
};
var writing = doWrite();
var result = await pipe.Reader.ReadAsync();
pipe.Reader.Advance(result.Buffer.End, result.Buffer.End);
pipe.Reader.Complete();
await writing;
}
}
}
public async Task GetUInt64GivesExpectedValues()
{
using (var factory = new PipeFactory())
{
var readerWriter = factory.Create();
var writeBuffer = readerWriter.Writer.Alloc();
writeBuffer.Ensure(50);
writeBuffer.Advance(50); // not even going to pretend to write data here - we're going to cheat
await writeBuffer.FlushAsync(); // by overwriting the buffer in-situ
// now read it back
var result = await readerWriter.Reader.ReadAsync();
var readBuffer = result.Buffer;
ReadUInt64GivesExpectedValues(ref readBuffer);
}
}
public async Task TrimEndTrimsWhitespaceAtEnd(string input, string expected)
{
using (var factory = new PipeFactory())
{
var readerWriter = factory.Create();
var writeBuffer = readerWriter.Writer.Alloc();
var bytes = Encoding.ASCII.GetBytes(input);
writeBuffer.Write(bytes);
await writeBuffer.FlushAsync();
var result = await readerWriter.Reader.ReadAsync();
var buffer = result.Buffer;
var trimmed = buffer.TrimEnd();
var outputBytes = trimmed.ToArray();
Assert.Equal(expected, Encoding.ASCII.GetString(outputBytes));
}
}
public TestInput()
{
_memoryPool = new MemoryPool();
_pipelineFactory = new PipeFactory();
Pipe = _pipelineFactory.Create();
FrameContext = new FrameContext
{
ServiceContext = new TestServiceContext(),
Input = Pipe.Reader,
ConnectionInformation = new MockConnectionInformation
{
PipeFactory = _pipelineFactory
},
TimeoutControl = Mock.Of <ITimeoutControl>()
};
Frame = new Frame <object>(null, FrameContext);
Frame.FrameControl = Mock.Of <IFrameControl>();
}
public void Setup()
{
PipeFactory = new PipeFactory();
Pipe = PipeFactory.Create();
var serviceContext = new ServiceContext
{
HttpParserFactory = f => new HttpParser <Http1ParsingHandler>(),
ServerOptions = new KestrelServerOptions(),
};
var http1ConnectionContext = new Http1ConnectionContext
{
ServiceContext = serviceContext,
ConnectionFeatures = new FeatureCollection(),
PipeFactory = PipeFactory,
TimeoutControl = new MockTimeoutControl()
};
Http1Connection = new Http1Connection <object>(application: null, context: http1ConnectionContext);
}
public async Task EqualsDetectsDeltaForAllLocations()
{
using (var factory = new PipeFactory())
{
var readerWriter = factory.Create();
// populate with dummy data
const int DataSize = 10000;
byte[] data = new byte[DataSize];
var rand = new Random(12345);
rand.NextBytes(data);
var writeBuffer = readerWriter.Writer.Alloc();
writeBuffer.Write(data);
await writeBuffer.FlushAsync();
// now read it back
var result = await readerWriter.Reader.ReadAsync();
var readBuffer = result.Buffer;
Assert.False(readBuffer.IsSingleSpan);
Assert.Equal(data.Length, readBuffer.Length);
// check the entire buffer
EqualsDetectsDeltaForAllLocations(readBuffer, data, 0, data.Length);
// check the first 32 sub-lengths
for (int i = 0; i <= 32; i++)
{
var slice = readBuffer.Slice(0, i);
EqualsDetectsDeltaForAllLocations(slice, data, 0, i);
}
// check the last 32 sub-lengths
for (int i = 0; i <= 32; i++)
{
var slice = readBuffer.Slice(data.Length - i, i);
EqualsDetectsDeltaForAllLocations(slice, data, data.Length - i, i);
}
}
}
public async Task ReadTWorksAgainstMultipleBuffers()
{
using (var factory = new PipeFactory())
{
var readerWriter = factory.Create();
var output = readerWriter.Writer.Alloc();
// we're going to try to force 3 buffers for 8 bytes
output.Write(new byte[] { 0, 1, 2 });
output.Ensure(4031);
output.Write(new byte[] { 3, 4, 5 });
output.Ensure(4031);
output.Write(new byte[] { 6, 7, 9 });
var readable = output.AsReadableBuffer();
Assert.Equal(9, readable.Length);
int spanCount = 0;
foreach (var _ in readable)
{
spanCount++;
}
Assert.Equal(3, spanCount);
byte[] local = new byte[9];
readable.CopyTo(local);
var span = new Span <byte>(local);
Assert.Equal(span.Read <byte>(), readable.ReadLittleEndian <byte>());
Assert.Equal(span.Read <sbyte>(), readable.ReadLittleEndian <sbyte>());
Assert.Equal(span.Read <short>(), readable.ReadLittleEndian <short>());
Assert.Equal(span.Read <ushort>(), readable.ReadLittleEndian <ushort>());
Assert.Equal(span.Read <int>(), readable.ReadLittleEndian <int>());
Assert.Equal(span.Read <uint>(), readable.ReadLittleEndian <uint>());
Assert.Equal(span.Read <long>(), readable.ReadLittleEndian <long>());
Assert.Equal(span.Read <ulong>(), readable.ReadLittleEndian <ulong>());
Assert.Equal(span.Read <float>(), readable.ReadLittleEndian <float>());
Assert.Equal(span.Read <double>(), readable.ReadLittleEndian <double>());
await output.FlushAsync();
}
}
public async Task WriteDuringReadIsNotReturned()
{
var pool = new DisposeTrackingBufferPool();
var writeSize = 512;
using (var factory = new PipeFactory(pool))
{
var pipe = factory.Create();
await pipe.Writer.WriteAsync(new byte[writeSize]);
var buffer = pipe.Writer.Alloc(writeSize);
var readResult = await pipe.Reader.ReadAsync();
pipe.Reader.Advance(readResult.Buffer.End);
buffer.Write(new byte[writeSize]);
buffer.Commit();
Assert.Equal(1, pool.CurrentlyRentedBlocks);
}
}
public async Task PeekWorkesWithEmptySegments()
{
using (var factory = new PipeFactory())
{
var readerWriter = factory.Create();
var w = readerWriter.Writer.Alloc();
w.Append(ReadableBuffer.Create(new byte[] { 0 }, 0, 0));
w.Append(ReadableBuffer.Create(new byte[] { 1 }, 0, 1));
await w.FlushAsync();
var result = await readerWriter.Reader.ReadAsync();
var buffer = result.Buffer;
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Peek());
Assert.Equal(1, reader.Take());
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
}
public async Task DefaultWriterSchedulerRunsInline()
{
using (var factory = new PipeFactory())
{
var pipe = factory.Create(new PipeOptions
{
MaximumSizeLow = 32,
MaximumSizeHigh = 64
});
var writableBuffer = pipe.Writer.Alloc(64);
writableBuffer.Advance(64);
var flushAsync = writableBuffer.FlushAsync();
Assert.False(flushAsync.IsCompleted);
int id = 0;
Func <Task> doWrite = async() =>
{
await flushAsync;
pipe.Writer.Complete();
Assert.Equal(Thread.CurrentThread.ManagedThreadId, id);
};
var writing = doWrite();
var result = await pipe.Reader.ReadAsync();
id = Thread.CurrentThread.ManagedThreadId;
pipe.Reader.Advance(result.Buffer.End, result.Buffer.End);
pipe.Reader.Complete();
await writing;
}
}
public async Task TakeTraversesSegments()
{
using (var factory = new PipeFactory())
{
var readerWriter = factory.Create();
var w = readerWriter.Writer.Alloc();
w.Append(ReadableBuffer.Create(new byte[] { 1 }, 0, 1));
w.Append(ReadableBuffer.Create(new byte[] { 2 }, 0, 1));
w.Append(ReadableBuffer.Create(new byte[] { 3 }, 0, 1));
await w.FlushAsync();
var result = await readerWriter.Reader.ReadAsync();
var buffer = result.Buffer;
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Take());
Assert.Equal(3, reader.Take());
Assert.Equal(-1, reader.Take());
}
}
public void Setup()
{
PipeFactory = new PipeFactory();
Pipe = PipeFactory.Create();
var serviceContext = new ServiceContext
{
HttpParserFactory = f => new HttpParser <FrameAdapter>(),
ServerOptions = new KestrelServerOptions(),
};
var frameContext = new FrameContext
{
ServiceContext = serviceContext,
ConnectionInformation = new MockConnectionInformation
{
PipeFactory = PipeFactory
},
TimeoutControl = new MockTimeoutControl()
};
Frame = new Frame <object>(application: null, frameContext: frameContext);
}
public async Task CopyToAsyncNativeMemory()
{
using (var factory = new PipeFactory(NativeBufferPool.Shared))
{
var readerWriter = factory.Create();
var output = readerWriter.Writer.Alloc();
output.Append("Hello World", TextEncoder.Utf8);
await output.FlushAsync();
var ms = new MemoryStream();
var result = await readerWriter.Reader.ReadAsync();
var rb = result.Buffer;
await rb.CopyToAsync(ms);
ms.Position = 0;
Assert.Equal(11, rb.Length);
Assert.Equal(11, ms.Length);
Assert.Equal(rb.ToArray(), ms.ToArray());
Assert.Equal("Hello World", Encoding.ASCII.GetString(ms.ToArray()));
}
}
public async Task TrySliceToSpan(string input, string sliceTo, string expected)
{
var sliceToBytes = Encoding.UTF8.GetBytes(sliceTo);
using (var factory = new PipeFactory())
{
var readerWriter = factory.Create();
var writeBuffer = readerWriter.Writer.Alloc();
var bytes = Encoding.UTF8.GetBytes(input);
writeBuffer.Write(bytes);
await writeBuffer.FlushAsync();
var result = await readerWriter.Reader.ReadAsync();
var buffer = result.Buffer;
ReadableBuffer slice;
ReadCursor cursor;
Assert.True(buffer.TrySliceTo(sliceToBytes, out slice, out cursor));
Assert.Equal(expected, slice.GetUtf8String());
}
}
public async Task AdvanceToEndReturnsAllBlocks()
{
var pool = new DisposeTrackingBufferPool();
var writeSize = 512;
using (var factory = new PipeFactory(pool))
{
var pipe = factory.Create();
while (pool.CurrentlyRentedBlocks != 3)
{
var writableBuffer = pipe.Writer.Alloc(writeSize);
writableBuffer.Advance(writeSize);
await writableBuffer.FlushAsync();
}
var readResult = await pipe.Reader.ReadAsync();
pipe.Reader.Advance(readResult.Buffer.End);
Assert.Equal(0, pool.CurrentlyRentedBlocks);
}
}
private OutputProducer CreateOutputProducer(PipeOptions pipeOptions, CancellationTokenSource cts = null)
{
var pipe = _pipeFactory.Create(pipeOptions);
var logger = new TestApplicationErrorLogger();
var serviceContext = new TestServiceContext
{
Log = new TestKestrelTrace(logger),
ThreadPool = new InlineLoggingThreadPool(new TestKestrelTrace(logger))
};
var transportContext = new TestLibuvTransportContext {
Log = new LibuvTrace(logger)
};
var socket = new MockSocket(_mockLibuv, _libuvThread.Loop.ThreadId, transportContext.Log);
var consumer = new LibuvOutputConsumer(pipe.Reader, _libuvThread, socket, "0", transportContext.Log);
var frame = new Frame <object>(null, new FrameContext
{
ServiceContext = serviceContext,
ConnectionInformation = new MockConnectionInformation
{
PipeFactory = _pipeFactory
},
TimeoutControl = Mock.Of <ITimeoutControl>(),
Output = pipe
});
if (cts != null)
{
frame.RequestAborted.Register(cts.Cancel);
}
var ignore = WriteOutputAsync(consumer, pipe.Reader, frame);
return(frame.Output);
}