Echo Protocol

Echo protocol

The echo protocol simply repeats back anything it receives back to the client, in this code I also added commands to stop the server and clients. The server needs to handle disconnecting a little better, but this is going to come in a future version.

---

Server code

I split the code here into many classes, they are all included below

ServerMain.cs

using System;
using System.Net.Sockets;
using com.benjaminapplegate.EasyNetworking;

namespace EchoProtocol
{
    class ServerMain
    {

        public static EasyServer _server;

        public static void ClientConnect(TcpClient client, int clientId)
        {
            //Send Welcome to server packet
            Packet packet = new Packet((int) ServerPackets.Message);
            packet.WriteString("Welcome to the Echo Server");
            _server.SendPacketToId(packet, clientId);
        }

        public static void ServerFullConnect(TcpClient client, int clientId)
        {
            Packet packet = new Packet((int) ServerPackets.ServerFull);
            _server.SendPacketToTcpClient(packet, client);
        }
        
        static void Main(string[] args)
        {
            _server = new EasyServer(2, 7);
            
            _server.AddPacketHandler((int)ServerPackets.Message, ServerHandlePackets.HandleMessage);
            _server.AddPacketHandler((int)ServerPackets.ClientDisconnecting, ServerHandlePackets.HandleClientDisconnect);

            _server.clientConnection = ClientConnect;
            _server.serverFullConnection = ServerFullConnect;
            
            _server.StartServer();
            bool closeServer = false;
            while (!closeServer)
            {
                if (Console.ReadLine().Equals("stop"))
                {
                    ServerSendPackets.SendServerClosing();
                    _server.Stop();
                    Console.WriteLine("Press enter to close the server");
                    Console.ReadKey();
                    closeServer = true;
                }
            }
            
        }
    }
}

ServerPackets.cs

namespace EchoProtocol
{
    public enum ServerPackets
    {
        Message = 1,
        ServerClosing = 2,
        ClientDisconnecting = 3,
        ServerFull = 4
    }
}

ServerSendPackets.cs

using com.benjaminapplegate.EasyNetworking;

namespace EchoProtocol
{
    public class ServerSendPackets
    {
        public static void SendServerClosing()
        {
            Packet packet = new Packet((int) ServerPackets.ServerClosing);
            ServerMain._server.SendPacketToAll(packet);
        }
    }
}

ServerHandlePackets.cs

using System;
using com.benjaminapplegate.EasyNetworking;

namespace EchoProtocol
{
    public class ServerHandlePackets
    {
        public static void HandleMessage(int clientId, Packet packet)
        {
            /*Because the echo protocol simply repeats what was sent to the server back to the client
             *you do not need to make a new packet, you could simply send the same packet back,
             * but here I will make a new one
             */
            Packet packetToSend = new Packet((int) ServerPackets.Message);
            packetToSend.WriteString(packet.ReadString());
            ServerMain._server.SendPacketToId(packetToSend, clientId);
        }

        public static void HandleClientDisconnect(int clientId, Packet packet)
        {
            //Future versions of the library will add a function to disconnect a client
            Console.WriteLine($"Client {clientId} has disconnected from the server");
            ServerMain._server.ConnectedClients[clientId].Close();
            ServerMain._server.ConnectedClients[clientId] = null;
        }
    }
}

---

Client

ClientMain.cs

using System;
using com.benjaminapplegate.EasyNetworking;

namespace EchoProtocolClient
{
    class ClientMain
    {

        public static EasyClient _client;
        public static bool disconnectFromServer = false;

        public static void ConnectedToServer()
        {
            Console.WriteLine("Connected to server, Enter a message to have it echoed back");
        }

        public static void FailedToConnect()
        {
            Console.WriteLine("Failed to connect to server, perhaps no server is running on that port");
            Console.WriteLine("Press enter to close the client");
            Console.ReadKey();
            disconnectFromServer = true;
        }
        
        static void Main(string[] args)
        {
            _client = new EasyClient("localhost", 7);
            
            _client.AddPacketHandler((int)ClientPackets.Message, ClientHandlePackets.HandleMessage);
            _client.AddPacketHandler((int)ClientPackets.ServerClosing, ClientHandlePackets.HandleServerClose);
            _client.AddPacketHandler((int)ClientPackets.ServerFull, ClientHandlePackets.HandleServerFull);

            _client.SuccessfulClient = ConnectedToServer;
            _client.FailedClient = FailedToConnect;
            
            _client.ConnectToServer();
            while (!disconnectFromServer)
            {
                string message = Console.ReadLine();
                if(disconnectFromServer) break;
                if(_client.IsConnected() == false) break;
                if (message.Equals("exit"))
                {
                    ClientSendPackets.SendDisconnectPacket();
                    _client.Disconnect();
                    disconnectFromServer = true;
                }
                else
                {
                    ClientSendPackets.SendMessagePacket(message);
                }
            }
        }
    }
}

ClientPackets.cs

namespace EchoProtocolClient
{
    public enum ClientPackets
    {
        Message = 1,
        ServerClosing = 2,
        ClientDisconnecting = 3,
        ServerFull = 4
    }
}

ClientSendPackets.cs

using com.benjaminapplegate.EasyNetworking;

namespace EchoProtocolClient
{
    public class ClientSendPackets
    {
        public static void SendDisconnectPacket()
        {
            Packet packet = new Packet((int) ClientPackets.ClientDisconnecting);
            ClientMain._client.SendPacketToServer(packet);
        }

        public static void SendMessagePacket(string message)
        {
            Packet packet = new Packet((int) ClientPackets.Message);
            packet.WriteString(message);
            ClientMain._client.SendPacketToServer(packet);
        }
    }
}

ClientHandlePackets.cs

using System;
using com.benjaminapplegate.EasyNetworking;

namespace EchoProtocolClient
{
    public class ClientHandlePackets
    {
        public static void HandleMessage(Packet packet)
        {
            Console.WriteLine($"Message from server: {packet.ReadString()}");
        }
        
        public static void HandleServerClose(Packet packet)
        {
            Console.WriteLine("The server has closed, press Enter to close the client");
            ClientMain._client.Disconnect();
            ClientMain.disconnectFromServer = true;
        }

        public static void HandleServerFull(Packet packet)
        {
            Console.WriteLine("The server is full, press enter to close the client");
            ClientMain._client.Disconnect();
            Console.ReadKey();
            ClientMain.disconnectFromServer = true;
        }
        
        
    }
}