hermes-server/Server.cs

using System.Net.WebSockets;
using System.Text;
using System.Text.Json;
using CommonSocketLibrary.Common;
using HermesSocketLibrary.Requests.Messages;
using HermesSocketLibrary.Socket.Data;
using HermesSocketServer.Socket;
using ILogger = Serilog.ILogger;

namespace HermesSocketLibrary
{
    public class Server
    {
        private readonly HermesSocketManager _sockets;
        private readonly SocketHandlerManager _handlers;
        private readonly JsonSerializerOptions _options;
        private readonly ILogger _logger;


        public Server(
            HermesSocketManager sockets,
            SocketHandlerManager handlers,
            JsonSerializerOptions options,
            ILogger logger
        )
        {
            _sockets = sockets;
            _handlers = handlers;
            _options = options;
            _logger = logger;
        }


        public async Task Handle(WebSocketUser socket, HttpContext context)
        {
            _logger.Information($"Socket connected [ip: {socket.IPAddress}][uid: {socket.SessionId}]");
            _sockets.Add(socket);
            var buffer = new byte[1024 * 8];

            while (socket.State == WebSocketState.Open)
            {
                try
                {
                    var result = await socket.Receive(new ArraySegment<byte>(buffer));
                    if (result == null || result.MessageType == WebSocketMessageType.Close || !socket.Connected)
                        break;

                    string messageString = Encoding.UTF8.GetString(buffer, 0, result.Count).TrimEnd('\0');
                    var message = JsonSerializer.Deserialize<WebSocketMessage>(messageString, _options);
                    if (message == null)
                        continue;

                    if (message.OpCode != 0)
                        _logger.Information($"rxm: {messageString} [ip: {socket.IPAddress}][id: {socket.Id}][name: {socket.Name}][token: {socket.ApiKey}][uid: {socket.SessionId}]");

                    if (message.OpCode < 0 || message.OpCode > 8 || message.OpCode == 2 || message.OpCode == 4)
                    {
                        await socket.Send(5, new LoggingMessage("Received an invalid message: " + messageString, HermesLoggingLevel.Error));
                        return;
                    }

                    bool loggedIn = !string.IsNullOrEmpty(socket.Id);
                    int[] nonProtectedOps = { 0, 1 };
                    if (!loggedIn && !nonProtectedOps.Contains(message.OpCode))
                    {
                        _logger.Warning($"An attempt was made to use protected routes while not logged in [ip: {socket.IPAddress}][id: {socket.Id}][name: {socket.Name}][token: {socket.ApiKey}][uid: {socket.SessionId}]");
                        return;
                    }
                    int[] protectedOps = { 0, 3, 5, 6, 7, 8 };
                    if (loggedIn && !protectedOps.Contains(message.OpCode))
                    {
                        _logger.Warning($"An attempt was made to use non-protected routes while logged in [ip: {socket.IPAddress}][id: {socket.Id}][name: {socket.Name}][token: {socket.ApiKey}][uid: {socket.SessionId}]");
                        return;
                    }

                    if (message.Data == null)
                    {
                        await socket.Send(5, new LoggingMessage("Received no data in the message.", HermesLoggingLevel.Warn));
                        continue;
                    }

                    string data = message.Data.ToString()!;
                    if (message.OpCode == 0)
                        message.Data = JsonSerializer.Deserialize<HeartbeatMessage>(data, _options);
                    else if (message.OpCode == 1)
                        message.Data = JsonSerializer.Deserialize<HermesLoginMessage>(data, _options);
                    else if (message.OpCode == 3)
                        message.Data = JsonSerializer.Deserialize<RequestMessage>(data, _options);
                    else if (message.OpCode == 5)
                        message.Data = JsonSerializer.Deserialize<LoggingMessage>(data, _options);
                    else if (message.OpCode == 6)
                        message.Data = JsonSerializer.Deserialize<ChatterMessage>(data, _options);
                    else if (message.OpCode == 7)
                        message.Data = JsonSerializer.Deserialize<EmoteDetailsMessage>(data, _options);
                    else if (message.OpCode == 8)
                        message.Data = JsonSerializer.Deserialize<EmoteUsageMessage>(data, _options);
                    //else if (message.OpCode == 9)
                    //    message.Data = JsonSerializer.Deserialize<SlaveMessage>(data, _options);
                    else
                    {
                        await socket.Send(5, new LoggingMessage("Received a message with invalid data: " + messageString, HermesLoggingLevel.Error));
                        continue;
                    }
                    await _handlers.Execute(socket, message.OpCode, message.Data);
                }
                catch (WebSocketException wse)
                {
                    _logger.Error(wse, $"Error trying to process a socket message [code: {wse.ErrorCode}][ip: {socket.IPAddress}][id: {socket.Id}][name: {socket.Name}][token: {socket.ApiKey}][uid: {socket.SessionId}]");
                }
                catch (Exception e)
                {
                    _logger.Error(e, $"Error trying to process a socket message [ip: {socket.IPAddress}][id: {socket.Id}][name: {socket.Name}][token: {socket.ApiKey}][uid: {socket.SessionId}]");
                }
            }

            try
            {
                if (socket.Connected)
                    await socket.Close(socket.CloseStatus ?? WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
            }
            catch (Exception e)
            {
                _logger.Information(e, $"Client failed to disconnect [ip: {socket.IPAddress}][id: {socket.Id}][name: {socket.Name}][token: {socket.ApiKey}][uid: {socket.SessionId}]");
            }
            finally
            {
                socket.Dispose();
                _sockets.Remove(socket);
            }
            _logger.Information($"Client disconnected [ip: {socket.IPAddress}][id: {socket.Id}][name: {socket.Name}][token: {socket.ApiKey}][uid: {socket.SessionId}]");

            // Update slave status of another client from the same user if available.
            // TODO: Ensure one of the clients is always a non-slave.
            if (socket.Id != null && !socket.Slave)
            {
                var client = _sockets.GetSockets(socket.Id).Where(s => !s.WebLogin).FirstOrDefault();
                if (client != null)
                {
                    await client.Send(9, new SlaveMessage() { Slave = false });
                    client.Slave = false;
                }
            }
        }
    }
}