Winify – Diff between revs 39 and 44

Subversion Repositories:

?pathlinks?

Rev 39 – Rev 46 – 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 WebSocketSharp;
+using Configuration = Configuration.Configuration;
-using ClientWebSocket = System.Net.WebSockets.Managed.ClientWebSocket;
+using ErrorEventArgs = WebSocketSharp.ErrorEventArgs;
 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 Task _runTask;
         private HttpClient _httpClient;
-        private readonly string _auth;
         private readonly Uri _webSocketsUri;
         private readonly Uri _httpUri;
+        private WebSocket _webSocketSharp;
+        private readonly global::Configuration.Configuration _configuration;
         #endregion
         #region Constructors, Destructors and Finalizers
-        public GotifyConnection()
+        private GotifyConnection()
-        {
+        {
             _httpClient = new HttpClient();
         }
-        public GotifyConnection(Server server) : this()
+        public GotifyConnection(Server server, global::Configuration.Configuration configuration) : this()
+        {
+            _server = server;
+            _configuration = configuration;
+            var httpClientHandler = new HttpClientHandler();
+            _httpClient = new HttpClient(httpClientHandler);
+            if (_configuration.IgnoreSelfSignedCertificates)
+            {
+                httpClientHandler.ServerCertificateCustomValidationCallback =
-        {
+                    HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
+            }
-            _server = server;
+            _httpClient = new HttpClient(httpClientHandler)
+            {
+                DefaultRequestHeaders =
+                {
+                    Authorization = new AuthenticationHeaderValue("Basic",
-            _auth = Convert.ToBase64String(Encoding.Default.GetBytes($"{_server.Username}:{_server.Password}"));
+                        Convert.ToBase64String(Encoding.Default.GetBytes($"{_server.Username}:{_server.Password}")))
             _httpClient.DefaultRequestHeaders.Authorization =
-                new AuthenticationHeaderValue("Basic", _auth);
+            };
             if (Uri.TryCreate(_server.Url, UriKind.Absolute, out _httpUri))
+            {
                 // Build the web sockets URI.
                 var webSocketsUriBuilder = new UriBuilder(_httpUri);
+                switch (webSocketsUriBuilder.Scheme.ToUpperInvariant())
+                {
+                    case "HTTP":
-                webSocketsUriBuilder.Scheme = "ws";
+                        webSocketsUriBuilder.Scheme = "ws";
+                        break;
+                    case "HTTPS":
+                        webSocketsUriBuilder.Scheme = "wss";
+                        break;
+                }
                 webSocketsUriBuilder.Path = Path.Combine(webSocketsUriBuilder.Path, "stream");
                 _webSocketsUri = webSocketsUriBuilder.Uri;
+            }
+        }
         public void Dispose()
+        {
             if (_cancellationTokenSource != null)
+            {
                 _cancellationTokenSource.Dispose();
                 _cancellationTokenSource = null;
+            }
+            _webSocketSharp.Close();
+            _webSocketSharp = null;
             _httpClient.Dispose();
             _httpClient = null;
+        }
         #endregion
         #region Public Methods
         public void Start()
+        {
             _cancellationTokenSource = new CancellationTokenSource();
             _cancellationToken = _cancellationTokenSource.Token;
+            Connect();
             _runTask = Run(_cancellationToken);
+        }
-        public void Stop()
+        private void Connect()
+        {
+            _webSocketSharp = new WebSocket(_webSocketsUri.AbsoluteUri);
-        {
+            _webSocketSharp.SetCredentials(_server.Username, _server.Password, true);
-            if (_cancellationTokenSource != null)
+            if (_configuration.IgnoreSelfSignedCertificates)
+            {
-            {
+                _webSocketSharp.SslConfiguration.ServerCertificateValidationCallback +=
-                _cancellationTokenSource.Cancel();
+                    (sender, certificate, chain, errors) => true;
+            }
+            _webSocketSharp.OnMessage += WebSocketSharp_OnMessage;
+            _webSocketSharp.OnError += WebSocketSharp_OnError;
+            _webSocketSharp.OnOpen += WebSocketSharp_OnOpen;
+            _webSocketSharp.OnClose += WebSocketSharp_OnClose;
+            _webSocketSharp.ConnectAsync();
+        }
+        private void WebSocketSharp_OnClose(object sender, CloseEventArgs e)
+        {
+            Log.Information($"Connection to server closed with reason: {e.Reason}");
+        }
+        private void WebSocketSharp_OnOpen(object sender, EventArgs e)
+        {
+            Log.Information("Connection to server is now open.");
+        }
+        private async void WebSocketSharp_OnError(object sender, ErrorEventArgs e)
+        {
+            if (_cancellationToken.IsCancellationRequested)
+            {
+                Stop();
+                return;
+            }
+            await Task.Delay(TimeSpan.FromSeconds(1), _cancellationToken);
+            Log.Information("Reconnecting to websocket server.");
+            Connect();
+        }
+        private async void WebSocketSharp_OnMessage(object sender, MessageEventArgs e)
+        {
+            if (e.RawData.Length == 0)
+            {
+                Log.Warning($"Empty message received from server.");
+                return;
+            }
+            var message = Encoding.UTF8.GetString(e.RawData, 0, e.RawData.Length);
+            GotifyNotification gotifyNotification;
+            try
+            {
+                gotifyNotification = JsonConvert.DeserializeObject<GotifyNotification>(message);
+            }
+            catch (JsonSerializationException exception)
+            {
+                Log.Warning($"Could not deserialize notification: {exception.Message}");
+                return;
+            }
+            if (gotifyNotification == null)
+            {
+                Log.Warning($"Could not deserialize gotify notification: {message}");
+                return;
+            }
+            gotifyNotification.Server = _server;
+            if (!Uri.TryCreate(Path.Combine($"{_httpUri}", "application"), UriKind.Absolute,
+                    out var applicationUri))
+            {
+                Log.Warning($"Could not build an URI to an application.");
+                return;
+            }
+            using (var imageStream =
+                   await RetrieveGotifyApplicationImage(gotifyNotification.AppId, applicationUri, _cancellationToken))
+            {
+                if (imageStream == null)
+                {
+                    Log.Warning("Could not find any application image for notification.");
+                    return;
+                }
+                var image = Image.FromStream(imageStream);
+                GotifyNotification?.Invoke(this,
+                    new GotifyNotificationEventArgs(gotifyNotification, image));
+            }
+            Log.Debug($"Notification message received: {gotifyNotification.Message}");
+        }
+        public void Stop()
+        {
             if (_cancellationTokenSource != null) _cancellationTokenSource.Cancel();
+        }
         #endregion
         #region Private Methods
         private async Task Run(CancellationToken cancellationToken)
+        {
             try
+            {
                 do
+                {
-                    try
-                    {
-                        using (var webSocketClient = new ClientWebSocket())
-                        {
-                            webSocketClient.Options.SetRequestHeader("Authorization", $"Basic {_auth}");
-                            await webSocketClient.ConnectAsync(_webSocketsUri, cancellationToken);
-                            do
-                            {
-                                var payload = new ArraySegment<byte>(new byte[1024]);
-                                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 (gotifyNotification == null)
-                                {
-                                    Log.Warning($"Could not deserialize gotify notification: {message}");
-                                    continue;
-                                }
-                                gotifyNotification.Server = _server;
-                                if (!Uri.TryCreate(Path.Combine($"{_httpUri}", "application"), UriKind.Absolute,
-                                        out var applicationUri))
-                                {
-                                    continue;
-                                }
-                                var image = await RetrieveGotifyApplicationImage(gotifyNotification.AppId,
-                                    applicationUri, cancellationToken);
-                                GotifyNotification?.Invoke(this,
-                                    new GotifyNotificationEventArgs(gotifyNotification, image));
-                                Log.Debug($"Notification message received: {gotifyNotification.Message}");
-                            } while (!cancellationToken.IsCancellationRequested);
-                        }
-                    }
-                    catch (Exception ex) when (ex is WebSocketException || ex is HttpRequestException)
-                    {
-                        // Reconnect
-                        Log.Warning($"Unable to connect to gotify server: {ex.Message}");
-                        await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
+                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
-                    }
                 } while (!cancellationToken.IsCancellationRequested);
+            }
-            catch (Exception ex) when (ex is OperationCanceledException || ex is ObjectDisposedException)
+            catch (Exception exception) when (exception is OperationCanceledException || exception is ObjectDisposedException)
+            {
+            }
-            catch (Exception ex)
+            catch (Exception exception)
+            {
-                Log.Warning(ex, "Failure running connection loop.");
+                Log.Warning(exception, "Failure running connection loop.");
+            }
+        }
-        private async Task<Image> RetrieveGotifyApplicationImage(int appId, Uri applicationUri,
+        private async Task<Stream> RetrieveGotifyApplicationImage(int appId, Uri applicationUri,
             CancellationToken cancellationToken)
+        {
             var applicationResponse = await _httpClient.GetAsync(applicationUri, cancellationToken);
             var applications = await applicationResponse.Content.ReadAsStringAsync();
-            var gotifyApplications =
-                JsonConvert.DeserializeObject<GotifyApplication[]>(applications);
+            GotifyApplication[] gotifyApplications;
-            if (gotifyApplications == null)
+            try
+            {
+                gotifyApplications =
+                    JsonConvert.DeserializeObject<GotifyApplication[]>(applications);
+            }
+            catch (JsonSerializationException exception)
+            {
+                Log.Warning($"Could not deserialize the list of applications from the server: {exception.Message}");
                 return null;
+            }
             foreach (var application in gotifyApplications)
+            {
-                if (application.Id != appId)
+                if (application.Id != appId) continue;
-                {
-                    continue;
-                }
                 if (!Uri.TryCreate(Path.Combine($"{_httpUri}", $"{application.Image}"), UriKind.Absolute,
                         out var applicationImageUri))
+                {
+                    Log.Warning("Could not build URL path to application icon.");
                     continue;
+                }
                 var imageResponse = await _httpClient.GetAsync(applicationImageUri, cancellationToken);
-                using (var memoryStream = new MemoryStream())
-                {
-                    await imageResponse.Content.CopyToAsync(memoryStream);
+                var memoryStream = new MemoryStream();
+                await imageResponse.Content.CopyToAsync(memoryStream);
                     return Image.FromStream(memoryStream);
                 return memoryStream;
+            }
             return null;
+        }
         #endregion
+    }
+}
 Generated by GNU Enscript 1.6.5.90.