Winify – Diff between revs 54 and 59

Subversion Repositories:

?pathlinks?

Rev 54 – Rev 61 – Go to most recent revision – Details – Blame – Last modification – View Log

 using System.Drawing;
 using System.IO;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Net.Security;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 using Serilog;
 using Servers;
 using WebSocketSharp;
 using WebSocketSharp.Net;
-using static System.Windows.Forms.VisualStyles.VisualStyleElement.StartPanel;
-using Configuration = Configuration.Configuration;
 using ErrorEventArgs = WebSocketSharp.ErrorEventArgs;
 using NetworkCredential = System.Net.NetworkCredential;
 namespace Winify.Gotify
         private readonly Uri _webSocketsUri;
         private readonly Uri _httpUri;
+        private WebSocket _webSocketSharp;
-        private WebSocket _webSocketSharp;
+        private readonly Configuration.Configuration _configuration;
-        private readonly global::Configuration.Configuration _configuration;
+        private Task _initTask;
         #endregion
         #region Constructors, Destructors and Finalizers
+        #region Constructors, Destructors and Finalizers
         private GotifyConnection()
         private GotifyConnection()
+        {
+        }
-        public GotifyConnection(Server server, global::Configuration.Configuration configuration) : this()
+        public GotifyConnection(Server server, Configuration.Configuration configuration) : this()
+        {
             _server = server;
             _configuration = configuration;
             ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
-            var httpClientHandler = new HttpClientHandler()
             var httpClientHandler = new HttpClientHandler
                 // mono does not implement this
-                //SslProtocols = SslProtocols.Tls12
-            };
+                // mono does not implement this
-            _httpClient = new HttpClient(httpClientHandler);
+                //SslProtocols = SslProtocols.Tls12
-            if (_configuration.IgnoreSelfSignedCertificates)
+            };
-            {
                 httpClientHandler.ServerCertificateCustomValidationCallback =
-                    (httpRequestMessage, cert, cetChain, policyErrors) => true;
+            _httpClient = new HttpClient(httpClientHandler);
-            }
             if (_configuration.IgnoreSelfSignedCertificates)
