Changed various locking mechanisms.

Twitch/Socket/Handlers/SessionWelcomeHandler.cs

@@ -39,7 +39,7 @@ namespace TwitchChatTTS.Twitch.Socket.Handlers
                 _logger.Warning($"Twitch connection has {timeLeft} before it is revoked. Refreshing the token is soon required.");
             else
             {
-                _logger.Error("Twitch connection has its permissions revoked. Refresh the token. Twitch client will not be connecting.");
+                _logger.Error($"Twitch connection has its permissions revoked. Refresh the token. Twitch client will not be connecting. [expired at: {twitchConnection.ExpiresAt}]");
                 return;
             }
 

Twitch/Socket/TwitchConnectionManager.cs

@@ -18,21 +18,22 @@ namespace TwitchChatTTS.Twitch.Socket
         private readonly IServiceProvider _serviceProvider;
         private readonly ILogger _logger;
 
-        private readonly object _lock;
+        private readonly Mutex _mutex;
 
         public TwitchConnectionManager(IServiceProvider serviceProvider, ILogger logger)
         {
             _serviceProvider = serviceProvider;
             _logger = logger;
 
-            _lock = new object();
+            _mutex = new Mutex();
         }
 
 
         public TwitchWebsocketClient GetBackupClient()
         {
-            lock (_lock)
+            try
             {
+                _mutex.WaitOne();
                 if (_identified == null)
                     throw new InvalidOperationException("Cannot get backup Twitch client yet. Waiting for identification.");
                 if (_backup != null)
@@ -40,12 +41,17 @@ namespace TwitchChatTTS.Twitch.Socket
 
                 return CreateNewClient();
             }
+            finally
+            {
+                _mutex.ReleaseMutex();
+            }
         }
 
         public TwitchWebsocketClient GetWorkingClient()
         {
-            lock (_lock)
+            try
             {
+                _mutex.WaitOne();
                 if (_identified == null)
                 {
                     return CreateNewClient();
@@ -53,6 +59,10 @@ namespace TwitchChatTTS.Twitch.Socket
 
                 return _identified;
             }
+            finally
+            {
+                _mutex.ReleaseMutex();
+            }
         }
 
         private TwitchWebsocketClient CreateNewClient()
@@ -74,8 +84,9 @@ namespace TwitchChatTTS.Twitch.Socket
         private async Task OnDisconnection(TwitchWebsocketClient client)
         {
             bool reconnecting = false;
-            lock (_lock)
+            try
             {
+                _mutex.WaitOne();
                 if (_identified?.UID == client.UID)
                 {
                     _logger.Debug($"Identified Twitch client has disconnected [client: {client.UID}][main: {_identified.UID}][backup: {_backup?.UID}]");
@@ -92,19 +103,25 @@ namespace TwitchChatTTS.Twitch.Socket
                 else
                     _logger.Warning($"Twitch client disconnected from unknown source [client: {client.UID}][main: {_identified?.UID}][backup: {_backup?.UID}]");
             }
+            finally
+            {
+                _mutex.ReleaseMutex();
+            }
 
             if (reconnecting)
             {
                 var newClient = GetWorkingClient();
                 await newClient.Reconnect();
             }
+
         }
 
         private async Task OnIdentified(TwitchWebsocketClient client)
         {
             bool clientDisconnect = false;
-            lock (_lock)
+            try
             {
+                _mutex.WaitOne();
                 if (_identified == null || _identified.ReceivedReconnecting)
                 {
                     if (_backup != null && _backup.UID == client.UID)
@@ -125,10 +142,14 @@ namespace TwitchChatTTS.Twitch.Socket
                     _logger.Warning($"Twitch client has been identified, but isn't main or backup [client: {client.UID}][main: {_identified.UID}][backup: {_backup?.UID}]");
                     clientDisconnect = true;
                 }
-            }
 
-            if (clientDisconnect)
-                await client.DisconnectAsync(new SocketDisconnectionEventArgs("Closed", "No need for a tertiary client."));
+                if (clientDisconnect)
+                    client.DisconnectAsync(new SocketDisconnectionEventArgs("Closed", "No need for a tertiary client.")).Wait();
+            }
+            finally
+            {
+                _mutex.ReleaseMutex();
+            }
         }
     }
 }

Twitch/Socket/TwitchWebsocketClient.cs

@@ -17,15 +17,11 @@ namespace TwitchChatTTS.Twitch.Socket
         private readonly IDictionary<string, string> _subscriptions;
         private readonly IBackoff _backoff;
         private readonly Configuration _configuration;
-        private bool _disconnected;
-        private readonly object _lock;
 
         public event EventHandler<EventArgs>? OnIdentified;
 
         public string UID { get; }
         public string URL;
-        public bool Connected { get; private set; }
-        public bool Identified { get; private set; }
         public string? SessionId { get; private set; }
         public bool ReceivedReconnecting { get; set; }
         public bool TwitchReconnected { get; set; }
@@ -46,13 +42,14 @@ namespace TwitchChatTTS.Twitch.Socket
             _backoff = backoff;
             _configuration = configuration;
             _subscriptions = new Dictionary<string, string>();
-            _lock = new object();
 
-            _messageTypes = new Dictionary<string, Type>();
-            _messageTypes.Add("session_keepalive", typeof(object));
-            _messageTypes.Add("session_welcome", typeof(SessionWelcomeMessage));
-            _messageTypes.Add("session_reconnect", typeof(SessionWelcomeMessage));
-            _messageTypes.Add("notification", typeof(NotificationMessage));
+            _messageTypes = new Dictionary<string, Type>
+            {
+                { "session_keepalive", typeof(object) },
+                { "session_welcome", typeof(SessionWelcomeMessage) },
+                { "session_reconnect", typeof(SessionWelcomeMessage) },
+                { "notification", typeof(NotificationMessage) }
+            };
 
             UID = Guid.NewGuid().ToString("D");
 
@@ -88,25 +85,12 @@ namespace TwitchChatTTS.Twitch.Socket
             _logger.Information($"Initializing Twitch websocket client.");
             OnConnected += (sender, e) =>
             {
-                Connected = true;
                 _logger.Information("Twitch websocket client connected.");
-                _disconnected = false;
             };
 
             OnDisconnected += (sender, e) =>
             {
-                lock (_lock)
-                {
-                    if (_disconnected)
-                        return;
-
-                    _disconnected = true;
-                }
-
                 _logger.Information($"Twitch websocket client disconnected [status: {e.Status}][reason: {e.Reason}][client: {UID}]");
-
-                Connected = false;
-                Identified = false;
             };
         }
 
@@ -126,7 +110,6 @@ namespace TwitchChatTTS.Twitch.Socket
 
         public void Identify(string sessionId)
         {
-            Identified = true;
             SessionId = sessionId;
             OnIdentified?.Invoke(this, EventArgs.Empty);
         }