yep

Shogi.Api/Services/SocketService.cs

@@ -9,91 +9,96 @@ using System.Text.Json;
 
 namespace Shogi.Api.Services
 {
-  public interface ISocketService
-  {
-    Task HandleSocketRequest(HttpContext context);
-  }
-
-  /// <summary>
-  /// Services a single websocket connection. Authenticates the socket connection, accepts messages, and sends messages.
-  /// </summary>
-  public class SocketService : ISocketService
-  {
-    private readonly ILogger<SocketService> logger;
-    private readonly ISocketConnectionManager communicationManager;
-    private readonly ISocketTokenCache tokenManager;
-
-    public SocketService(
-      ILogger<SocketService> logger,
-      ISocketConnectionManager communicationManager,
-      ISocketTokenCache tokenManager) : base()
+    public interface ISocketService
     {
-      this.logger = logger;
-      this.communicationManager = communicationManager;
-      this.tokenManager = tokenManager;
+        Task HandleSocketRequest(HttpContext context);
     }
 
-    public async Task HandleSocketRequest(HttpContext context)
+    /// <summary>
+    /// Services a single websocket connection. Authenticates the socket connection, accepts messages, and sends messages.
+    /// </summary>
+    public class SocketService : ISocketService
     {
-      if (!context.Request.Query.Keys.Contains("token"))
-      {
-        context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
-        return;
-      }
-      var token = Guid.Parse(context.Request.Query["token"][0]);
-      var userName = tokenManager.GetUsername(token);
+        private readonly ILogger<SocketService> logger;
+        private readonly ISocketConnectionManager communicationManager;
+        private readonly ISocketTokenCache tokenManager;
 
-      if (string.IsNullOrEmpty(userName))
-      {
-        context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
-        return;
-      }
-      var socket = await context.WebSockets.AcceptWebSocketAsync();
+        public SocketService(
+          ILogger<SocketService> logger,
+          ISocketConnectionManager communicationManager,
+          ISocketTokenCache tokenManager) : base()
+        {
+            this.logger = logger;
+            this.communicationManager = communicationManager;
+            this.tokenManager = tokenManager;
+        }
 
-      communicationManager.Subscribe(socket, userName);
-      while (socket.State == WebSocketState.Open)
-      {
-        try
+        public async Task HandleSocketRequest(HttpContext context)
         {
-          var message = await socket.ReceiveTextAsync();
-          if (string.IsNullOrWhiteSpace(message)) continue;
-          logger.LogInformation("Request \n{0}\n", message);
-          var request = JsonSerializer.Deserialize<ISocketRequest>(message);
-          if (request == null || !Enum.IsDefined(typeof(SocketAction), request.Action))
-          {
-            await socket.SendTextAsync("Error: Action not recognized.");
-            continue;
-          }
-          switch (request.Action)
-          {
-            default:
-              await socket.SendTextAsync($"Received your message with action {request.Action}, but did no work.");
-              break;
-          }
+            if (!context.Request.Query.Keys.Contains("token"))
+            {
+                context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
+                return;
+            }
+            var token = Guid.Parse(context.Request.Query["token"][0] ?? throw new InvalidOperationException("Token expected during socket connection request, but was not sent."));
+            var userName = tokenManager.GetUsername(token);
+
+            if (string.IsNullOrEmpty(userName))
+            {
+                context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
+                return;
+            }
+            var socket = await context.WebSockets.AcceptWebSocketAsync();
+
+            communicationManager.Subscribe(socket, userName);
+            // TODO: I probably don't need this while-loop anymore? Perhaps unsubscribe when a disconnect is detected instead.
+            while (socket.State.HasFlag(WebSocketState.Open))
+            {
+                try
+                {
+                    var message = await socket.ReceiveTextAsync();
+                    if (string.IsNullOrWhiteSpace(message)) continue;
+                    logger.LogInformation("Request \n{0}\n", message);
+                    var request = JsonSerializer.Deserialize<ISocketRequest>(message);
+                    if (request == null || !Enum.IsDefined(typeof(SocketAction), request.Action))
+                    {
+                        await socket.SendTextAsync("Error: Action not recognized.");
+                        continue;
+                    }
+                    switch (request.Action)
+                    {
+                        default:
+                            await socket.SendTextAsync($"Received your message with action {request.Action}, but did no work.");
+                            break;
+                    }
+                }
+                catch (OperationCanceledException ex)
+                {
+                    logger.LogError(ex.Message);
+                }
+                catch (WebSocketException ex)
+                {
+                    logger.LogInformation($"{nameof(WebSocketException)} in {nameof(SocketConnectionManager)}.");
+                    logger.LogInformation("Probably tried writing to a closed socket.");
+                    logger.LogError(ex.Message);
+                }
+                communicationManager.Unsubscribe(userName);
+
+                if (!socket.State.HasFlag(WebSocketState.Closed) && !socket.State.HasFlag(WebSocketState.Aborted))
+                {
+                    try
+                    {
+                        await socket.CloseAsync(WebSocketCloseStatus.NormalClosure,
+                            "Socket closed",
+                            CancellationToken.None);
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine($"Ignored exception during socket closing. {ex.Message}");
+                    }
+                }
+
+            }
         }
-        catch (OperationCanceledException ex)
-        {
-          logger.LogError(ex.Message);
-        }
-        catch (WebSocketException ex)
-        {
-          logger.LogInformation($"{nameof(WebSocketException)} in {nameof(SocketConnectionManager)}.");
-          logger.LogInformation("Probably tried writing to a closed socket.");
-          logger.LogError(ex.Message);
-        }
-        communicationManager.Unsubscribe(userName);
-      }
     }
-
-    public async Task<bool> ValidateRequestAndReplyIfInvalid<TRequest>(WebSocket socket, IValidator<TRequest> validator, TRequest request)
-    {
-      var results = validator.Validate(request);
-      if (!results.IsValid)
-      {
-        var errors = string.Join('\n', results.Errors.Select(_ => _.ErrorMessage));
-        await socket.SendTextAsync(errors);
-      }
-      return results.IsValid;
-    }
-  }
 }