Winify – Diff between revs 24 and 25

Subversion Repositories:

?pathlinks?

Rev 24 – Rev 26 – Go to most recent revision – Details – Blame – Last modification – View Log

         #endregion
+        #region Private Delegates, Events, Enums, Properties, Indexers and Fields
-        #region Private Delegates, Events, Enums, Properties, Indexers and Fields
+        private readonly Server _server;
-        private CancellationToken _cancellationToken;
-        private CancellationTokenSource _cancellationTokenSource;
+        private CancellationToken _cancellationToken;
-        private HttpClient _httpClient;
+        private CancellationTokenSource _cancellationTokenSource;
         private Task _runTask;
-        private ClientWebSocket _webSocketClient;
-        private readonly Server _server;
-        public GotifyConnection(Server server)
+        #endregion
-            _server = server;
+        #region Constructors, Destructors and Finalizers
         public GotifyConnection(Server server)
         #endregion
             _server = server;
-        #region Constructors, Destructors and Finalizers
-        public void Dispose()
-        {
-            if (_cancellationTokenSource != null)
-            {
-                _cancellationTokenSource.Dispose();
-                _cancellationTokenSource = null;
-            }
-            if (_webSocketClient != null)
-            {
                 _webSocketClient.Dispose();
                 _webSocketClient = null;
         public void Dispose()
+        {
-            if (_httpClient != null)
+            if (_cancellationTokenSource != null)
             {
-                _httpClient.Dispose();
+                _cancellationTokenSource.Dispose();
-                _httpClient = null;
+                _cancellationTokenSource = null;
+            }
+        }
             var webSocketsUri = webSocketsUriBuilder.Uri;
             _cancellationTokenSource = new CancellationTokenSource();
-            _cancellationToken = _cancellationTokenSource.Token;
-            _httpClient = new HttpClient();
-            var auth = Convert.ToBase64String(Encoding.Default.GetBytes($"{username}:{password}"));
-            _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", auth);
+            _cancellationToken = _cancellationTokenSource.Token;
-            _runTask = Run(webSocketsUri, httpUri, username, password, _cancellationToken);
+            _runTask = Run(webSocketsUri, httpUri, _server.Username, _server.Password, _cancellationToken);
+        }
         public void Stop()
+        {
             if (_cancellationTokenSource != null)
-            {
-                _cancellationTokenSource.Cancel();
+            {
                 _cancellationTokenSource.Cancel();
             _runTask.Wait(CancellationToken.None);
+            {
                 do
+                {
                     try
+                    {
-                        using (_webSocketClient = new ClientWebSocket())
+                        using (var webSocketClient = new ClientWebSocket())
+                        {
                             var auth = Convert.ToBase64String(Encoding.Default.GetBytes($"{username}:{password}"));
-                            _webSocketClient.Options.SetRequestHeader("Authorization", $"Basic {auth}");
+                            webSocketClient.Options.SetRequestHeader("Authorization", $"Basic {auth}");
-                            await _webSocketClient.ConnectAsync(webSocketsUri, cancellationToken);
+                            await webSocketClient.ConnectAsync(webSocketsUri, cancellationToken);
                             do
+                            {
                                 var payload = new ArraySegment<byte>(new byte[1024]);
-                                var result = await _webSocketClient.ReceiveAsync(payload, cancellationToken);
+                                var result = await webSocketClient.ReceiveAsync(payload, cancellationToken);
                                     continue;
+                                }
                                 var message = Encoding.UTF8.GetString(payload.Array, 0, payload.Count);
-                                var gotifyNotification = JsonConvert.DeserializeObject<GotifyNotification>(message);
+                                if (!(JsonConvert.DeserializeObject<GotifyNotification>(message) is GotifyNotification
-                                if (gotifyNotification == null)
+                                    gotifyNotification))
-                                {
-                                    continue;
-                                }
-                                gotifyNotification.Server = _server;
+                                {
-                                if (!Uri.TryCreate($"{httpUri}/application", UriKind.Absolute, out var applicationUri))
+                                    Log.Warning($"Could not deserialize gotify notification: {message}");
-                                {
-                                    continue;
-                                }
+                                    continue;
+                                }
                                 var applications = await _httpClient.GetStringAsync(applicationUri);
                                 gotifyNotification.Server = _server;
                                 var gotifyApplications =
-                                    JsonConvert.DeserializeObject<GotifyApplication[]>(applications);
-                                if (gotifyApplications == null)
-                                {
+                                if (!Uri.TryCreate($"{httpUri}/application", UriKind.Absolute,
-                                    continue;
-                                }
-                                foreach (var application in gotifyApplications)
-                                {
-                                    if (application.Id != gotifyNotification.AppId)
+                                    out var applicationUri))
-                                    {
-                                        continue;
-                                    }
-                                    if (!Uri.TryCreate($"{httpUri}/{application.Image}", UriKind.Absolute,
-                                        out var applicationImageUri))
-                                    {
-                                        continue;
-                                    }
-                                    var imageBytes = await _httpClient.GetByteArrayAsync(applicationImageUri);
-                                    if (imageBytes == null || imageBytes.Length == 0)
-                                    {
-                                        continue;
-                                    }
-                                    using (var memoryStream = new MemoryStream(imageBytes))
-                                    {
-                                        var image = Image.FromStream(memoryStream);
+                                {
+                                    continue;
                                         GotifyNotification?.Invoke(this,
                                             new GotifyNotificationEventArgs(gotifyNotification, image));
-                                    }
-                                    break;
+                                var image = await RetrieveGotifyApplicationImage(gotifyNotification.AppId, httpUri,
-                                }
-                                Log.Debug($"Notification message received: {gotifyNotification.Message}");
+                                    applicationUri, auth, cancellationToken);
                             } while (!cancellationToken.IsCancellationRequested);
                                 GotifyNotification?.Invoke(this,
-                            await _webSocketClient.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty,
-                                CancellationToken.None);
                                     new GotifyNotificationEventArgs(gotifyNotification, image));
-                        _webSocketClient = null;
-                    }
-                    catch (Exception ex) when (ex is WebSocketException || ex is HttpRequestException)
-                    {
-                        Log.Warning($"Unable to connect to gotify server: {ex.Message}");
                                 Log.Debug($"Notification message received: {gotifyNotification.Message}");
-                        // Reconnect
+                            } while (!cancellationToken.IsCancellationRequested);
                         if (_webSocketClient != null)
+                    }
+            }
             catch (Exception ex)
+            {
                 Log.Warning(ex, "Failure running connection loop.");
+            }
+            var e = "o";
+        }
+        private static async Task<Image> RetrieveGotifyApplicationImage(int appId, Uri httpUri, Uri applicationUri,
+                                                                        string auth,
+                                                                        CancellationToken cancellationToken)
+        {
+            using (var httpClient = new HttpClient())
+            {
+                httpClient.DefaultRequestHeaders.Authorization =
+                    new AuthenticationHeaderValue("Basic", auth);
+                var applicationResponse = await httpClient.GetAsync(applicationUri, cancellationToken);
+                var applications = await applicationResponse.Content.ReadAsStringAsync();
+                var gotifyApplications =
+                    JsonConvert.DeserializeObject<GotifyApplication[]>(applications);
+                if (gotifyApplications == null)
+                {
+                    return null;
+                }
+                foreach (var application in gotifyApplications)
+                {
+                    if (application.Id != appId)
+                    {
+                        continue;
+                    }
+                    if (!Uri.TryCreate($"{httpUri}/{application.Image}", UriKind.Absolute,
+                        out var applicationImageUri))
+                    {
+                        continue;
+                    }
+                    var imageResponse = await httpClient.GetAsync(applicationImageUri, cancellationToken);
+                    using (var memoryStream = new MemoryStream())
+                    {
+                        await imageResponse.Content.CopyToAsync(memoryStream);
+                        return Image.FromStream(memoryStream);
+                    }
+                }
+            }
+            return null;
+        }
         #endregion
+    }
+}