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));
}