-            if (_configuration.Proxy.Enable)
+                httpClientHandler.ServerCertificateCustomValidationCallback =
-            {
-                httpClientHandler.Proxy = new WebProxy(_configuration.Proxy.Url, false, new string[] { },
+                    (httpRequestMessage, cert, cetChain, policyErrors) => true;
                     new NetworkCredential(_configuration.Proxy.Username, _configuration.Proxy.Password));
             if (_configuration.Proxy.Enable)
                 httpClientHandler.Proxy = new WebProxy(_configuration.Proxy.Url, false, new string[] { },
+            {
                 webSocketsUriBuilder.Path = Path.Combine(webSocketsUriBuilder.Path, "stream");
+            }
             catch (ArgumentException exception)
+            {
+                Log.Error(
-                Log.Error($"No WebSockets URL could be built from the provided URL {_server.Url} due to {exception.Message}");
+                    $"No WebSockets URL could be built from the provided URL {_server.Url} due to {exception.Message}");
+            }
             _webSocketsUri = webSocketsUriBuilder.Uri;
             _cancellationTokenSource = new CancellationTokenSource();
             _cancellationToken = _cancellationTokenSource.Token;
+            Connect();
+            if (_configuration.RetrievePastNotificationHours != 0)
+            {
+                _initTask = RetrievePastMessages(_cancellationToken);
             Connect();
             _runTask = Run(_cancellationToken);
+        }
         private void Connect()
+        {
             _webSocketSharp = new WebSocket(_webSocketsUri.AbsoluteUri);
-            _webSocketSharp.SslConfiguration = new ClientSslConfiguration(_webSocketsUri.Host,
-                new X509CertificateCollection(new X509Certificate[] { }), SslProtocols.Tls12, false);
+            _webSocketSharp.SslConfiguration = new ClientSslConfiguration(_webSocketsUri.Host,
-            if (_configuration.Proxy.Enable)
+                new X509CertificateCollection(new X509Certificate[] { }), SslProtocols.Tls12, false);
             if (_configuration.Proxy.Enable)
-                _webSocketSharp.SetProxy(_configuration.Proxy.Url, _configuration.Proxy.Username, _configuration.Proxy.Password);
                 _webSocketSharp.SetProxy(_configuration.Proxy.Url, _configuration.Proxy.Username,
-            if (!string.IsNullOrEmpty(_server.Username) && !string.IsNullOrEmpty(_server.Password))
+                    _configuration.Proxy.Password);
-            {
                 _webSocketSharp.SetCredentials(_server.Username, _server.Password, true);
             if (!string.IsNullOrEmpty(_server.Username) && !string.IsNullOrEmpty(_server.Password))
-            if (_configuration.IgnoreSelfSignedCertificates)
+                _webSocketSharp.SetCredentials(_server.Username, _server.Password, true);
-                _webSocketSharp.SslConfiguration.ServerCertificateValidationCallback +=
+            if (_configuration.IgnoreSelfSignedCertificates)
-                    (sender, certificate, chain, errors) => true;
+                _webSocketSharp.SslConfiguration.ServerCertificateValidationCallback +=
                     (sender, certificate, chain, errors) => true;
             _webSocketSharp.Log.Output = (logData, s) =>
+            {
                 Log.Information($"WebSockets low level logging reported: {logData.Message}");
             };
             _webSocketSharp.OnMessage += WebSocketSharp_OnMessage;
             _webSocketSharp.OnError += WebSocketSharp_OnError;
+            _webSocketSharp.OnOpen += WebSocketSharp_OnOpen;
-            _webSocketSharp.OnOpen += WebSocketSharp_OnOpen;
+            _webSocketSharp.OnClose += WebSocketSharp_OnClose;
             _webSocketSharp.OnClose += WebSocketSharp_OnClose;
             _webSocketSharp.ConnectAsync();
             _webSocketSharp.ConnectAsync();
         private void WebSocketSharp_OnClose(object sender, CloseEventArgs e)
         private void WebSocketSharp_OnClose(object sender, CloseEventArgs e)
             Log.Information(
+                $"WebSockets connection to server {_webSocketsUri.AbsoluteUri} closed with reason {e.Reason}");
-            Log.Information($"WebSockets connection to server {_webSocketsUri.AbsoluteUri} closed with reason {e.Reason}");
+        }
         private void WebSocketSharp_OnOpen(object sender, EventArgs e)
+        {
-        private void WebSocketSharp_OnOpen(object sender, EventArgs e)
+            Log.Information($"WebSockets connection to server {_webSocketsUri.AbsoluteUri} is now open");
+        }
         private async void WebSocketSharp_OnMessage(object sender, MessageEventArgs e)
+        {
             if (e.RawData.Length == 0)
             {
-                Log.Warning($"Empty message received from server");
+                Log.Warning("Empty message received from server");
                 return;
+            }
             var message = Encoding.UTF8.GetString(e.RawData, 0, e.RawData.Length);
-            GotifyNotification gotifyNotification;
+            GotifyMessage gotifyNotification;
             try
+            {
-                gotifyNotification = JsonConvert.DeserializeObject<GotifyNotification>(message);
+                gotifyNotification = JsonConvert.DeserializeObject<GotifyMessage>(message);
+            }
                 return;
+            }
             gotifyNotification.Server = _server;
-            if (!Uri.TryCreate(Path.Combine($"{_httpUri}", "application"), UriKind.Absolute,
+            var applicationUriBuilder = new UriBuilder(_httpUri);
+            try
+            {
+                applicationUriBuilder.Path = Path.Combine(applicationUriBuilder.Path, "application");
+            }
-                    out var applicationUri))
+            catch (ArgumentException exception)
+            {
                 Log.Warning("Could not build an URI to an application");
                 Log.Warning($"Could not build an URI to an application");
                 return;
             }
             using (var imageStream =
-            using (var imageStream =
+                   await RetrieveGotifyApplicationImage(gotifyNotification.AppId, applicationUriBuilder.Uri,
-                   await RetrieveGotifyApplicationImage(gotifyNotification.AppId, applicationUri, _cancellationToken))
+                       _cancellationToken))
+            {
                 if (imageStream == null)
             Log.Debug($"Notification message received: {gotifyNotification.Message}");
+        }
         public void Stop()
         {
+            if (_cancellationTokenSource == null) return;
-            if (_cancellationTokenSource != null) _cancellationTokenSource.Cancel();
+            _cancellationTokenSource.Cancel();
+        }
+        #endregion
+        #region Private Methods
+        private async Task RetrievePastMessages(CancellationToken cancellationToken)
+        {
+            var messageUriBuilder = new UriBuilder(_httpUri);
+            foreach (var application in await RetrieveGotifyApplications(cancellationToken))
+            {
+                try
+                {
+                    messageUriBuilder.Path = Path.Combine(messageUriBuilder.Path, "application", $"{application.Id}",
+                        "message");
+                }
+                catch (ArgumentException exception)
+                {
+                    Log.Error($"No application URL could be built for {_server.Url} due to {exception.Message}");
+                    continue;
+                }
+                var messagesResponse = await _httpClient.GetAsync(messageUriBuilder.Uri, cancellationToken);
+                var messages = await messagesResponse.Content.ReadAsStringAsync();
+                GotifyMessageQuery gotifyMessageQuery;
+                try
+                {
+                    gotifyMessageQuery =
+                        JsonConvert.DeserializeObject<GotifyMessageQuery>(messages);
+                }
+                catch (JsonSerializationException exception)
+                {
+                    Log.Warning($"Could not deserialize the message response: {exception.Message}");
+                    continue;
+                }
+                var applicationUriBuilder = new UriBuilder(_httpUri);
+                try
+                {
+                    applicationUriBuilder.Path = Path.Combine(applicationUriBuilder.Path, "application");
+                }
+                catch (ArgumentException exception)
+                {
+                    Log.Warning($"Could not build an URI to an application: {exception}");
+                    return;
+                }
+                foreach (var message in gotifyMessageQuery.Messages)
+                {
+                    if (message.Date < DateTime.Now - TimeSpan.FromHours(_configuration.RetrievePastNotificationHours))
+                        continue;
+                    message.Server = _server;
+                    using (var imageStream =
+                           await RetrieveGotifyApplicationImage(message.AppId, applicationUriBuilder.Uri,
+                               _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(message, image));
+                    }
         #endregion
+            }
         #region Private Methods
         private async Task Run(CancellationToken cancellationToken)
+        {
             try
+            {
                 do
                 {
+                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
-                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
+                } while (!cancellationToken.IsCancellationRequested);
                 } while (!cancellationToken.IsCancellationRequested);
             catch (Exception exception) when (exception is OperationCanceledException ||
-            catch (Exception exception) when (exception is OperationCanceledException || exception is ObjectDisposedException)
+                                              exception is ObjectDisposedException)
+            {
+            }
             catch (Exception exception)
+            {
+                Log.Warning(exception, "Failure running connection loop");
+            }
+        }
+        private async Task<GotifyApplication[]> RetrieveGotifyApplications(CancellationToken cancellationToken)
+        {
+            var applicationsUriBuilder = new UriBuilder(_httpUri);
+            try
+            {
+                applicationsUriBuilder.Path = Path.Combine(applicationsUriBuilder.Path, "application");
+            }
+            catch (ArgumentException exception)
+            {
+                Log.Error($"No application URL could be built for {_server.Url} due to {exception}");
+            }
+            var applicationsResponse = await _httpClient.GetAsync(applicationsUriBuilder.Uri, cancellationToken);
+            var applications = await applicationsResponse.Content.ReadAsStringAsync();
+            GotifyApplication[] gotifyApplications;
+            try
+            {
+                gotifyApplications =
+                    JsonConvert.DeserializeObject<GotifyApplication[]>(applications);
+            }
+            catch (JsonSerializationException exception)
+            {
+                Log.Warning($"Could not deserialize the list of applications from the server: {exception}");
+                return null;
+            }
                 Log.Warning(exception, "Failure running connection loop");
             return gotifyApplications;
+        }