public async Task TestSynchronousReadAsyncPushedBuffers(IEnumerable <byte[]> data)
{
var buffers = data.Select(x => new ArraySegment <byte>(x, 6, x.Length - 12)).ToArray();
var expectedResult = Merge(buffers);
var stream = new BufferQueueStream(null);
var readTask = Task.Run(() => ReadSyncAndAssert(stream, expectedResult, 0));
foreach (var buffer in buffers)
{
Assert.False(readTask.IsCompleted);
await Task.Delay(WaitDelay);
stream.PushBuffer(buffer);
}
await Task.Delay(WaitDelay);
Assert.False(readTask.IsCompleted);
stream.IsCompleted = true;
await Task.Delay(WaitDelay);
Assert.True(readTask.IsCompleted);
}
private void ProcessRequest(BufferSegment buffer, bool isCompleted)
{
Logger.Debug("Request received (isCompleted = {isCompleted}), length = {length}",
isCompleted, buffer.Length);
var headerLength = HttpFormatter.ParseRequest(buffer, out var request);
Logger.Trace("Request: {@request}", request);
var stream = new BufferQueueStream(_socket.BufferPool);
request.Body = stream;
stream.PushBuffer(new ArraySegment <byte>(buffer.Buffer, buffer.Offset + headerLength,
buffer.Length - headerLength));
var requestId = int.Parse(request.Headers[MazeHeaders.MazeSocketRequestIdHeader]);
var cancellationTokenSource = _cancellableRequests.GetOrAdd(requestId, i => new CancellationTokenSource());
var token = cancellationTokenSource.Token;
if (token.IsCancellationRequested)
{
cancellationTokenSource.Dispose();
_cancellableRequests.TryRemove(requestId, out _);
return;
}
if (isCompleted)
{
stream.IsCompleted = true;
}
else
{
if (_activeRequests.TryAdd(requestId, stream))
{
Logger.Debug("Added request {requestId} to active requests", requestId);
}
else
{
Logger.Error(
"Adding the request {requestId} to the active requests failed because it already exists.",
requestId);
throw new InvalidOperationException("The request already exists, duplicate request id deteceted.");
}
}
var response = new DefaultMazeResponse(requestId);
response.Headers.Add(MazeHeaders.MazeSocketRequestIdHeader, requestId.ToString());
var rawStream = new HttpResponseStream(response, request, _socket, _packageBufferSize, _maxHeaderSize,
_bufferPool, token);
response.HttpResponseStream = rawStream;
response.Body = new BufferingWriteStream(rawStream, _packageBufferSize, _bufferPool);
LogTaskError(Task.Run(() => RequestReceived?.Invoke(this, new MazeRequestReceivedEventArgs(request, response, token))));
}
public async Task TestAsynchronousReadAllBuffersPushedAtBeginningWithSegmentation(IEnumerable <byte[]> data)
{
var buffers = data.Select(x => new ArraySegment <byte>(x, 6, x.Length - 12)).ToArray();
var expectedResult = Merge(buffers);
var stream = new BufferQueueStream(null);
foreach (var buffer in buffers)
{
stream.PushBuffer(buffer);
}
stream.IsCompleted = true;
await ReadAsyncAndAssert(stream, expectedResult, 0);
}
public void TestSynchronousReadAllBuffersPushedAtBeginningNoSegmentation(IEnumerable <byte[]> data)
{
var buffers = data.Select(x => new ArraySegment <byte>(x)).ToArray();
var expectedResult = Merge(buffers);
var stream = new BufferQueueStream(null);
foreach (var buffer in buffers)
{
stream.PushBuffer(buffer);
}
stream.IsCompleted = true;
ReadSyncAndAssert(stream, expectedResult, 0);
}
private void ProcessResponse(BufferSegment buffer, bool isCompleted)
{
Logger.LogDataPackage("Received Response", buffer.Buffer, buffer.Offset, buffer.Length);
var headerLength = HttpFormatter.ParseResponse(buffer, out var response, out var contentHeaders);
var requestId = int.Parse(response.Headers.GetValues(MazeHeaders.MazeSocketRequestIdHeader).Single());
var bufferSegment =
new ArraySegment <byte>(buffer.Buffer, buffer.Offset + headerLength, buffer.Length - headerLength);
if (isCompleted)
{
response.Content = new RawStreamContent(new ArrayPoolMemoryStream(bufferSegment, _socket.BufferPool));
}
else
{
var stream = new BufferQueueStream(_socket.BufferPool);
stream.PushBuffer(bufferSegment);
if (_activeResponses.TryAdd(requestId, stream))
{
Logger.Debug("Added response {requestId} to active responses", requestId);
}
else
{
Logger.Error(
"Adding the response {requestId} to the active response failed because it already exists.",
requestId);
throw new InvalidOperationException("The response already exists, duplicate response id deteceted.");
}
response.Content = new RawStreamContent(stream);
}
foreach (var contentHeader in contentHeaders)
{
response.Content.Headers.Add(contentHeader.Key, (IEnumerable <string>)contentHeader.Value);
}
if (!_waitingRequests.TryRemove(requestId, out var taskCompletionSource))
{
Logger.Error("No TaskCompletionSource for request {requestId} found.", requestId);
response.Dispose();
return;
}
taskCompletionSource.SetResult(response);
}
