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

Only display areas with differences – Ignore whitespace

 ï»¿using System;
 using System.Drawing;
 using System.IO;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 using Serilog;
 using Servers;
 using ClientWebSocket = System.Net.WebSockets.Managed.ClientWebSocket;
 namespace Winify.Gotify
+{
     public class GotifyConnection : IDisposable
+    {
         #region Public Events & Delegates
         public event EventHandler<GotifyNotificationEventArgs> GotifyNotification;
         #endregion
         #region Private Delegates, Events, Enums, Properties, Indexers and Fields
+        private readonly Server _server;
         private CancellationToken _cancellationToken;
         private CancellationTokenSource _cancellationTokenSource;
-        private HttpClient _httpClient;
         private Task _runTask;
-        private ClientWebSocket _webSocketClient;
+        #endregion
-        private readonly Server _server;
+        #region Constructors, Destructors and Finalizers
         public GotifyConnection(Server server)
+        {
             _server = server;
+        }
-        #endregion
-        #region Constructors, Destructors and Finalizers
         public void Dispose()
+        {
             if (_cancellationTokenSource != null)
+            {
                 _cancellationTokenSource.Dispose();
                 _cancellationTokenSource = null;
+            }
-            if (_webSocketClient != null)
-            {
-                _webSocketClient.Dispose();
-                _webSocketClient = null;
-            }
-            if (_httpClient != null)
-            {
-                _httpClient.Dispose();
-                _httpClient = null;
-            }
+        }
         #endregion
         #region Public Methods
-        public void Start(string username, string password, string url)
+        public void Start()
         {
-            if (!Uri.TryCreate(url, UriKind.Absolute, out var httpUri))
+            if (!Uri.TryCreate(_server.Url, UriKind.Absolute, out var httpUri))
+            {
                 return;
+            }
             // Build the web sockets URI.
             var webSocketsUriBuilder = new UriBuilder(httpUri);
             webSocketsUriBuilder.Scheme = "ws";
             webSocketsUriBuilder.Path = $"{webSocketsUriBuilder.Path}/stream";
             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);
-            _runTask = Run(webSocketsUri, httpUri, username, password, _cancellationToken);
+            _runTask = Run(webSocketsUri, httpUri, _server.Username, _server.Password, _cancellationToken);
+        }
         public void Stop()
+        {
             if (_cancellationTokenSource != null)
+            {
                 _cancellationTokenSource.Cancel();
+            }
-            _runTask.Wait(CancellationToken.None);
+        }
         #endregion
         #region Private Methods
         private async Task Run(Uri webSocketsUri, Uri httpUri, string username, string password,
                                CancellationToken cancellationToken)
+        {
             try
+            {
                 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);
                                 if (result.Count == 0)
+                                {
                                     continue;
+                                }
                                 if (payload.Array == null || payload.Count == 0)
+                                {
                                     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;
+                                }
-                                var applications = await _httpClient.GetStringAsync(applicationUri);
+                                gotifyNotification.Server = _server;
-                                var gotifyApplications =
-                                    JsonConvert.DeserializeObject<GotifyApplication[]>(applications);
+                                if (!Uri.TryCreate($"{httpUri}/application", UriKind.Absolute,
-                                if (gotifyApplications == null)
+                                    out var applicationUri))
+                                {
                                     continue;
+                                }
-                                foreach (var application in gotifyApplications)
-                                {
-                                    if (application.Id != gotifyNotification.AppId)
-                                    {
-                                        continue;
-                                    }
-                                    if (!Uri.TryCreate($"{httpUri}/{application.Image}", UriKind.Absolute,
+                                var image = await RetrieveGotifyApplicationImage(gotifyNotification.AppId, httpUri,
-                                        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);
-                                        GotifyNotification?.Invoke(this,
-                                            new GotifyNotificationEventArgs(gotifyNotification, image));
-                                    }
+                                    applicationUri, auth, cancellationToken);
-                                    break;
+                                GotifyNotification?.Invoke(this,
                                     new GotifyNotificationEventArgs(gotifyNotification, image));
                                 Log.Debug($"Notification message received: {gotifyNotification.Message}");
                             } while (!cancellationToken.IsCancellationRequested);
-                            await _webSocketClient.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty,
-                                CancellationToken.None);
+                        }
-                        _webSocketClient = null;
+                    }
                     catch (Exception ex) when (ex is WebSocketException || ex is HttpRequestException)
+                    {
-                        Log.Warning($"Unable to connect to gotify server: {ex.Message}");
                         // Reconnect
-                        if (_webSocketClient != null)
-                        {
-                            _webSocketClient.Abort();
-                            _webSocketClient.Dispose();
+                        Log.Warning($"Unable to connect to gotify server: {ex.Message}");
-                            _webSocketClient = null;
-                        }
                         await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
+                    }
                 } while (!cancellationToken.IsCancellationRequested);
+            }
             catch (Exception ex) when (ex is OperationCanceledException || ex is ObjectDisposedException)
+            {
+            }
             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
+    }
+}
 Generated by GNU Enscript 1.6.5.90.