public async Task Rerouting() { using TCPServer server = new(new ServerConfiguration()); using TCPClient client1 = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); client1.SetUpClientInfo("Client 1"); using TCPClient client2 = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); client2.SetUpClientInfo("Client 2"); await server.Start(55550); const byte PACKET = 4; await client1.ConnectAsync(1000); client1.DefineCustomPacket <string[]>(PACKET, OnMyStringArrayReceived); await client2.ConnectAsync(1000); client2.DefineCustomPacket <string[]>(PACKET, OnClientStringsReceived); server.DefineCustomPacket <string[]>(1, PACKET, OnServerReceivedStringArray); server.DefineRerouteID(1, 2, PACKET); client1.Connection.SendData(PACKET, new[] { "Hello", "World" }); server.GetConnection(1).SendData(PACKET, new[] { "Hello", "World" }); await Task.Run(Wait); Assert.IsTrue(callbackSuccess); Assert.IsTrue(rerouteCallbackSuccess); server.Stop(); }
public async Task SendPrimitives() { using TCPServer server = new(new ServerConfiguration()); using TCPClient client = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); await server.Start(55550); server.OnClientConnected += (_, e) => { server.GetConnection(e.ClientInfo.ID).OnStringReceived += ServerClientTests_OnStringReceived; server.GetConnection(e.ClientInfo.ID).OnInt64Received += ServerClientTests_OnInt64Received; server.GetConnection(e.ClientInfo.ID).SendData(SERVER_STRING); server.GetConnection(e.ClientInfo.ID).SendData(SERVER_LONG); }; await client.ConnectAsync(1000); client.Connection.OnStringReceived += GetConnection_OnStringReceived; client.Connection.OnInt64Received += GetConnection_OnInt64Received; client.Connection.SendData(CLIENT_STRING); client.Connection.SendData(CLIENT_LONG); await Task.Run(Wait); Assert.IsTrue(eventsPassed == 4); server.Stop(); }
public async Task Connect() { using TCPServer server = new (new ServerConfiguration()); server.OnClientConnected += Server_OnClientConnected; using TCPClient client = new (SimpleTCPHelper.GetActiveIPv4Address(), 55550); await server.Start(55550); bool res = await client.ConnectAsync(1000); if (!res) { Assert.Fail(); return; } await Task.Run(Wait); Assert.IsTrue(clientConnectedEventFired); Assert.IsTrue(server.ConnectedClients.Length == 1); Assert.IsNotNull(client.Connection); Assert.IsTrue(server.ConnectedClients[0].IsServer == false); Assert.IsTrue(server.ConnectedClients[0].Address == SimpleTCPHelper.GetActiveIPv4Address().ToString()); Assert.IsTrue(server.ConnectedClients[0].Name == Environment.UserName); Assert.IsTrue(server.ConnectedClients[0].ID == 1); Assert.IsTrue(client.Connection.ListeningForData); Assert.IsTrue(client.Connection.SendingData); Assert.IsTrue(client.Info.ID == 1); server.Stop(); }
public async Task KickClient() { using TCPServer server = new (new ServerConfiguration()); using TCPClient client = new (SimpleTCPHelper.GetActiveIPv4Address(), 55550); await server.Start(55550); client.OnClientDisconnected += Client_OnDisconnectedByTheServer; bool res = await client.ConnectAsync(1000); if (!res) { Assert.Fail(); } Assert.IsTrue(server.ConnectedClients.Length == 1); Assert.IsNotNull(client.Connection); Assert.IsTrue(server.ConnectedClients[0].IsServer == false); Assert.IsTrue(client.Connection.ListeningForData); Assert.IsTrue(client.Connection.SendingData); Assert.IsTrue(client.Info.ID == 1); server.DisconnectClient(client.Info.ID); await Task.Run(Wait); Assert.IsTrue(kickedCalled); server.Stop(); }
public async Task DisconnectingMultipleClients() { using TCPServer server = new(new ServerConfiguration()); server.OnClientDisconnected += Server_OnClientDisconnected; using TCPClient client1 = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); client1.SetUpClientInfo("Client 1"); using TCPClient client2 = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); client2.SetUpClientInfo("Client 2"); await server.Start(55550); await client1.ConnectAsync(1000); await client2.ConnectAsync(1000); client1.Disconnect(); client2.Disconnect(); await Task.Run(Wait); server.Stop(); if (!(client1Disconnect && client2Disconnect)) { throw new Exception("Disconnect invalid data returned"); } }
public async Task RequestResponse() { using TCPServer server = new(new ServerConfiguration()); using TCPClient client = new(SimpleTCPHelper.GetActiveIPv4Address(), 5656); await server.Start(5656); const byte PACKET_ID = 4; await client.ConnectAsync(1000); client.ProvideValue(PACKET_ID, ClientString); server.ProvideValue(1, PACKET_ID, ServerString); string resp = await server.GetValue <string>(1, PACKET_ID); Assert.IsTrue(resp != null); Assert.IsTrue(resp == ClientString()); string resp2 = await client.GetValue <string>(PACKET_ID); Assert.IsTrue(resp2 != null); Assert.IsTrue(resp2 == ServerString()); server.Stop(); }
public async Task Disconnect() { using TCPServer server = new (new ServerConfiguration()); using TCPClient client = new (SimpleTCPHelper.GetActiveIPv4Address(), 55550); // client.SetUpClientInfo(nameof(ServerClientTests_Disconnect)); server.OnClientDisconnected += Server_OnClientDisconnected; await server.Start(55550); await client.ConnectAsync(1000); client.Disconnect(); await Task.Run(Wait); // if (server.ConnectedClients.Length > 0) { // Debug.WriteLine("A " + server.ConnectedClients[0].Name); // } Assert.IsTrue(server.ConnectedClients.Length == 0); Assert.ThrowsException <InvalidOperationException>(() => { server.GetConnection(1); }); Assert.IsNull(client.Connection); Assert.IsTrue(disconnectEvent); server.Stop(); }
public async Task ReconnectToServer() { using TCPServer server = new (new ServerConfiguration()); using TCPClient client = new (SimpleTCPHelper.GetActiveIPv4Address(), 55550); await server.Start(55550); await client.ConnectAsync(1000); client.Disconnect(); await Task.Delay(100);; Assert.IsTrue(client.Connection == null); await client.ConnectAsync(1000); Assert.IsTrue(client.Info.ID == 1); Assert.IsTrue(client.Connection != null); Assert.IsTrue(client.Connection.ListeningForData); Assert.IsTrue(client.Connection.SendingData); Assert.IsTrue(server.ConnectedClients.Length == 1); Assert.IsTrue(server.ConnectedClients[0].ID == 1); Assert.IsTrue(server.GetConnection(1).SendingData); Assert.IsTrue(server.GetConnection(1).ListeningForData); server.Stop(); }
public async Task CustomStructurePacket() { using TCPServer server = new(new ServerConfiguration()); using TCPClient client = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); await server.Start(55550); const byte PACKET_ID = 4; await client.ConnectAsync(1000); client.ProvideValue(PACKET_ID, AlsoGet); server.ProvideValue(1, PACKET_ID, Get); TestDataStruct resp = await server.GetValue <TestDataStruct>(1, PACKET_ID); Assert.IsTrue(resp.data[0] == "Ahoj"); Assert.IsTrue(resp.dataTest[0].ID == 0); Assert.IsTrue(resp.dataTest[0].moreData[0] == "Hello"); TestDataStruct resp2 = await client.GetValue <TestDataStruct>(PACKET_ID); Assert.IsTrue(resp2.data[0] == "Ahoooooooooooj"); Assert.IsTrue(resp2.dataTest[0].ID == 0); Assert.IsTrue(resp2.dataTest[0].moreData[0] == "Hell00000000000"); server.Stop(); }
public void ClientStart() { TCPClient client = new(SimpleTCPHelper.GetActiveIPv4Address(), 55555); Assert.ThrowsException <InvalidOperationException>(() => client.Info.ID == 255); Assert.IsTrue(client.Info.Name == Environment.UserName); Assert.IsNull(client.Connection); }
/// <summary> /// Send custom data type using internal serialization/deserialization mechanisms /// </summary> /// <exception cref="InvalidOperationException">The data is not marked as [Serializable]</exception> public void SendData <TData>(byte packetID, TData data) { if (!typeof(TData).IsSerializable && !serializationConfig.ContainsSerializationRule(typeof(TData))) { throw new InvalidOperationException("Trying to send data that is not marked as [Serializable]"); } SendData(packetID, myInfo.ID, SimpleTCPHelper.GetBytesFromObject(data, serializationConfig)); }
public async Task ObtainIPAddressAsync() { string ip = RefImplementation(); NetworkAddressState state = await SimpleTCPHelper.GetActiveIPv4AddressAsync(); Assert.AreEqual(ip, state.Address.ToString()); }
public void ObtainIPAddress() { string ip = RefImplementation(); IPAddress address = SimpleTCPHelper.GetActiveIPv4Address(); Assert.AreEqual(ip, address.ToString()); }
public async Task Define() { using TCPClient client = new(SimpleTCPHelper.GetActiveIPv4Address(), 4245); using TCPServer server = new(new ServerConfiguration()); using ManualResetEventSlim localEvnt = new(); await server.Start(4245); server.OnClientConnected += (_, e) => { localEvnt.Wait(); server.GetConnection(e.ClientInfo.ID).SendData(55, new TestStruct { a = 50 }); server.GetConnection(e.ClientInfo.ID).SendData(56, new MyClass()); server.GetConnection(e.ClientInfo.ID).SendData(57, new C2()); server.GetConnection(e.ClientInfo.ID).SendData(58, new Text <int>()); server.GetConnection(e.ClientInfo.ID).SendData(59, new List <MyClass>()); }; bool res = await client.ConnectAsync(1000); if (!res) { Assert.Fail(); } client.DefineCustomPacket <TestStruct>(55, (_, _) => Match()); client.DefineCustomPacket <MyClass>(56, (_, _) => Match()); client.DefineCustomPacket <C2>(57, (_, _) => Match()); client.DefineCustomPacket <Text <int> >(58, (_, _) => Match()); client.DefineCustomPacket <List <MyClass> >(59, (_, _) => Match()); localEvnt.Set(); await Task.Run(Wait); Assert.IsTrue(evnt.IsSet); void Match() { matches++; if (matches == 5) { evnt.Set(); } } }
public async Task SendUnknownData() { using TCPServer server = new (new ServerConfiguration()); server.OnClientConnected += Server_OnClientConnected; using TCPClient client = new (SimpleTCPHelper.GetActiveIPv4Address(), 55550); await server.Start(55550); await client.ConnectAsync(1000); client.Connection.SendData(64, (byte)50); await Task.Run(Wait); Assert.IsTrue(sendUnknownEventSuccess); }
public async Task SendingToAllCustom() { using TCPServer server = new(new ServerConfiguration()); using TCPClient client1 = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); client1.SetUpClientInfo("Client 1"); using TCPClient client2 = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); client2.SetUpClientInfo("Client 2"); await server.Start(55550); const byte PACKET_ID = 4; TestDataClass dataCustom = new() { Data = new List <int> { 0, 1, 2, 3, 4 } }; await client1.ConnectAsync(1000); client1.DefineCustomPacket <TestDataClass>(PACKET_ID, Test); await client2.ConnectAsync(1000); client2.DefineCustomPacket <TestDataClass>(PACKET_ID, Test); server.SendToAll(PACKET_ID, dataCustom); await Task.Run(Wait); server.Stop(); void Test(byte sender, TestDataClass e) { if (e.Data.Count == 5 && e.Data[0] == 0 && e.Data[4] == 4) { receivedCustomDataCount++; } if (receivedCustomDataCount == 2) { evnt.Set(); } } } }
public async Task SerializeCustomClass() { SimpleSerializer <MyComplexClass> format = new(Deserialization, Serialization); using TCPServer server = new(ServerConfiguration.Builder .Create() .AddSerializer(format) .Build()); using TCPClient client = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550, ClientConfiguration.Builder .Create() .AddSerializer(format) .Build()); const byte PACKET_ID = 4; await server.Start(55550); await client.ConnectAsync(1000); client.DefineCustomPacket <MyComplexClass>(PACKET_ID, (se, ea) => { if (ea.ID == 1) { idOnePassed = true; } if (ea.ID == 2) { idTwoPassed = true; } if (AllPassed()) { evnt.Set(); } ; }); server.GetConnection(1).SendData(PACKET_ID, DATA(1)); server.GetConnection(1).SendData(PACKET_ID, DATA(2)); await Task.Run(Wait); server.Stop(); }
private async Task StartServerTask() { if (ServerStateManager.isHoldingInstance) { server = ServerStateManager.RestoreServerInstance(); server.OnClientConnected += Server_OnConnectionEstablished; server.OnClientDisconnected += Server_OnClientDisconnected; } else { server = new TCPServer(new ServerConfiguration()); try { await server.Start(SimpleTCPHelper.GetActiveIPv4Address(), START_PORT); Services.Instance.MainWindow.StatusBarViewModel.ServerOnline = true; server.OnClientConnected += Server_OnConnectionEstablished; server.OnClientDisconnected += Server_OnClientDisconnected; } catch { Debugger.Break(); } } }
public async Task ConnectingMultipleClients() { using TCPServer server = new (new ServerConfiguration()); using TCPClient client1 = new (SimpleTCPHelper.GetActiveIPv4Address(), 55550); const string CLIENT1_NAME = "Client 1 " + nameof(MultipleClientsPerServer_Connect); client1.SetUpClientInfo(CLIENT1_NAME); using TCPClient client2 = new (SimpleTCPHelper.GetActiveIPv4Address(), 55550); const string CLIENT2_NAME = "Client 2 " + nameof(MultipleClientsPerServer_Connect); client2.SetUpClientInfo(CLIENT2_NAME); await server.Start(55550); await client1.ConnectAsync(1000); Assert.IsTrue(client1.Connection != null); Assert.IsTrue(server.ConnectedClients.Single(w => w.ID == client1.Info.ID).IsServer == false); Assert.IsTrue(server.ConnectedClients.Single(w => w.ID == client1.Info.ID).Name == CLIENT1_NAME); await client2.ConnectAsync(1000); Assert.IsTrue(client2.Connection != null); Assert.IsTrue(server.ConnectedClients.Single(w => w.ID == client2.Info.ID).IsServer == false); Assert.IsTrue(server.ConnectedClients.Single(w => w.ID == client2.Info.ID).Name == CLIENT2_NAME); Assert.IsTrue(server.ConnectedClients.Length == 2); Assert.ThrowsException <InvalidOperationException>(() => { server.GetConnection(0); }); Assert.ThrowsException <InvalidOperationException>(() => { server.GetConnection(3); }); Assert.IsNotNull(server.GetConnection(client1.Info.ID)); Assert.IsNotNull(server.GetConnection(client2.Info.ID)); server.Stop(); }
public async Task SendSimpleData() { using TCPServer server = new(new ServerConfiguration()); using TCPClient client = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); await server.Start(55550); const byte PACKET_ID = 4; await client.ConnectAsync(1000); client.DefineCustomPacket(PACKET_ID, (byte _, byte value) => { Assert.IsTrue(value == sentByte); evnt.Set(); }); server.DefineCustomPacket(1, PACKET_ID, (byte _, byte value) => { Assert.IsTrue(value == sentByte); }); client.Connection.SendData(PACKET_ID, sentByte); server.GetConnection(1).SendData(PACKET_ID, sentByte); await Task.Run(Wait); server.Stop(); }
internal void HandleRequest(TCPRequest request, object obj) { byte[] rawData = SimpleTCPHelper.GetBytesFromObject(obj, connection.serializationConfig); HandleRequest(request, rawData); }
public async Task CustomStructurePacketAdvanced() { using TCPServer server = new (new ServerConfiguration()); using TCPClient client = new (SimpleTCPHelper.GetActiveIPv4Address(), 55550); await server.Start(55550); const byte PACKET_ID = 4; await client.ConnectAsync(1000); TestDataStructAdvanced toSend = new() { MachineGrid = new[, ] { { new Machine { State = StateEnum.Running, GUID = Guid.NewGuid() }, new Machine { State = StateEnum.Idle, GUID = Guid.NewGuid() } }, { new Machine { State = StateEnum.Broken, GUID = Guid.NewGuid() }, new Machine { State = StateEnum.Broken, GUID = Guid.NewGuid() } } }, Machines = new Dictionary <byte, Machine>() { { 0, new Machine { State = StateEnum.Running, GUID = Guid.NewGuid() } }, { 1, new Machine { State = StateEnum.Running, GUID = Guid.NewGuid() } }, { 2, new Machine { State = StateEnum.Idle, GUID = Guid.NewGuid() } }, { 3, new Machine { State = StateEnum.Broken, GUID = Guid.NewGuid() } }, } }; bool result = false; server.DefineCustomPacket(1, PACKET_ID, (byte _, TestDataStructAdvanced value) => { try { Assert.IsTrue(value.Machines.Values .Select(s => s.GUID) .SequenceEqual(toSend.Machines.Values .Select(s => s.GUID))); Assert.IsTrue(value.MachineGrid .Cast <Machine>().ToArray() .SequenceEqual(toSend.MachineGrid .Cast <Machine>().ToArray())); result = true; } finally { evnt.Set(); } }); client.Connection.SendData(PACKET_ID, toSend); await Task.Run(Wait); client.Disconnect(); server.Stop(); Assert.IsTrue(result); } }
/// <summary> /// Disconnect and let server know that this client is disconnecting /// </summary> public void DisconnectFromServer(byte myID) { SendDataImmediate(DataIDs.CLIENT_DISCONNECTED, SimpleTCPHelper.GetBytesFromObject(myInfo, client.Configuration)); Dispose(); }
public async Task SendingToAllPrimitive() { using TCPServer server = new(new ServerConfiguration()); using TCPClient client1 = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); client1.SetUpClientInfo("Client 1"); using TCPClient client2 = new(SimpleTCPHelper.GetActiveIPv4Address(), 55550); client2.SetUpClientInfo("Client 2"); await server.Start(55550); const string DATA_STR = "Hello World"; const long DATA_LONG = 123456789; await client1.ConnectAsync(1000); client1.Connection.OnStringReceived += (s, e) => { if (e.Data == DATA_STR) { receivedStringDataCount++; } if (HasAll()) { evnt.Set(); } }; client1.Connection.OnInt64Received += (s, e) => { if (e.Data == DATA_LONG) { receivedLongDataCount++; } if (HasAll()) { evnt.Set(); } }; await client2.ConnectAsync(1000); client2.Connection.OnStringReceived += (s, e) => { if (e.Data == DATA_STR) { receivedStringDataCount++; } if (HasAll()) { evnt.Set(); } }; client2.Connection.OnInt64Received += (s, e) => { if (e.Data == DATA_LONG) { receivedLongDataCount++; } if (HasAll()) { evnt.Set(); } }; server.SendToAll(DATA_STR); server.SendToAll(DATA_LONG); await Task.Run(Wait); server.Stop(); bool HasAll() { return(receivedStringDataCount == 2 && receivedLongDataCount == 2); } }
private ReceivedData ReceiveData() { #region Working with the stream #if DEBUG Console.WriteLine("Waiting for next packet..."); #endif byte[] packetSize = new byte[DataIDs.PACKET_TOTAL_HEADER_SIZE_COMPLEXITY]; byte[] packetID = new byte[DataIDs.PACKET_ID_COMPLEXITY]; byte[] fromClient = new byte[DataIDs.CLIENT_IDENTIFICATION_COMPLEXITY]; Int64 totalReceived = 0; while (totalReceived < packetSize.Length && ListeningForData) { totalReceived += mainNetworkStream.Read(packetSize, 0, packetSize.Length); if (totalReceived == 0) { return(new ReceivedData(typeof(SocketException), 0, 0, 0)); } } totalReceived = 0; Int64 toReceive = BitConverter.ToInt64(packetSize, 0); while (totalReceived < DataIDs.PACKET_ID_COMPLEXITY) { totalReceived += mainNetworkStream.Read(packetID, 0, DataIDs.PACKET_ID_COMPLEXITY); } totalReceived = 0; while (totalReceived < DataIDs.CLIENT_IDENTIFICATION_COMPLEXITY && ListeningForData) { totalReceived += mainNetworkStream.Read(fromClient, 0, DataIDs.CLIENT_IDENTIFICATION_COMPLEXITY); } #if DEBUG Console.WriteLine("Waiting for Data 0/" + toReceive + " bytes"); #endif byte[] data = new byte[toReceive]; totalReceived = 0; while (totalReceived < toReceive && ListeningForData) { totalReceived += mainNetworkStream.Read(data, (int)totalReceived, (int)(toReceive - totalReceived)); #if DEBUG Console.WriteLine("Waiting for Data " + totalReceived + "/" + toReceive + " bytes"); #endif } #endregion byte senderID = fromClient[0]; byte packetIDSingle = packetID[0]; Type dataType = dataIDs.IdentifyID(packetIDSingle, senderID, data); object dataObject; if (packetIDSingle == DataIDs.STRING_ID) { dataObject = Encoding.UTF8.GetString(data); } else if (packetIDSingle == DataIDs.INT64_ID) { dataObject = BitConverter.ToInt64(data, 0); } else if (dataType == typeof(TCPResponse)) { TCPResponse resp; dataObject = resp = new TCPResponse(data[0], new byte[data.Length - 1], ResponseGenerator.GetResponseType(data[0]), serializationConfig); Array.Copy(data, 1, resp.RawData, 0, resp.RawData.Length); } else if (dataType == typeof(TCPRequest)) { dataObject = data[0]; } else if (dataType == typeof(OnPropertySynchronizationEventArgs) || dataType == typeof(UndefinedPacketEventArgs)) { dataObject = data; } else if (dataType == typeof(TCPClientInfo)) { dataObject = SimpleTCPHelper.GetObject(dataType, data, serializationConfig); } else { dataObject = SimpleTCPHelper.GetObject(dataIDs.customIDs[packetIDSingle].DataType, data, serializationConfig); } return(new ReceivedData(dataType, senderID, packetIDSingle, dataObject)); }