public async Task <LoopSession> Start() { int?port; ReceiverService loop = new ReceiverBuilder() .WithDefinition(new LoopMessages()) .Build(hooks); TcpSocket client = pool.New(); TcpSocket server = pool.New(); client.Bind(); server.Bind(out port); server.Listen(1); IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port.Value); Task <TcpSocketAccept> accept = server.Accept(); client.Connect(endpoint, null); PeerHash peer = PeerHash.Random(); TcpSocketAccept accepted = await accept; NetworkConnection receiver = pool.Create(accepted.Connection, NetworkDirection.Incoming, accepted.GetRemote()); loop.StartProcessing(peer, receiver); return(new LoopSession(client, loop)); }
public async Task CanHandleTerminatedStream() { IPAddress localhost = IPAddress.Loopback; IPEndPoint endpoint = new IPEndPoint(localhost, 1234); using (CompletionThread worker = new CompletionThread()) { SocketFactory factory = new SocketFactory(worker); using (TcpSocket server = factory.Tcp()) using (TcpSocket socket = factory.Tcp()) { socket.Bind(); worker.Start(); server.Bind(endpoint.Port); server.Listen(1); Task <TcpSocketAccept> acceptable = server.Accept(); await socket.Connect(endpoint); TcpSocketAccept accepted = await acceptable; accepted.Connection.Dispose(); byte[] buffer = new byte[10]; TcpSocketSend sent = await socket.Send(buffer); Assert.That(sent.Status, Is.EqualTo(SocketStatus.OK)); } } }
private void OnAccept(TcpSocketAccept data) { bool canAcceptMore = data.Status != SocketStatus.NotSocket && data.Status != SocketStatus.OperationAborted; if (canAcceptMore) { data.Socket.Accept(OnAccept); } if (data.Status == SocketStatus.OK) { IPEndPoint endpoint = data.GetRemote(); NetworkAddress remote = NetworkAddress.Parse(endpoint); NetworkDirection direction = NetworkDirection.Incoming; NetworkConnection connection = dependencies.Network.Create(data.Connection, direction, endpoint); hooks.CallConnectionArrived(remote, connection); } else { data.Connection?.Dispose(); } }
public async Task CanObtainAcceptedRemoteEndpointUsingTasks() { using (CompletionThread worker = new CompletionThread()) { IPEndPoint endpoint; SocketFactory factory = new SocketFactory(worker); using (TcpSocket server = factory.Tcp()) using (TcpSocket client = factory.Tcp()) { worker.Start(); client.Bind(); server.Bind(IPAddress.Loopback); server.Listen(1); endpoint = server.Info().Endpoint; Task <TcpSocketAccept> accepting = server.Accept(); await client.Connect(endpoint); TcpSocketAccept accepted = await accepting; IPEndPoint remote = accepted.GetRemote(); Assert.That(remote.Address, Is.EqualTo(endpoint.Address)); Assert.That(remote.Port, Is.Not.EqualTo(endpoint.Port)); Assert.That(remote.Port, Is.Not.Zero); } } }
private void OnAccepted(TcpSocketAccept data) { socket.Accept(OnAccepted); if (data.Status == SocketStatus.OK) { serverWorkers.Next().Handle(data.Connection); } else { data.Connection.Dispose(); } }
public async Task CanHandleNotBoundSocket() { using (CompletionThread worker = new CompletionThread()) { SocketFactory factory = new SocketFactory(worker); using (TcpSocket socket = factory.Tcp()) { TcpSocketAccept accepted = await socket.Accept(); Assert.That(accepted.Status, Is.Not.EqualTo(SocketStatus.OK)); } } }
public async Task ShouldTriggerConnectionReceivedWhenReceivedSomeBytes() { NetworkDirection direction = NetworkDirection.Outgoing; NetworkOutgoingMessage message = new RandomMessage(113); using (NetworkFixture fixture = new NetworkFixture()) using (TcpSocket host = fixture.Pool.New()) using (TcpSocket socket = fixture.Pool.New()) { TcpSocketInfo info = host.BindAndInfo(); int port = info.Endpoint.Port; IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port); socket.Bind(); host.Listen(10); Task <TcpSocketAccept> task = host.Accept(); await socket.Connect(endpoint); TcpSocketAccept accept = await task; NetworkConnection connection = fixture.Pool.Create(socket, direction, endpoint); NetworkBlock block = new NetworkBlock(new byte[1024], 0, message.Length); Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionReceived, data => { data.Remote.Should().Be(NetworkAddress.Parse(endpoint)); data.Connection.Should().NotBeNull(); data.Bytes.Should().Be(message.Length); }); connection.Receive(new NullReceiver()); message.ToBytes(block); block.With((buffer, offset, count) => { accept.Connection.Send(new SocketBuffer(buffer, offset, count), null); }); handler.Wait().Should().BeTrue(); } }
private async void OnAccepted(TcpSocketAccept data) { if (data.Status == SocketStatus.OK) { socket.Accept(OnAccepted); } if (data.Status == SocketStatus.OK) { TcpSocket other = data.Connection; byte[] bytes = new byte[1024]; while (true) { TcpSocketReceive received = await other.Receive(bytes); SocketBuffer buffer = new SocketBuffer(bytes, 0, received.Count); if (received.Count == 0) { break; } if (received.Status != SocketStatus.OK) { break; } TcpSocketSend sent = await other.Send(buffer); if (sent.Status != SocketStatus.OK) { break; } } other.Dispose(); } }
public async Task ShouldTriggerConnectionTerminatedWhenSending() { NetworkDirection direction = NetworkDirection.Outgoing; using (NetworkFixture fixture = new NetworkFixture()) using (TcpSocket host = fixture.Pool.New()) using (TcpSocket socket = fixture.Pool.New()) { TcpSocketInfo info = host.BindAndInfo(); int port = info.Endpoint.Port; IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port); socket.Bind(); host.Listen(10); Task <TcpSocketAccept> task = host.Accept(); TcpSocketConnect connect = await socket.Connect(endpoint); TcpSocketAccept accept = await task; connect.Status.Should().Be(SocketStatus.OK); accept.Status.Should().Be(SocketStatus.OK); accept.Connection.Dispose(); NetworkConnection connection = fixture.Pool.Create(socket, direction, endpoint); Trigger handler = Trigger.Bind(ref fixture.Hooks.OnConnectionTerminated, data => { data.Remote.Should().Be(NetworkAddress.Parse(endpoint)); data.Connection.Should().NotBeNull(); }); for (int i = 0; i < 10; i++) { connection.Send(new OneByteMessage()); } handler.Wait().Should().BeTrue(); } }
public async Task <NegotiatorFixturePair> Create() { int?port; TcpSocket host = pool.New(); TcpSocket client = pool.New(); client.Bind(); host.Bind(out port); host.Listen(1); Task <TcpSocketAccept> accept = host.Accept(); Task <TcpSocketConnect> connect = client.Connect(port.Value); TcpSocketAccept accepted = await accept; TcpSocketConnect connected = await connect; NetworkConnection local = pool.Create(connected.Socket, NetworkDirection.Outgoing, connected.Endpoint); NetworkConnection remote = pool.Create(accepted.Connection, NetworkDirection.Incoming, accepted.GetRemote()); return(new NegotiatorFixturePair(local, remote)); }