public async Task SendAsync(byte[] payload, CancellationToken token) { await Task.Run(async() => { var packet = new TcpTransportPacket(_packetNumber++, payload); var args = new SocketAsyncEventArgs(); args.SetBuffer(packet.Data, 0, packet.Data.Length); var awaitable = new SocketAwaitable(args); await _socket.SendAsync(awaitable); }, token).ConfigureAwait(false); }
public Task SendAsync(byte[] payload, CancellationToken token) { ThrowIfDisposed(); return(Task.Run(async() => { var packet = new TcpTransportPacket(_packetNumber++, payload); var args = new SocketAsyncEventArgs(); args.SetBuffer(packet.Data, 0, packet.Data.Length); _socket.SendAsync(args); }, token)); }
/// <summary> /// Try load TCP transport packet from a buffer. /// </summary> /// <param name="buffer">Buffer.</param> /// <param name="packet">Packet.</param> /// <returns>True - success, False - fail.</returns> public static bool TryLoad(ArraySegment <byte> buffer, out TcpTransportPacket packet) { packet = null; try { packet = new TcpTransportPacket(buffer); return(true); } catch (TransportException e) { Log.Debug(e); } return(false); }
private async Task ProcessReceivedPacket(TcpTransportPacket packet) { await Task.Run(() => _in.OnNext(packet.GetPayloadCopy())); }
private async Task ProcessReceivedDataAsync(ArraySegment<byte> buffer) { try { int bytesRead = 0; while (bytesRead < buffer.Count) { int startIndex = buffer.Offset + bytesRead; int bytesToRead = buffer.Count - bytesRead; if (_nextPacketBytesCountLeft == 0) { int tempLengthBytesToRead = PacketLengthBytesCount - _tempLengthBufferFill; tempLengthBytesToRead = (bytesToRead < tempLengthBytesToRead) ? bytesToRead : tempLengthBytesToRead; Buffer.BlockCopy(buffer.Array, startIndex, _tempLengthBuffer, _tempLengthBufferFill, tempLengthBytesToRead); _tempLengthBufferFill += tempLengthBytesToRead; if (_tempLengthBufferFill < PacketLengthBytesCount) { break; } startIndex += tempLengthBytesToRead; bytesToRead -= tempLengthBytesToRead; _tempLengthBufferFill = 0; _nextPacketBytesCountLeft = _tempLengthBuffer.ToInt32(); if (_nextPacketDataBuffer == null || _nextPacketDataBuffer.Length < _nextPacketBytesCountLeft || _nextPacketStreamer == null) { _nextPacketDataBuffer = new byte[_nextPacketBytesCountLeft]; _nextPacketStreamer = new TLStreamer(_nextPacketDataBuffer); } // Writing packet length. _nextPacketStreamer.Write(_tempLengthBuffer); _nextPacketBytesCountLeft -= PacketLengthBytesCount; bytesRead += PacketLengthBytesCount; } bytesToRead = bytesToRead > _nextPacketBytesCountLeft ? _nextPacketBytesCountLeft : bytesToRead; _nextPacketStreamer.Write(buffer.Array, startIndex, bytesToRead); bytesRead += bytesToRead; _nextPacketBytesCountLeft -= bytesToRead; if (_nextPacketBytesCountLeft > 0) { break; } var packet = new TcpTransportPacket(_nextPacketDataBuffer, 0, (int) _nextPacketStreamer.Position); await ProcessReceivedPacket(packet); _nextPacketBytesCountLeft = 0; _nextPacketStreamer.Position = 0; } } catch (Exception) { if (_nextPacketStreamer != null) { _nextPacketStreamer.Dispose(); _nextPacketStreamer = null; } _nextPacketDataBuffer = null; _nextPacketBytesCountLeft = 0; throw; } }
public Task SendAsync(byte[] payload, CancellationToken token) { ThrowIfDisposed(); return Task.Run(async () => { var packet = new TcpTransportPacket(_packetNumber++, payload); var args = new SocketAsyncEventArgs(); args.SetBuffer(packet.Data, 0, packet.Data.Length); var awaitable = new SocketAwaitable(args); await _socket.SendAsync(awaitable); }, token); }
private async Task ProcessReceivedDataAsync(ArraySegment <byte> buffer) { try { int bytesRead = 0; while (bytesRead < buffer.Count) { int startIndex = buffer.Offset + bytesRead; int bytesToRead = buffer.Count - bytesRead; if (_nextPacketBytesCountLeft == 0) { int tempLengthBytesToRead = PacketLengthBytesCount - _tempLengthBufferFill; tempLengthBytesToRead = (bytesToRead < tempLengthBytesToRead) ? bytesToRead : tempLengthBytesToRead; Buffer.BlockCopy(buffer.Array, startIndex, _tempLengthBuffer, _tempLengthBufferFill, tempLengthBytesToRead); _tempLengthBufferFill += tempLengthBytesToRead; if (_tempLengthBufferFill < PacketLengthBytesCount) { break; } startIndex += tempLengthBytesToRead; bytesToRead -= tempLengthBytesToRead; _tempLengthBufferFill = 0; _nextPacketBytesCountLeft = _tempLengthBuffer.ToInt32(); if (_nextPacketDataBuffer == null || _nextPacketDataBuffer.Length < _nextPacketBytesCountLeft || _nextPacketStreamer == null) { _nextPacketDataBuffer = new byte[_nextPacketBytesCountLeft]; _nextPacketStreamer = new TLStreamer(_nextPacketDataBuffer); } // Writing packet length. _nextPacketStreamer.Write(_tempLengthBuffer); _nextPacketBytesCountLeft -= PacketLengthBytesCount; bytesRead += PacketLengthBytesCount; } bytesToRead = bytesToRead > _nextPacketBytesCountLeft ? _nextPacketBytesCountLeft : bytesToRead; _nextPacketStreamer.Write(buffer.Array, startIndex, bytesToRead); bytesRead += bytesToRead; _nextPacketBytesCountLeft -= bytesToRead; if (_nextPacketBytesCountLeft > 0) { break; } var packet = new TcpTransportPacket(_nextPacketDataBuffer, 0, (int)_nextPacketStreamer.Position); await ProcessReceivedPacket(packet); _nextPacketBytesCountLeft = 0; _nextPacketStreamer.Position = 0; } } catch (Exception) { if (_nextPacketStreamer != null) { _nextPacketStreamer.Dispose(); _nextPacketStreamer = null; } _nextPacketDataBuffer = null; _nextPacketBytesCountLeft = 0; throw; } }
/// <summary> /// Try load TCP transport packet from a buffer. /// </summary> /// <param name="buffer">Buffer.</param> /// <param name="packet">Packet.</param> /// <returns>True - success, False - fail.</returns> public static bool TryLoad(ArraySegment<byte> buffer, out TcpTransportPacket packet) { packet = null; try { packet = new TcpTransportPacket(buffer); return true; } catch (TransportException e) { Console.WriteLine(e); } return false; }
public async Task Should_send() { TcpClientTransport clientTransport = CreateTcpTransport(); await clientTransport.ConnectAsync(); Socket clientSocket = _serverSocket.Accept(); byte[] payload = "010203040506070809".HexToBytes(); await clientTransport.SendAsync(payload); var buffer = new byte[30]; var received = clientSocket.Receive(buffer); var packet = new TcpTransportPacket(buffer, 0, received); var receivedPayload = packet.GetPayloadCopy(); receivedPayload.ShouldAllBeEquivalentTo(payload); }
public async Task Should_receive_small_parts_less_than_4_bytes() { TcpClientTransport clientTransport = CreateTcpTransport(); Task<byte[]> receiveTask = clientTransport.FirstAsync().Timeout(TimeSpan.FromMilliseconds(3000)).ToTask(); await clientTransport.ConnectAsync(); Socket clientSocket = _serverSocket.Accept(); byte[] payload = "010203040506070809".HexToBytes(); var packet = new TcpTransportPacket(0x0ABBCCDD, payload); byte[] part1 = packet.Data.Take(1).ToArray(); byte[] part2 = packet.Data.Skip(part1.Length).Take(2).ToArray(); byte[] part3 = packet.Data.Skip(part1.Length + part2.Length).Take(3).ToArray(); byte[] part4 = packet.Data.Skip(part1.Length + part2.Length + part3.Length).ToArray(); clientSocket.Send(part1); await Task.Delay(100); clientSocket.Send(part2); await Task.Delay(200); clientSocket.Send(part3); await Task.Delay(50); clientSocket.Send(part4); await Task.Delay(50); byte[] receivedData = await receiveTask; receivedData.Should().Equal(payload); await clientTransport.DisconnectAsync(); clientSocket.Close(); }
public async Task Should_receive_multiple_packets() { TcpClientTransport clientTransport = CreateTcpTransport(); var receivedMessages = new AsyncProducerConsumerQueue<byte[]>(); clientTransport.Subscribe(receivedMessages.Enqueue); await clientTransport.ConnectAsync(); Socket clientSocket = _serverSocket.Accept(); byte[] payload1 = Enumerable.Range(0, 10).Select(i => (byte) i).ToArray(); var packet1 = new TcpTransportPacket(0, payload1); byte[] payload2 = Enumerable.Range(11, 40).Select(i => (byte) i).ToArray(); var packet2 = new TcpTransportPacket(1, payload2); byte[] payload3 = Enumerable.Range(51, 205).Select(i => (byte) i).ToArray(); var packet3 = new TcpTransportPacket(2, payload3); byte[] allData = ArrayUtils.Combine(packet1.Data, packet2.Data, packet3.Data); byte[] dataPart1; byte[] dataPart2; allData.Split(50, out dataPart1, out dataPart2); clientSocket.Send(dataPart1); await Task.Delay(100); clientSocket.Send(dataPart2); await Task.Delay(100); byte[] receivedData1 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token); receivedData1.Should().Equal(payload1); byte[] receivedData2 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token); receivedData2.Should().Equal(payload2); byte[] receivedData3 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token); receivedData3.Should().Equal(payload3); await clientTransport.DisconnectAsync(); clientSocket.Close(); }
public async Task Should_receive_big_payload() { TcpClientTransport clientTransport = CreateTcpTransport(); Task<byte[]> receiveTask = clientTransport.FirstAsync().Timeout(TimeSpan.FromMilliseconds(1000)).ToTask(); await clientTransport.ConnectAsync(); Socket clientSocket = _serverSocket.Accept(); byte[] payload = Enumerable.Range(0, 255).Select(i => (byte) i).ToArray(); var packet = new TcpTransportPacket(0x0FA0B1C2, payload); clientSocket.Send(packet.Data); byte[] receivedData = await receiveTask; receivedData.Should().Equal(payload); await clientTransport.DisconnectAsync(); clientSocket.Close(); }
public async Task Should_receive() { TcpClientTransport clientTransport = CreateTcpTransport(); Task<byte[]> receiveTask = clientTransport.FirstAsync().Timeout(TimeSpan.FromMilliseconds(1000)).ToTask(); await clientTransport.ConnectAsync(); Socket clientSocket = _serverSocket.Accept(); byte[] payload = "010203040506070809".HexToBytes(); var packet = new TcpTransportPacket(0x0FA0B1C2, payload); clientSocket.Send(packet.Data); byte[] receivedData = await receiveTask; receivedData.Should().Equal(payload); await clientTransport.DisconnectAsync(); clientSocket.Close(); }