Websocket exception handling

Author: theSlyest

Parse/Abstractions/Infrastructure/Execution/IWebSocketClient.cs

@@ -1,6 +1,8 @@
 using System;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using Parse.Infrastructure.Execution;
 
 namespace Parse.Abstractions.Infrastructure.Execution;
 
@@ -16,7 +18,26 @@ public interface IWebSocketClient
     /// The event handler receives the message as a string parameter. This can be used to process incoming
     /// WebSocket messages, such as notifications, commands, or data updates.
     /// </remarks>
-    public event EventHandler<string> MessageReceived;
+    public event EventHandler<MessageReceivedEventArgs> MessageReceived;
+
+    /// <summary>
+    /// An event that is triggered when an error occurs during the WebSocket operation.
+    /// </summary>
+    /// <remarks>
+    /// This event communicates WebSocket-specific errors along with additional details encapsulated in
+    /// the <see cref="ErrorEventArgs"/> object. It can be used to handle and log errors during WebSocket
+    /// communication or connection lifecycle.
+    /// </remarks>
+    public event EventHandler<ErrorEventArgs> WebsocketError;
+
+    /// <summary>
+    /// An event that is triggered when an unknown or unexpected error occurs during WebSocket communication.
+    /// </summary>
+    /// <remarks>
+    /// This event can be used to handle errors that do not fall under typical WebSocket error events. The event
+    /// handler receives an <see cref="ErrorEventArgs"/> parameter containing details about the error.
+    /// </remarks>
+    public event EventHandler<ErrorEventArgs> UnknownError;
 
     /// <summary>
     /// Establishes a WebSocket connection to the specified server URI.

Parse/Infrastructure/Execution/MessageReceivedEventArgs.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace Parse.Infrastructure.Execution;
+
+/// <summary>
+/// Provides data for the event that is triggered when a message is received.
+/// </summary>
+public class MessageReceivedEventArgs(string message) : EventArgs
+{
+    /// <summary>
+    /// Gets the message content that was received.
+    /// </summary>
+    public string Message { get; } = message;
+}

Parse/Infrastructure/Execution/TextWebSocketClient.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Diagnostics;
+using System.IO;
+using System.Net;
 using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
@@ -39,7 +41,9 @@ class TextWebSocketClient(int bufferSize) : IWebSocketClient
     /// represented as a string. Handlers for this event can process or respond to the message
     /// based on the application's requirements.
     /// </summary>
-    public event EventHandler<string> MessageReceived;
+    public event EventHandler<MessageReceivedEventArgs> MessageReceived;
+    public event EventHandler<ErrorEventArgs> WebsocketError;
+    public event EventHandler<ErrorEventArgs> UnknownError;
 
     private readonly object connectionLock = new object();
 
@@ -111,7 +115,7 @@ private async Task ListenForMessages(CancellationToken cancellationToken)
                 if (result.EndOfMessage)
                 {
                     string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
-                    MessageReceived?.Invoke(this, message);
+                    MessageReceived?.Invoke(this, new MessageReceivedEventArgs(message));
                 }
                 else
                 {
@@ -126,7 +130,7 @@ private async Task ListenForMessages(CancellationToken cancellationToken)
                         messageBuilder.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));
                     }
                     string fullMessage = messageBuilder.ToString();
-                    MessageReceived?.Invoke(this, fullMessage);
+                    MessageReceived?.Invoke(this, new MessageReceivedEventArgs(fullMessage));;
                 }
             }
         }
@@ -135,15 +139,17 @@ private async Task ListenForMessages(CancellationToken cancellationToken)
             // Normal cancellation, no need to handle
             Debug.WriteLine($"Websocket connection was closed: {ex.Message}");
         }
-        catch (WebSocketException e)
+        catch (WebSocketException ex)
         {
             // WebSocket error, notify the user
-            Debug.WriteLine($"Websocket error: {e.Message}");
+            Debug.WriteLine($"Websocket error ({ex.ErrorCode}): {ex.Message}");
+            WebsocketError?.Invoke(this, new ErrorEventArgs(ex));
         }
-        catch (Exception e)
+        catch (Exception ex)
         {
             // Unexpected error, notify the user
-            Debug.WriteLine($"Unexpected error in Websocket listener: {e.Message}");
+            Debug.WriteLine($"Unexpected error in Websocket listener: {ex.Message}");
+            UnknownError?.Invoke(this, new ErrorEventArgs(ex));
         }
         Debug.WriteLine("Websocket ListenForMessage stopped");
     }

Parse/Platform/LiveQueries/ParseLiveQueryController.cs

@@ -2,13 +2,16 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using Parse.Abstractions.Infrastructure.Data;
 using Parse.Abstractions.Infrastructure.Execution;
 using Parse.Abstractions.Platform.LiveQueries;
 using Parse.Infrastructure.Data;
+using Parse.Infrastructure.Execution;
 using Parse.Infrastructure.Utilities;
 
 namespace Parse.Platform.LiveQueries;
@@ -133,6 +136,7 @@ private void ProcessMessage(IDictionary<string, object> message)
 
         switch (op)
         {
+            // CONNECTION
             case "connected":
                 ProcessConnectionMessage(message);
                 break;
@@ -354,16 +358,16 @@ private async Task OpenAsync(CancellationToken cancellationToken = default)
         await WebSocketClient.OpenAsync(ParseClient.Instance.Services.LiveQueryServerConnectionData.ServerURI, cancellationToken);
     }
 
