public void Start(ushort port)
{
EasyTcpClient selectedClient = null;
using var server = new EasyTcpServer().Start(port);
server.OnError += (s, exception) => Console.WriteLine($"Server error: {exception.Message}");
server.OnDataReceive += (s, message) =>
{
if (selectedClient == message.Client)
{
Console.WriteLine(message.Decompress().ToString());
}
};
while (true)
{
string command = Console.ReadLine();
if (string.IsNullOrWhiteSpace(command))
{
continue;
}
var args = command.Split(' ');
command = args[0];
ExecuteCommand(command, args.Skip(1).ToArray(), server, ref selectedClient);
}
}
public void Start4()
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer();
server.Start(port);
}
public void Setup()
{
_port = TestHelper.GetPort();
var server = new EasyTcpServer();
server.Start(_port);
}
/// <summary>
/// Start listening for new connections
/// </summary>
/// <param name="server"></param>
/// <param name="endPoint"></param>
/// <param name="dualMode">specifies if the socket is a dual-mode socket (IPv4 and IPv6)</param>
/// <param name="backlog">the maximum length of the pending connections queue</param>
public static EasyTcpServer Start(this EasyTcpServer server, IPEndPoint endPoint, bool dualMode = false,
int backlog = 100)
{
if (server.IsRunning)
{
throw new Exception("Could not start server: server is already running");
}
if (endPoint == null)
{
throw new ArgumentException("Could not start server: endPoint is null");
}
if (dualMode && endPoint.AddressFamily != AddressFamily.InterNetworkV6)
{
throw new ArgumentException("Could not start server: use an ipv6 endpoint if using dualMode");
}
server.BaseSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
if (dualMode)
{
server.BaseSocket.DualMode = true;
}
server.BaseSocket.Bind(endPoint);
server.BaseSocket.Listen(backlog);
server.BaseSocket.BeginAccept(OnConnectUtil.OnClientConnect, server);
server.IsRunning = true;
return(server);
}
public void TestLargeArray()
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
server.OnDataReceive += async(sender, message) =>
{
var array = await message.ReceiveLargeArrayAsync();
message.Client.Send(array.Length);
await message.Client.SendLargeArrayAsync(array);
};
byte[] receivedArray = null;
using var client = new EasyTcpClient();
client.OnDataReceive += (sender, message) => receivedArray = message.ReceiveLargeArray();
Assert.IsTrue(client.Connect(IPAddress.Loopback, port));
client.Send("first message");
byte[] largeMessage = new byte[ushort.MaxValue * 10];
for (int i = 0; i < largeMessage.Length; i++)
{
largeMessage[i] = 11;
}
client.SendLargeArray(largeMessage);
TestHelper.WaitWhileTrue(() => receivedArray == null);
Assert.IsTrue(receivedArray.SequenceEqual(largeMessage));
}
public void Stream1() //Client -> -(Stream)> Server (Client sends message to server)
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, port));
string testData = "123", data = null;
server.OnDataReceive += (sender, message) => //Receive stream from client
{
using var stream = new MemoryStream();
message.ReceiveStream(stream, compression: true);
data = Encoding.UTF8.GetString(stream.ToArray());
};
//Send stream to server
using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(testData));
client.Send("Stream");
client.SendStream(dataStream, compression: true);
TestHelper.WaitWhileTrue(() => data == null);
Assert.AreEqual(testData, data);
}
public void Stream()
{
var certificate = new X509Certificate2("certificate.pfx", "password");
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().UseSsl(certificate).Start(port);
using var client = new EasyTcpClient().UseSsl("localhost", true);
Assert.IsTrue(client.Connect(IPAddress.Any, port));
string testData = "123", data = null;
server.OnDataReceiveAsync += async(sender, message) => //Receive stream from client
{
await using var stream = new MemoryStream();
message.ReceiveStream(stream);
data = Encoding.UTF8.GetString(stream.ToArray());
};
//Send stream to server
using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(testData));
client.Send("Stream");
client.SendStream(dataStream);
TestHelper.WaitWhileTrue(() => data == null);
Assert.AreEqual(testData, data);
}
public static void StartBasicServer()
{
var server = new EasyTcpServer().Start(Port); // Start server on port 5000. (See StartUtil for more options)
/* Using the OnConnect event.
* Gets triggered when an new client connects,
* Has as parameter an EasyTcpClient, events and functions on this client can be used as in BasicClient.cs
*/
server.OnConnect += (sender, client) =>
{
Console.WriteLine("Server: Client connected");
Console.WriteLine($"Server: There are now {server.ConnectedClientsCount + 1} clients connected");
};
/* Using the OnDisconnect event.
* Gets triggered when a client is disconnects (After the client is disconnected!)
*/
server.OnDisconnect += (sender, client)
=> Console.WriteLine("Server: Client disconnected");
/* Using the OnDataReceive event.
* This gets triggered when any clients sends data,
* remember: Events can also be set for 1 client (See BasicClient.cs)
*/
server.OnDataReceive += OnDataReceive;
/* OnError get triggered when an error occurs in the server code,
* This includes errors in the events because these are triggered by the server
*/
server.OnError += (sender, e) =>
Console.WriteLine($"Server: Error occured, message: {e.Message}");
}
public void Stream2() //Client -> Server -(Stream)> Client (Client requests stream from server)
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer();
server.Start(port);
string testData = "123", data = null;
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, port));
server.OnDataReceive += (sender, message) => //Send stream if client requests
{
using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(testData));
message.Client.Send("Stream");
message.Client.SendStream(dataStream);
};
client.OnDataReceive += (sender, message) => //Receive stream from server
{
using var stream = new MemoryStream();
message.ReceiveStream(stream);
data = Encoding.UTF8.GetString(stream.ToArray());
};
client.Send("GetStream"); //Request stream
TestHelper.WaitWhileTrue(() => data == null);
Assert.AreEqual(testData, data);
}
public static void Run()
{
// Create server with logging enabled
// Write log to console
using var server = new EasyTcpServer().UseServerLogging(Console.WriteLine).Start(Port);
server.OnDataReceive += (s, message) => message.Client.Send("Hello client test!");
// Create client with logging enabled
using var client = new EasyTcpClient().UseClientLogging(Console.WriteLine);
if (!client.Connect("127.0.0.1", Port))
{
return;
}
client.Send("Hello server!");
Console.ReadLine();
/* Custom logging,
* only log connect/disconnect events
*/
using var server2 = new EasyTcpServer().UseCustomServerLogging(logMessage =>
{
if (logMessage.Type == LoggingType.ClientConnected)
{
Console.WriteLine(logMessage);
}
else if (logMessage.Type == LoggingType.ClientDisconnected)
{
Console.WriteLine(logMessage);
}
});
}
public static void StartEchoServer()
{
var server = new EasyTcpServer().Start(Port); //Start server on port 5001
// Send received data back
server.OnDataReceive += (sender, message) => message.Client.Send(message.Data);
}
public void TestConnectedClients()
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
Assert.IsEmpty(server.GetConnectedClients());
using var client = new EasyTcpClient();
client.Connect(IPAddress.Loopback, port);
TestHelper.WaitWhileFalse(() => server.ConnectedClientsCount == 1);
Assert.AreEqual(1, server.ConnectedClientsCount);
using var client2 = new EasyTcpClient();
client2.Connect(IPAddress.Loopback, port);
TestHelper.WaitWhileFalse(() => server.ConnectedClientsCount == 2);
Assert.AreEqual(2, server.ConnectedClientsCount);
client.Dispose();
TestHelper.WaitWhileTrue(() => server.ConnectedClientsCount == 2);
Assert.AreEqual(1, server.ConnectedClientsCount);
client2.Dispose();
TestHelper.WaitWhileTrue(() => server.ConnectedClientsCount == 1);
Assert.AreEqual(0, server.ConnectedClientsCount);
}
static void Main(string[] args)
{
Console.WriteLine("Server starting...");
EasyTcpServer server = new EasyTcpServer(System.Reflection.Assembly.GetExecutingAssembly());
server.OnServerStarted += (sender, s) =>
{
Console.WriteLine("Server started!");
};
server.ClientConnected += (sender, client) =>
{
Console.WriteLine($"Client [{client.RemoteEndPoint.ToString()}] connected!");
};
server.ClientDisconnected += (sender, client) =>
{
Console.WriteLine($"Client [{client.RemoteEndPoint.ToString()}] disconnected!");
};
server.DataReceived += (sender, msg) =>
{
Console.WriteLine($"PacketType: {msg.GetPacket.PacketType}");
server.PacketHandler(msg, false);
};
server.OnError += (sender, ex) =>
{
Console.WriteLine($"{ex.Message}\n{ex.StackTrace}");
};
server.Start("127.0.0.1", 6124, 10);
Task.Delay(-1).Wait();
}
public void Setup()
{
_port = TestHelper.GetPort();
var server = new EasyTcpServer().Start(_port);
server.OnDataReceive += (sender, message) => message.Client.Send(message.Data);
}
private static void StartServer(int port)
{
try
{
server = new EasyTcpActionServer();
server.Start(Port);
bool exit = false;
Console.WriteLine($">> Server started on ip: {LocalIP} (public ip adress: {PublicIP})!");
Console.WriteLine($">> Server started listening to port {port}!");
Console.WriteLine(">> Press escape to close the server ...");
while (!exit)
{
ConsoleKeyInfo key = Console.ReadKey(true);
if (key.Key == ConsoleKey.Escape)
{
exit = true;
}
}
server.Dispose();
Console.WriteLine(Environment.NewLine + ">> Server closed! Press any key to close the window ...");
Console.ReadKey(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public static void StartBasicServer()
{
var server = new EasyTcpServer();
/* OnConnect event,
* triggered when a new client connects to server
*/
server.OnConnect += (object sender, EasyTcpClient client) =>
{
Console.WriteLine($"Server: Client {server.ConnectedClientsCount} connected");
client.Send("Welcome to the server!");
};
/* OnDisconnect event,
* triggered when a client disconnects from the server
*/
server.OnDisconnect += (object sender, EasyTcpClient client)
=> Console.WriteLine("Server: Client disconnected");
/* OnDataReceive event,
* triggered when server receives data from any client
*/
server.OnDataReceive += OnDataReceive;
/* OnError event,
* triggered when an unexpected error occurs withing the servers code or in any event
* error is thrown when ignored
*/
server.OnError += (object sender, Exception e) =>
Console.WriteLine($"Server: Error occured, message: {e.Message}");
Console.WriteLine("Press enter to shutdown basic server...");
Console.ReadLine();
}
public async Task Stream1() //Client -> -(Stream)> Server (Client sends message to server)
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer();
server.Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, port));
string testData = "123", data = "";
server.OnDataReceiveAsync += async(sender, message) => //Receive stream from client
{
await using var stream = new MemoryStream();
await message.ReceiveStreamAsync(stream);
data = Encoding.UTF8.GetString(stream.ToArray());
};
//Send stream to server
await using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(testData));
client.Send("Stream");
await client.SendStreamAsync(dataStream);
TestHelper.WaitWhileTrue(() => data == "");
Assert.AreEqual(testData, data);
}
public void OnDataReceive2()
{
// Example receiving for the client
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer();
server.Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, port));
const string message = "Hello client!";
int receiveCount = 0;
client.OnDataReceive += (sender, receivedMessage) =>
{
//Async lambda, so thread safe increase integer
if (message.Equals(receivedMessage.ToString()))
{
Interlocked.Increment(ref receiveCount);
}
Console.WriteLine($"[{receiveCount}]Received message: {receivedMessage.ToString()}");
};
server.SendAll(message);
server.SendAll(message);
TestHelper.WaitWhileTrue(() => receiveCount < 2);
Assert.AreEqual(2, receiveCount);
}
public void Execute(Message msg, EasyTcpServer server)
{
Packet pack = msg.GetPacket;
List <object> objs = BytesTransformation.TransformToObject(BytesCompress.Decompress(pack.RawData), typeof(string));
ServerEvents.Debug?.Invoke($"Command Received: {objs[0].ToString()}");
MainLogic.GetInstance.Exec.CommandHandler(objs[0].ToString(), msg.Socket);
}
/// <summary>
/// Send action (byte[]) to connected clients
/// </summary>
/// <param name="server"></param>
/// <param name="action">action code</param>
/// <param name="data">data to send to connected clients</param>
/// <param name="compression">compress data using GZIP if set to true</param>
public static void SendAllAction(this EasyTcpServer server, int action, byte[] data = null, bool compression = false)
{
if (compression && data != null)
{
data = CompressionUtil.Compress(data);
}
server.SendAll(BitConverter.GetBytes(action), data);
}
/// <summary>
/// Send data (byte[]) to connected clients
/// </summary>
/// <param name="server"></param>
/// <param name="data">data to send to connected clients</param>
/// <param name="compression">compress data using GZIP if set to true</param>
public static void SendAll(this EasyTcpServer server, byte[] data, bool compression = false)
{
if (compression)
{
data = CompressionUtil.Compress(data);
}
server.SendAll(dataArray: data);
}
public void Execute(Message msg, EasyTcpServer server)
{
Console.WriteLine($"Received packet!");
Packet pack = msg.GetPacket;
List <object> Objects = BytesTransformation.TransformToObject(BytesCompress.Decompress(pack.RawData), typeof(string), typeof(string));
Console.WriteLine($"LOGIN: {Objects[0].ToString()} | PASSWORD: {Objects[1].ToString()}");
}
public void ConnectIPAddressString()
{
var port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect("127.0.0.1", port));
Assert.IsTrue(client.IsConnected());
}
public void ConnectIPAddress()
{
var port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Loopback, port));
Assert.IsTrue(client.IsConnected());
}
private static void OnDataReceive(object sender, Message message)
{
Console.WriteLine($"Server: Received data, received: {message}");
Console.WriteLine("Server: Broadcasting received data");
EasyTcpClient client = message.Client; // Get client from message
EasyTcpServer server = (EasyTcpServer)sender; // Convert sender to server or client
server.SendAll(message);
}
/// <summary>
/// Start listening for new connections
/// </summary>
/// <param name="server"></param>
/// <param name="ipAddress">ipAddress as string</param>
/// <param name="port"></param>
/// <param name="dualMode">Specifies if the socket is a dual-mode socket (Ipv4 and Ipv6)</param>
/// <param name="backlog">The maximum length of the pending connections queue</param>
public static EasyTcpServer Start(this EasyTcpServer server, string ipAddress, ushort port,
bool dualMode = false,
int backlog = 100)
{
if (!IPAddress.TryParse(ipAddress, out IPAddress address))
{
throw new ArgumentException("Could not start server: ipAddress is not a valid IPv4/IPv6 address");
}
return(Start(server, new IPEndPoint(address, Math.Max(port, (ushort)1)), dualMode, backlog));
}
public async Task ConnectAsyncEndpoint()
{
var port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, port)));
Assert.IsTrue(client.IsConnected());
}
public void TestInvalidCertificate()
{
ushort port = TestHelper.GetPort();
var certificate = new X509Certificate2("certificate.pfx", "password");
using var server = new EasyTcpServer().UseSsl(certificate).Start(port);
using var client = new EasyTcpClient().UseSsl("localhost");
Assert.IsFalse(client.Connect("127.0.0.1", port));
}
/// <summary>
/// Send data to all connected clients
/// </summary>
/// <param name="server"></param>
/// <param name="dataArray">data to send to connected clients</param>
public static void SendAll(this EasyTcpServer server, params byte[][] dataArray)
{
if (server == null || !server.IsRunning)
{
throw new Exception("Could not send data: server not running or null");
}
foreach (var client in server.GetConnectedClients())
{
client.Protocol.SendMessage(client, dataArray);
}
}
public void Start3()
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start("127.0.0.1", port);
//Start with dualMode socket
ushort port2 = TestHelper.GetPort();
using var server2 = new EasyTcpServer().Start("::1", port2, true);
}
