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