-    private void WebSocketClientOnMessageReceived(object sender, string e)
+    private void WebSocketClientOnMessageReceived(object sender, MessageReceivedEventArgs args)
     {
-        object parsed = JsonUtilities.Parse(e);
+        object parsed = JsonUtilities.Parse(args.Message);
         if (parsed is IDictionary<string, object> message)
         {
             ProcessMessage(message);
         }
         else
         {
-            Debug.WriteLine($"Invalid message format received: {e}");
+            Debug.WriteLine($"Invalid message format received: {args.Message}");
         }
     }
 
@@ -386,6 +390,8 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
             _state = ParseLiveQueryState.Connecting;
             await OpenAsync(cancellationToken);
             WebSocketClient.MessageReceived += WebSocketClientOnMessageReceived;
+            WebSocketClient.WebsocketError += WebSocketClientOnWebsocketError;
+            WebSocketClient.UnknownError += WebSocketClientOnUnknownError;
             Dictionary<string, object> message = new Dictionary<string, object>
             {
                 { "op", "connect" },
@@ -423,6 +429,22 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
         }
     }
 
+    void WebSocketClientOnWebsocketError(object sender, ErrorEventArgs args)
+    {
+        if (args.GetException() is WebSocketException ex)
+        {
+            Error?.Invoke(this, new ParseLiveQueryErrorEventArgs(ex.ErrorCode, ex.Message, false, ex));
+        }
+    }
+
+    void WebSocketClientOnUnknownError(object sender, ErrorEventArgs args)
+    {
+        if (args.GetException() is { } ex)
+        {
+            Error?.Invoke(this, new ParseLiveQueryErrorEventArgs(-1, ex.Message, false, ex));
+        }
+    }
+
     private async Task SendAndWaitForSignalAsync(IDictionary<string, object> message,
         ConcurrentDictionary<int, TaskCompletionSource> signalDictionary,
         int requestId,
@@ -560,6 +582,8 @@ public async Task UnsubscribeAsync(int requestId, CancellationToken cancellation
     public async Task CloseAsync(CancellationToken cancellationToken = default)
     {
         WebSocketClient.MessageReceived -= WebSocketClientOnMessageReceived;
+        WebSocketClient.WebsocketError -= WebSocketClientOnWebsocketError;
+        WebSocketClient.UnknownError -= WebSocketClientOnUnknownError;
         await WebSocketClient.CloseAsync(cancellationToken);
         _state = ParseLiveQueryState.Closed;
         SubscriptionSignals.Clear();

Parse/Platform/LiveQueries/ParseLiveQueryDualEventArgs.cs

@@ -15,7 +15,7 @@ public class ParseLiveQueryDualEventArgs : ParseLiveQueryEventArgs
     /// providing a snapshot of its previous state for comparison purposes during events
     /// such as updates or deletes.
     /// </summary>
-    public ParseObject Original { get; private set; }
+    public ParseObject Original { get; }
 
     internal ParseLiveQueryDualEventArgs(ParseObject current, ParseObject original) : base(current) =>
         Original = original ?? throw new ArgumentNullException(nameof(original));

Parse/Platform/LiveQueries/ParseLiveQueryErrorEventArgs.cs

@@ -15,7 +15,7 @@ public class ParseLiveQueryErrorEventArgs : EventArgs
     /// a live query operation. It can provide detailed information about the nature of the issue,
     /// which can be helpful for debugging or logging purposes.
     /// </remarks>
-    public string Error { get; private set; }
+    public string Error { get; }
 
     /// <summary>
     /// Gets or sets the error code associated with a live query operation.
@@ -25,7 +25,7 @@ public class ParseLiveQueryErrorEventArgs : EventArgs
     /// the type or category of the error that occurred during a live query operation.
     /// This is used alongside the error message to provide detailed diagnostics or logging.
     /// </remarks>
-    public int Code { get; private set; }
+    public int Code { get; }
 
     /// <summary>
     /// Gets or sets a value indicating whether the client should attempt to reconnect
@@ -37,15 +37,18 @@ public class ParseLiveQueryErrorEventArgs : EventArgs
     /// This can be used to determine the client's behavior in maintaining a continuous
     /// connection with the server.
     /// </remarks>
-    public bool Reconnect { get; private set; }
+    public bool Reconnect { get; }
+
+    public Exception LocalException { get; }
 
     /// <summary>
     /// Represents the arguments for an error event that occurs during a live query in the Parse platform.
     /// </summary>
-    internal ParseLiveQueryErrorEventArgs(int code, string error, bool reconnect)
+    internal ParseLiveQueryErrorEventArgs(int code, string error, bool reconnect, Exception localException = null)
     {
         Error = error;
         Code = code;
         Reconnect = reconnect;
+        LocalException = localException;
     }
 }

Parse/Platform/LiveQueries/ParseLiveQueryEventArgs.cs

@@ -15,7 +15,7 @@ public class ParseLiveQueryEventArgs : EventArgs
     /// the event was triggered, reflecting any changes made during operations such as
     /// an update or creation.
     /// </summary>
-    public ParseObject Object { get; private set; }
+    public ParseObject Object { get; }
 
     internal ParseLiveQueryEventArgs(ParseObject current) => Object = current ?? throw new ArgumentNullException(nameof(current));
 }