private void OnStreamClose(Task copyAsyncTask) { _memory.Return(_block); if (copyAsyncTask.IsFaulted) { SocketInput.AbortAwaiting(); Service.Logger.Log(copyAsyncTask.Exception); } else if (copyAsyncTask.IsCanceled) { SocketInput.AbortAwaiting(); Service.Logger.Log(LogLevel.Error, "FilteredStreamAdapter.CopyToAsync canceled."); } else if (_aborted) { SocketInput.AbortAwaiting(); } try { SocketInput.IncomingFin(); } catch (Exception ex) { Service.Logger.Log(ex); } }
public void LeadingWhitespaceIsNotIncludedInHeaderValue(string rawHeaders) { var trace = new KestrelTrace(new TestKestrelTrace()); var ltp = new LoggingThreadPool(trace); using (var pool = new MemoryPool()) using (var socketInput = new SocketInput(pool, ltp)) { var connectionContext = new ConnectionContext() { DateHeaderValueManager = new DateHeaderValueManager(), ServerAddress = ServerAddress.FromUrl("http://localhost:5000") }; var frame = new Frame <object>(application: null, context: connectionContext); frame.InitializeHeaders(); var headerArray = Encoding.ASCII.GetBytes(rawHeaders); socketInput.IncomingData(headerArray, 0, headerArray.Length); var success = frame.TakeMessageHeaders(socketInput, (FrameRequestHeaders)frame.RequestHeaders); Assert.True(success); Assert.Equal(1, frame.RequestHeaders.Count); Assert.Equal("value", frame.RequestHeaders["Header"]); // Assert TakeMessageHeaders consumed all the input var scan = socketInput.ConsumingStart(); Assert.True(scan.IsEnd); } }
private void OnOutputDragDroppedTo(SocketInput target) { // if sockets connected already // do nothing if (_currentDraggingSocket.HasConnection() && target.HasConnection()) { if (_currentDraggingSocket.connection == target.connection) { _currentDraggingSocket = null; drawer.CancelDrag(); return; } } if (target != null) { // check if input allows multiple connection if (target.HasConnection()) { // disconnect old connection if (target.connectionType != ConnectionType.Multiple) { Disconnect(target.connection); } } Connect(target, _currentDraggingSocket); } _currentDraggingSocket = null; drawer.CancelDrag(); }
public override void OnDisconnect(SocketInput input, IOutput output) { _receivedOutputs.Remove(output); output.ValueUpdated -= OnConnectedValueUpdated; OnConnectedValueUpdated(); }
public override void OnConnection(SocketInput input, IOutput output) { _receivedOutputs.Add(output); output.ValueUpdated += OnConnectedValueUpdated; OnConnectedValueUpdated(); }
public void ConsumingOutOfOrderFailsGracefully() { var defultIter = new MemoryPoolIterator(); // Calling ConsumingComplete without a preceding calling to ConsumingStart fails using (var socketInput = new SocketInput(null, null)) { Assert.Throws <InvalidOperationException>(() => socketInput.ConsumingComplete(defultIter, defultIter)); } // Calling ConsumingComplete twice in a row fails using (var socketInput = new SocketInput(null, null)) { socketInput.ConsumingStart(); socketInput.ConsumingComplete(defultIter, defultIter); Assert.Throws <InvalidOperationException>(() => socketInput.ConsumingComplete(defultIter, defultIter)); } // Calling ConsumingStart twice in a row fails using (var socketInput = new SocketInput(null, null)) { socketInput.ConsumingStart(); Assert.Throws <InvalidOperationException>(() => socketInput.ConsumingStart()); } }
private void OnStreamClose(Task copyAsyncTask) { _memory.Return(_block); if (copyAsyncTask.IsFaulted) { SocketInput.AbortAwaiting(); _log.LogError(0, copyAsyncTask.Exception, "FilteredStreamAdapter.CopyToAsync"); } else if (copyAsyncTask.IsCanceled) { SocketInput.AbortAwaiting(); _log.LogError("FilteredStreamAdapter.CopyToAsync canceled."); } else if (_aborted) { SocketInput.AbortAwaiting(); } try { _socketInputStream.Dispose(); } catch (Exception ex) { _log.LogError(0, ex, "FilteredStreamAdapter.OnStreamClose"); } }
public void EmptyHeaderValuesCanBeParsed(string rawHeaders, int numHeaders) { var trace = new KestrelTrace(new TestKestrelTrace()); var ltp = new LoggingThreadPool(trace); using (var pool = new MemoryPool()) using (var socketInput = new SocketInput(pool, ltp)) { var connectionContext = new ConnectionContext() { DateHeaderValueManager = new DateHeaderValueManager(), ServerAddress = ServerAddress.FromUrl("http://localhost:5000") }; var frame = new Frame <object>(application: null, context: connectionContext); var headerCollection = new FrameRequestHeaders(); var headerArray = Encoding.ASCII.GetBytes(rawHeaders); socketInput.IncomingData(headerArray, 0, headerArray.Length); var success = frame.TakeMessageHeaders(socketInput, headerCollection); Assert.True(success); Assert.Equal(numHeaders, headerCollection.Count()); // Assert TakeMessageHeaders consumed all the input var scan = socketInput.ConsumingStart(); Assert.True(scan.IsEnd); } }
// event handlers private void OnInputSocketClicked(SocketInput input, PointerEventData eventData) { if (eventData.button == PointerEventData.InputButton.Right) { connections.Where(conn => conn.input == input) .ToList() .ForEach(conn => Disconnect(conn)); } }
private async Task FilterInputAsync(MemoryPoolBlock block) { int bytesRead; while ((bytesRead = await _filteredStream.ReadAsync(block.Array, block.Data.Offset, block.Data.Count)) != 0) { SocketInput.IncomingData(block.Array, block.Data.Offset, bytesRead); } }
public void IncomingCompleteCallsBufferSizeControlAdd(Mock <IBufferSizeControl> mockBufferSizeControl) { using (var memory = new MemoryPool()) using (var socketInput = new SocketInput(memory, null, mockBufferSizeControl?.Object)) { socketInput.IncomingComplete(5, null); mockBufferSizeControl?.Verify(b => b.Add(5)); } }
public void IncomingDataCallsBufferSizeControlAdd(Mock <IBufferSizeControl> mockBufferSizeControl) { using (var memory = new MemoryPool()) using (var socketInput = new SocketInput(memory, null, mockBufferSizeControl?.Object)) { socketInput.IncomingData(new byte[5], 0, 5); mockBufferSizeControl?.Verify(b => b.Add(5)); } }
public FilteredStreamAdapter( string connectionId, Stream filteredStream, MemoryPool memory, IKestrelTrace logger, IThreadPool threadPool, IBufferSizeControl bufferSizeControl) { SocketInput = new SocketInput(memory, threadPool, bufferSizeControl); SocketOutput = new StreamSocketOutput(connectionId, filteredStream, memory, logger); _filteredStream = filteredStream; }
/// <summary> /// Creates a new connection from the listener context. /// </summary> /// <param name="context">The listener context to use.</param> /// <param name="socket">The socket handle.</param> internal Connection(ListenerContext context, UvStreamHandle socket) : base(context) { _socket = socket; socket.Connection = this; ConnectionId = ConnectionId.NewConnectionId(); _rawSocketInput = new SocketInput(Memory, ThreadPool); _rawSocketOutput = new SocketOutput(Thread, _socket, Memory, this, ConnectionId, ThreadPool, WriteReqPool); this.Expires = Timer.Now + TimeSpan.FromMinutes(1); this.ConnectionManager.Register(this); }
public FilteredStreamAdapter( ConnectionId connectionId, Stream filteredStream, MemoryPool memory, IThreadPool threadPool, IBufferSizeControl bufferSizeControl) { SocketInput = new SocketInput(memory, threadPool, bufferSizeControl); SocketOutput = new StreamSocketOutput(connectionId, filteredStream, memory); _connectionId = connectionId; _filteredStream = filteredStream; _memory = memory; }
public FilteredStreamAdapter( string connectionId, Stream filteredStream, MemoryPool memory, IKestrelTrace logger, IThreadPool threadPool) { SocketInput = new SocketInput(memory, threadPool); SocketOutput = new StreamSocketOutput(connectionId, filteredStream, memory, logger); _connectionId = connectionId; _log = logger; _filteredStream = filteredStream; _memory = memory; }
public void Connect(SocketInput input, SocketOutput output) { var connection = new Connection() { id = CreateId, input = input, output = output }; input.Connect(connection); output.Connect(connection); connections.Add(connection); input.parentNode.OnConnection(input, output); drawer.Add(connection.id, output.handle, input.handle); }
public FilteredStreamAdapter( Stream filteredStream, MemoryPool2 memory, IKestrelTrace logger) { SocketInput = new SocketInput(memory); SocketOutput = new StreamSocketOutput(filteredStream); _log = logger; _filteredStream = filteredStream; _socketInputStream = new SocketInputStream(SocketInput); _filteredStream.CopyToAsync(_socketInputStream).ContinueWith((task, state) => { ((FilteredStreamAdapter)state).OnStreamClose(task); }, this); }
public void ConsumingCompleteCallsBufferSizeControlSubtract(Mock <IBufferSizeControl> mockBufferSizeControl) { using (var kestrelEngine = new KestrelEngine(new MockLibuv(), new TestServiceContext())) { kestrelEngine.Start(1); using (var memory = new MemoryPool()) using (var socketInput = new SocketInput(memory, null, mockBufferSizeControl?.Object)) { socketInput.IncomingData(new byte[20], 0, 20); var iterator = socketInput.ConsumingStart(); iterator.Skip(5); socketInput.ConsumingComplete(iterator, iterator); mockBufferSizeControl?.Verify(b => b.Subtract(5)); } } }
public void EmptyHeaderValuesCanBeParsed(string rawHeaders, int numHeaders) { var socketInput = new SocketInput(new MemoryPool2()); var headerCollection = new FrameRequestHeaders(); var headerArray = Encoding.ASCII.GetBytes(rawHeaders); var inputBuffer = socketInput.IncomingStart(headerArray.Length); Buffer.BlockCopy(headerArray, 0, inputBuffer.Data.Array, inputBuffer.Data.Offset, headerArray.Length); socketInput.IncomingComplete(headerArray.Length, null); var success = Frame.TakeMessageHeaders(socketInput, headerCollection); Assert.True(success); Assert.Equal(numHeaders, headerCollection.Count()); // Assert TakeMessageHeaders consumed all the input var scan = socketInput.ConsumingStart(); Assert.True(scan.IsEnd); }
public async Task ReadInputAsync() { int bytesRead; do { var block = SocketInput.IncomingStart(); try { var count = block.Data.Offset + block.Data.Count - block.End; bytesRead = await _filteredStream.ReadAsync(block.Array, block.End, count); } catch (Exception ex) { SocketInput.IncomingComplete(0, ex); throw; } SocketInput.IncomingComplete(bytesRead, error: null); } while (bytesRead != 0); }
public void ThrowsOnHeadersNotEndingInCRLFLine(string rawHeaders) { var trace = new KestrelTrace(new TestKestrelTrace()); var ltp = new LoggingThreadPool(trace); using (var pool = new MemoryPool()) using (var socketInput = new SocketInput(pool, ltp)) { var connectionContext = new ConnectionContext() { DateHeaderValueManager = new DateHeaderValueManager(), ServerAddress = ServerAddress.FromUrl("http://localhost:5000"), Log = trace }; var frame = new Frame <object>(application: null, context: connectionContext); frame.InitializeHeaders(); var headerArray = Encoding.ASCII.GetBytes(rawHeaders); socketInput.IncomingData(headerArray, 0, headerArray.Length); Assert.Throws <BadHttpRequestException>(() => frame.TakeMessageHeaders(socketInput, (FrameRequestHeaders)frame.RequestHeaders)); } }
public FilteredStreamAdapter( Stream filteredStream, MemoryPool2 memory, IKestrelTrace logger, IThreadPool threadPool) { SocketInput = new SocketInput(memory, threadPool); SocketOutput = new StreamSocketOutput(filteredStream, memory); _log = logger; _filteredStream = filteredStream; _socketInputStream = new SocketInputStream(SocketInput); var block = memory.Lease(); // Use pooled block for copy _filteredStream.CopyToAsync(_socketInputStream, block).ContinueWith((task, state) => { var returnedBlock = task.Result; returnedBlock.Pool.Return(returnedBlock); ((FilteredStreamAdapter)state).OnStreamClose(task); }, this); }
public LibuvStream(SocketInput input, ISocketOutput output) { _input = input; _output = output; }
public virtual void OnDisconnect(SocketInput input, IOutput output) { }
public SocketInputStream(SocketInput socketInput) { _socketInput = socketInput; }
public async Task ConcurrentReadsFailGracefully() { // Arrange var trace = new KestrelTrace(new TestKestrelTrace()); var ltp = new LoggingThreadPool(trace); using (var memory2 = new MemoryPool()) using (var socketInput = new SocketInput(memory2, ltp)) { var task0Threw = false; var task1Threw = false; var task2Threw = false; var task0 = AwaitAsTaskAsync(socketInput); Assert.False(task0.IsFaulted); var task = task0.ContinueWith( (t) => { TestConcurrentFaultedTask(t); task0Threw = true; }, TaskContinuationOptions.OnlyOnFaulted); Assert.False(task0.IsFaulted); // Awaiting/continuing two tasks faults both var task1 = AwaitAsTaskAsync(socketInput); await task1.ContinueWith( (t) => { TestConcurrentFaultedTask(t); task1Threw = true; }, TaskContinuationOptions.OnlyOnFaulted); await task; Assert.True(task0.IsFaulted); Assert.True(task1.IsFaulted); Assert.True(task0Threw); Assert.True(task1Threw); // socket stays faulted var task2 = AwaitAsTaskAsync(socketInput); await task2.ContinueWith( (t) => { TestConcurrentFaultedTask(t); task2Threw = true; }, TaskContinuationOptions.OnlyOnFaulted); Assert.True(task2.IsFaulted); Assert.True(task2Threw); } }
public void Dispose() { SocketInput.Dispose(); }
public virtual void OnConnection(SocketInput input, IOutput output) { }
private async Task AwaitAsTaskAsync(SocketInput socketInput) { await socketInput; }