Server.cs

using MTSC.Exceptions;
using MTSC.Logging;
using MTSC.Server.Handlers;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MTSC.Server
{
    public sealed class Server
    {
        #region Fields
        bool running;
        X509Certificate2 certificate;
        TcpListener listener;
        int port = 50;
        List<ClientData> toRemove = new List<ClientData>();
        List<ClientData> clients = new List<ClientData>();
        List<IHandler> handlers = new List<IHandler>();
        List<ILogger> loggers = new List<ILogger>();
        List<IExceptionHandler> exceptionHandlers = new List<IExceptionHandler>();
        ConcurrentQueue<Tuple<ClientData, byte[]>> messageQueue = new ConcurrentQueue<Tuple<ClientData, byte[]>>();
        int loopMillis = 16;
        #endregion
        #region Properties
        public int Port { get => port; set => port = value; }
        public bool Running { get => running; }
        public List<ClientData> Clients { get => clients; set => clients = value; }
        public bool ScaleUsage { get; set; }
        public int TickRate { get => 1000 / loopMillis; set => loopMillis = 1000 / Math.Min(value, 1000); }
        public bool ForceTickrate { get; set; }
        #endregion
        #region Constructors
        public Server()
        {

        }
        public Server(int port)
        {
            this.port = port;
        }
        public Server(X509Certificate2 certificate, int port)
        {
            this.certificate = certificate;
            this.port = port;
        }
        #endregion
        #region Public Methods
        public Server SetPort(int port)
        {
            this.port = port;
            return this;
        }
        public Server AddHandler(IHandler handler)
        {
            handlers.Add(handler);
            return this;
        }
        public Server AddLogger(ILogger logger)
        {
            loggers.Add(logger);
            return this;
        }
        public Server AddExceptionHandler(IExceptionHandler handler)
        {
            exceptionHandlers.Add(handler);
            return this;
        }
        public void QueueMessage(ClientData target, byte[] message)
        {
            messageQueue.Enqueue(new Tuple<ClientData, byte[]>(target, message));
        }
        public void Log(string log)
        {
            foreach (ILogger logger in loggers)
            {
                logger.Log(log);
            }
        }
        public void LogDebug(string debugMessage)
        {
            foreach (ILogger logger in loggers)
            {
                logger.LogDebug(debugMessage);
            }
        }
        public void Run()
        {
            listener?.Stop();
            listener = new TcpListener(IPAddress.Any, port);
            listener.Start();
            running = true;
            Log("Server started on: " + listener.LocalEndpoint.ToString());
            DateTime lastLoad = DateTime.Now;
            DateTime startLoopTime;
            while (running)
            {
                startLoopTime = DateTime.Now;
                /*
                 * Check the client states. If a client is disconnected, 
                 * remove it from the list of clients.
                 */
                try
                {
                    foreach (ClientData client in clients)
                    {
                        if (!client.TcpClient.Connected || client.ToBeRemoved)
                        {
                            toRemove.Add(client);
                        }
                    }
                    foreach (ClientData client in toRemove)
                    {
                        foreach (IHandler handler in handlers)
                        {
                            handler.ClientRemoved(this, client);
                        }
                        LogDebug("Client removed: " + client.TcpClient.Client.RemoteEndPoint.ToString());
                        client.SslStream?.Dispose();
                        client.TcpClient?.Dispose();
                        clients.Remove(client);
                    }
                    toRemove.Clear();
                }
                catch (Exception e)
                {
                    LogDebug("Exception: " + e.Message);
                    LogDebug("Stacktrace: " + e.StackTrace);
                    foreach (IExceptionHandler exceptionHandler in exceptionHandlers)
                    {
                        if (exceptionHandler.HandleException(e))
                        {
                            break;
                        }
                    }
                }
                /*
                 * Check if the server has any pending connections.
                 * If it has a new connection, process it.
                 */
                try
                {
                    if (listener.Pending())
                    {
                        lastLoad = DateTime.Now;
                        TcpClient tcpClient = listener.AcceptTcpClient();
                        ClientData clientStruct = new ClientData(tcpClient);
                        if (certificate != null)
                        {
                            SslStream sslStream = new SslStream(tcpClient.GetStream(), true, new RemoteCertificateValidationCallback((o, c, ch, po) => {
                                return true;
                            }), null, EncryptionPolicy.RequireEncryption);
                            clientStruct.SslStream = sslStream;
                            sslStream.AuthenticateAsServer(certificate);
                        }
                        foreach (IHandler handler in handlers)
                        {
                            if (handler.HandleClient(this, clientStruct))
                            {
                                break;
                            }
                        }
                        clients.Add(clientStruct);
                        Log("Accepted new connection: " + tcpClient.Client.RemoteEndPoint.ToString());
                    }
                }
                catch(Exception e)
                {
                    LogDebug("Exception: " + e.Message);
                    LogDebug("Stacktrace: " + e.StackTrace);
                    foreach (IExceptionHandler exceptionHandler in exceptionHandlers)
                    {
                        if (exceptionHandler.HandleException(e))
                        {
                            break;
                        }
                    }
                }
                /*
                 * Process in parallel all clients.
                 */
                Parallel.ForEach(clients, (client) =>
                {
                    try
                    {
                        /*
                         * If the connection has been lost, mark the client to be removed.
                         * Else, check if there is data to be read.
                         */
                        if (!client.TcpClient.Connected)
                        {
                            client.ToBeRemoved = true;
                        }
                        else if (client.TcpClient.Available > 0)
                        {
                            lastLoad = DateTime.Now;
                            Message message = CommunicationPrimitives.GetMessage(client.TcpClient, client.SslStream);
                            LogDebug("Received message from " + client.TcpClient.Client.RemoteEndPoint.ToString() +
                                    "\nMessage length: " + message.MessageLength);
                            foreach (IHandler handler in handlers)
                            {
                                if (handler.PreHandleReceivedMessage(this, client, ref message))
                                {
                                    break;
                                }
                            }
                            foreach (IHandler handler in handlers)
                            {
                                if (handler.HandleReceivedMessage(this, client, message))
                                {
                                    break;
                                }
                            }
                        }
                    }
                    catch(Exception e)
                    {
                        LogDebug("Exception: " + e.Message);
                        LogDebug("Stacktrace: " + e.StackTrace);
                        foreach(IExceptionHandler exceptionHandler in exceptionHandlers)
                        {
                            if (exceptionHandler.HandleException(e))
                            {
                                break;
                            }
                        }
                    }
                });
                /*
                 * Iterate through all the handlers, running periodic operations.
                 */
                Parallel.ForEach(handlers, (handler) =>
                {
                    try
                    {
                        handler.Tick(this);
                    }
                    catch (Exception e)
                    {
                        LogDebug("Exception: " + e.Message);
                        LogDebug("Stacktrace: " + e.StackTrace);
                        foreach (IExceptionHandler exceptionHandler in exceptionHandlers)
                        {
                            if (exceptionHandler.HandleException(e))
                            {
                                break;
                            }
                        }
                    }
                });
                /*
                 * Check if there are messages queued to be sent.
                 */
                if(messageQueue.Count > 0)
                {
                    lastLoad = DateTime.Now;
                    try
                    {
                        while (messageQueue.Count > 0)
                        {
                            Tuple<ClientData, byte[]> queuedOrder = null;
                            if (messageQueue.TryDequeue(out queuedOrder))
                            {
                                Message sendMessage = CommunicationPrimitives.BuildMessage(queuedOrder.Item2);
                                for (int i = handlers.Count - 1; i >= 0; i--)
                                {
                                    IHandler handler = handlers[i];
                                    ClientData client = queuedOrder.Item1;
                                    handler.HandleSendMessage(this, client, ref sendMessage);
                                }
                                CommunicationPrimitives.SendMessage(queuedOrder.Item1.TcpClient, sendMessage, queuedOrder.Item1.SslStream);
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        LogDebug("Exception: " + e.Message);
                        LogDebug("Stacktrace: " + e.StackTrace);
                        foreach (IExceptionHandler exceptionHandler in exceptionHandlers)
                        {
                            if (exceptionHandler.HandleException(e))
                            {
                                break;
                            }
                        }
                    }
                }
                /*
                 * If the server load is low or the server has a forced tickrate,
                 * sleep an amount of milliseconds to lower the CPU usage.
                 */
                if(((DateTime.Now - lastLoad).TotalMilliseconds > 1000) && ScaleUsage || 
                    ForceTickrate)
                {
                    Thread.Sleep((int)Math.Max(loopMillis - (DateTime.Now - startLoopTime).TotalMilliseconds, 0));
                }
            }
        }
        public Task RunAsync()
        {
            return new Task(Run);
        }
        public void Stop()
        {
            if (running)
            {
                running = false;
            }
        }
        #endregion
        #region Private Methods
        #endregion
    }
    public class ClientData
    {
        public TcpClient TcpClient;
        public DateTime LastMessageTime;
        public bool ToBeRemoved;
        public SslStream SslStream;

        public ClientData(TcpClient client)
        {
            this.TcpClient = client;
            this.LastMessageTime = DateTime.Now;
            ToBeRemoved = false;
            SslStream = null;
        }
    }
}