public void ConnectParallel() { // error occured in endpoint manager tests: // TcpClient lost connection after beeing used to instantiate a PacketSocket const int PORT = 2312; const int COUNT = 20; TcpClientListener listener = new(); listener.StartListeningForConnections(PORT); List <Task> tasks = new(); List <TcpClient> clients = new(); for (int i = 0; i < COUNT; i++) { var c = new TcpClient(); clients.Add(c); tasks.Add(Task.Run(() => c.Connect("localhost", PORT))); } Task.WaitAll(tasks.ToArray()); clients.ForEach(c => { Assert.IsTrue(c.Connected); PacketSocket s = new PacketSocket(c); Assert.IsTrue(s.IsConnected); Assert.IsTrue(s.IsReceiving); }); }
private void ClientConnectedCallback(IAsyncResult ar) { if (!_running) { //listening for connections stopped _stopFinished.SetResult(); return; } var tcpClient = _tcpListener.EndAcceptTcpClient(ar); log.Trace("incoming connection request"); //prepare for next connect ListenForClients(); //create socket and endpoint for new connection var socket = new PacketSocket(tcpClient); var endpoint = new Endpoint(socket); log.Debug("connection request " + endpoint.Connection); var actionBlock = new ActionBlock <Tuple <IEndpoint, byte[]> >(ReceiveHandler); endpoint.MessageBlock.LinkTo(actionBlock); endpoint.Disconnected += Endpoint_Disconnected; _ = ConnectionHandler.ProcessEndpoint(endpoint.Connection, EndpointChangedEventArgs.NewConnection(endpoint)); }
public void TestDisconnectedSend() { TcpClient client = new(); PacketSocket socket = new PacketSocket(client); byte[] payload = new byte[1024]; TestUtils.AssertException <InvalidOperationException>(socket.SendAsync(payload)); }
private void TestPacketSocket_communication(PacketSocket server, PacketSocket client) { const int PAYLOAD_SIZE = 1024; const int COUNT = 100; Assert.IsTrue(server.IsConnected); Assert.IsTrue(client.IsConnected); byte[] payload = new byte[PAYLOAD_SIZE]; for (int i = 0; i < payload.Length; i++) { payload[i] = (byte)i; } ActionBlock <byte[]> serverMessageBlock = new(buffer => { CollectionAssert.AreEqual(payload, buffer); }); ActionBlock <byte[]> clientMessageBlock = new(buffer => { CollectionAssert.AreEqual(payload, buffer); }); using var serverDisp = server.IncomingBufferBlock.LinkTo(serverMessageBlock); using var clientDisp = client.IncomingBufferBlock.LinkTo(clientMessageBlock); List <Task> taskList = new(); for (int i = 0; i < COUNT; i++) { taskList.Add(Task.Run(async() => { Assert.IsTrue(await client.SendAsync(payload)); })); taskList.Add(Task.Run(async() => { Assert.IsTrue(await server.SendAsync(payload)); })); } Assert.IsTrue(Task.WhenAll(taskList).Wait(1000)); }
private static void ResetSockets(out PacketSocket server, out PacketSocket client) { const int Port = 123; TaskCompletionSource <TcpClient> serverTask = new(); var actionBlock = new ActionBlock <TcpClient>(tcp => { serverTask.SetResult(tcp); }); using TcpClientListener listener = new(); listener.ConnectingClientBlock.LinkTo(actionBlock); listener.StartListeningForConnections(Port); var tcpClient = new TcpClient("localhost", Port); client = new PacketSocket(tcpClient); server = new PacketSocket(serverTask.Task.Result); Assert.IsTrue(client.IsConnected); Assert.IsTrue(server.IsConnected); }
public void TestBasicFunctionality() { const int PORT = 1234; EndpointManager endpointManager = new(); BufferBlock <TcpClient> block = new(); block.LinkTo(endpointManager.IncomingClientBlock); using TcpClientListener listener = new TcpClientListener(); listener.StartListeningForConnections(PORT); listener.ConnectingClientBlock.LinkTo(endpointManager.IncomingClientBlock); // // add unconnected client // add client -> multiple clients // disconnect client (extern) // disconnect client (local, null) // disconnect client (local, unregistered) // disconnect client (local) // add 2 clients // send message via client 1 // send message via client 2 // AsyncBarrier barrier = null; EndpointEventType expectedType = new(); TcpClient clientUnconnected = new(); TcpClient client1 = new(); TcpClient client2 = new(); TcpClient client3 = new(); TcpClient clientRemoteDisconnect = new(); TcpClient clientLocalDisconnect = new(); IEndpoint ep = new Endpoint(new PacketSocket(clientUnconnected)); IEndpoint localDisconnectEp = null; bool local = false; bool remoteDisconnect = false; List <IEndpoint> epList = new List <IEndpoint>(); SemaphoreSlim sem = new(1); endpointManager.EndpointConnectedHandler = async ep => { Assert.IsTrue(expectedType == EndpointEventType.Connect); await sem.WaitAsync(); epList.Add(ep); if (local) { localDisconnectEp = ep; } TestUtils.AssertTask(barrier.SignalAsync()); sem.Release(); }; endpointManager.EndpointDisconnectedHandler = async(ep, remote) => { Assert.AreEqual(remoteDisconnect, remote); Assert.IsTrue(expectedType == EndpointEventType.Disconnect); await sem.WaitAsync(); Assert.IsTrue(epList.Remove(ep)); TestUtils.AssertTask(barrier.SignalAsync()); sem.Release(); }; expectedType = EndpointEventType.Connect; barrier = new(4, false); // add unconnected client TestUtils.AssertTask(block.SendAsync(clientUnconnected)); var tasks = new List <Task>(); // add client -> multiple clients tasks.Add(Task.Run(() => client1.Connect("localhost", PORT))); tasks.Add(Task.Run(() => client2.Connect("localhost", PORT))); tasks.Add(Task.Run(() => client3.Connect("localhost", PORT))); tasks.Add(Task.Run(() => clientRemoteDisconnect.Connect("localhost", PORT))); TestUtils.AssertTask(barrier.WaitAsync(), 3000); local = true; barrier = new(1, false); tasks.Add(Task.Run(() => clientLocalDisconnect.Connect("localhost", PORT))); TestUtils.AssertTask(barrier.WaitAsync(), 3000); local = false; CollectionAssert.Contains(epList, localDisconnectEp); CollectionAssert.Contains(endpointManager.ConnectedEndpoints, localDisconnectEp); Assert.AreEqual(5, endpointManager.ConnectedEndpoints.Count); CollectionAssert.AreEquivalent(epList, endpointManager.ConnectedEndpoints); Assert.IsNotNull(localDisconnectEp); // disconnect client (remote) expectedType = EndpointEventType.Disconnect; remoteDisconnect = true; barrier = new(1, false); clientRemoteDisconnect.Close(); TestUtils.AssertTask(barrier.WaitAsync()); Assert.AreEqual(4, endpointManager.ConnectedEndpoints.Count); Assert.AreEqual(4, epList.Count); CollectionAssert.AreEquivalent(epList, endpointManager.ConnectedEndpoints); CollectionAssert.Contains(epList, localDisconnectEp); CollectionAssert.Contains(endpointManager.ConnectedEndpoints, localDisconnectEp); // disconnect client (local, null) remoteDisconnect = false; TestUtils.AssertException <ArgumentNullException>(endpointManager.DisconnectEndpointAsync(null)); // disconnect client (local, unregistered) TestUtils.AssertException <ArgumentException>(endpointManager.DisconnectEndpointAsync(ep)); CollectionAssert.AreEquivalent(epList, endpointManager.ConnectedEndpoints); // disconnect client (local) barrier = new(1, false); CollectionAssert.Contains(endpointManager.ConnectedEndpoints, localDisconnectEp); TestUtils.AssertTask(endpointManager.DisconnectEndpointAsync(localDisconnectEp)); TestUtils.AssertTask(barrier.WaitAsync()); CollectionAssert.AreEquivalent(epList, endpointManager.ConnectedEndpoints); CollectionAssert.DoesNotContain(endpointManager.ConnectedEndpoints, localDisconnectEp); barrier = new(1, false); byte[] buffer = Encoding.ASCII.GetBytes("Hello World!"); ActionBlock <RawMessage> aB = new(m => { CollectionAssert.AreEqual(buffer, m.Data); _ = barrier.SignalAsync(); }); foreach (var e in endpointManager.ConnectedEndpoints) { Assert.IsTrue(e.Socket.IsConnected); } Assert.IsTrue(client1.Connected); PacketSocket socket1 = new PacketSocket(client1); Assert.IsTrue(socket1.IsReceiving); Assert.IsTrue(socket1.IsConnected); endpointManager.RawMessageBlock.LinkTo(aB); Assert.IsTrue(TestUtils.AssertTask(socket1.SendAsync(buffer))); TestUtils.AssertTask(barrier.WaitAsync()); }
public void TestLocalRemoteDisconnect() { /* * ensure socket disconnect event is called properly * * pre: server <-> client: connected * - disconnect client * -> server: remote disconnect * -> client: local disconnect */ TaskCompletionSource tcs = new(); const int PORT = 1634; using TcpClientListener listener = new(); listener.StartListeningForConnections(PORT); PacketSocket server = null, client; ActionBlock <TcpClient> aB = new(c => { server = new PacketSocket(c); tcs.SetResult(); }); listener.ConnectingClientBlock.LinkTo(aB); client = new PacketSocket(); TestUtils.AssertTask(client.ConnectAsync("localhost", PORT), 3000); TestUtils.AssertTask(tcs.Task); Assert.IsTrue(server.IsConnected); Assert.IsTrue(client.IsConnected); Assert.IsTrue(server.IsReceiving); Assert.IsTrue(client.IsReceiving); TaskCompletionSource <bool> serverDisconnected = new(); TaskCompletionSource <bool> clientDisconnected = new(); bool onceServer = false; bool onceClient = false; EventHandler <DisconnectedArgs> serverDisconnect = (sender, e) => { Assert.IsFalse(onceServer); onceServer = true; serverDisconnected.SetResult(e.RemoteDisconnect); }; EventHandler <DisconnectedArgs> clientDisconnect = (sender, e) => { Assert.IsFalse(onceClient); onceClient = true; clientDisconnected.SetResult(e.RemoteDisconnect); }; client.Disconnected += clientDisconnect; server.Disconnected += serverDisconnect; TestUtils.AssertTask(client.DisconnectAsync()); Assert.IsFalse(client.IsConnected); TestUtils.AssertTask(clientDisconnected.Task); TestUtils.AssertTask(serverDisconnected.Task); Assert.IsFalse(server.IsConnected); Assert.IsFalse(clientDisconnected.Task.Result, "socket falsely detected remote disconnect"); Assert.IsTrue(serverDisconnected.Task.Result, "socket didn't detect remote disconnect"); client.Disconnected -= clientDisconnect; server.Disconnected -= serverDisconnect; }