Winify – Diff between revs 64 and 66

Subversion Repositories:

?pathlinks?

Rev 64 – Rev 67 – Go to most recent revision – Details – Blame – Last modification – View Log

 ï»¿using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Drawing;
 using System.Globalization;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Threading.Tasks.Dataflow;
 using System.Windows.Forms;
 using Newtonsoft.Json;
+using Org.BouncyCastle.Asn1.Pkcs;
 using Serilog;
 using Servers;
 using WebSocketSharp;
 using WebSocketSharp.Net;
 using Winify.Utilities;
         private CancellationToken _cancellationToken;
         private CancellationTokenSource _cancellationTokenSource;
-        private Task _runTask;
+        private Task _heartBeatTask;
         private HttpClient _httpClient;
         private readonly Uri _webSocketsUri;
         private readonly Uri _webSocketsUri;
         private readonly Uri _httpUri;
-        private WebSocket _webSocketSharp;
+        private readonly Uri _httpUri;
-        private readonly Configuration.Configuration _configuration;
+        private WebSocket _webSocketSharp;
-        private Task _initTask;
+        private readonly Configuration.Configuration _configuration;
         private IDisposable _tplRetrievePastMessagesLink;
+        private IDisposable _tplWebSocketsBufferBlockTransformLink;
+        private IDisposable _tplWebSocketsTransformActionLink;
+        private IDisposable _tplWebSocketsTransformActionNullLink;
-        private IDisposable _tplWebSocketsBufferBlockTransformLink;
-        private IDisposable _tplWebSocketsTransformActionLink;
+        private readonly BufferBlock<GotifyConnectionData> _webSocketMessageBufferBlock;
-        private IDisposable _tplWebSocketsTransformActionNullLink;
+        private readonly Stopwatch _webSocketsClientPingStopWatch;
-        private readonly BufferBlock<byte[]> _webSocketMessageBufferBlock;
+        private readonly ScheduledContinuation _webSocketsServerResponseScheduledContinuation;
         private readonly Stopwatch _webSocketsClientPingStopWatch;
-        private readonly ScheduledContinuation _webSocketsServerResponseScheduledContinuation;
+        private Task _retrievePastMessagesTask;
         private static JsonSerializer _jsonSerializer;
         private readonly MemoryCache _applicationImageCache;
         #endregion
+        #region Constructors, Destructors and Finalizers
+        private GotifyConnection()
+        {
+            _jsonSerializer = new JsonSerializer();
-        #region Constructors, Destructors and Finalizers
+            _webSocketsServerResponseScheduledContinuation = new ScheduledContinuation();
+            _webSocketsClientPingStopWatch = new Stopwatch();
         private GotifyConnection()
             _webSocketMessageBufferBlock = new BufferBlock<GotifyConnectionData>(
-            _applicationImageCache = new MemoryCache("GotifyApplicationImageCache");
+                new DataflowBlockOptions
-            _webSocketsServerResponseScheduledContinuation = new ScheduledContinuation();
-            _webSocketsClientPingStopWatch = new Stopwatch();
+                {
-            _webSocketMessageBufferBlock = new BufferBlock<byte[]>(new DataflowBlockOptions { CancellationToken = _cancellationToken });
+                    CancellationToken = _cancellationToken
-            var webSocketTransformBlock = new TransformBlock<byte[], GotifyMessage>(bytes =>
+                });
+            var webSocketTransformBlock = new TransformBlock<GotifyConnectionData, GotifyMessage>(data =>
+            {
-                if (bytes.Length == 0)
-                {
-                    return null;
-                }
+                if (data.Payload == null || data.Payload.Length == 0)
+                {
+                    return null;
-                var message = Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+                }
+                GotifyMessage gotifyNotification;
-                GotifyMessage gotifyNotification;
+                try
+                {
-                try
+                    var message = Encoding.UTF8.GetString(data.Payload, 0, data.Payload.Length);
                     gotifyNotification = JsonConvert.DeserializeObject<GotifyMessage>(message);
-                catch (JsonSerializationException exception)
+                    if (gotifyNotification == null)
+                    {
-                    Log.Warning($"Could not deserialize notification: {exception.Message}");
-                    return null;
+                        throw new ArgumentNullException();
-                }
+                    }
-                if (gotifyNotification == null)
-                {
-                    Log.Warning($"Could not deserialize gotify notification: {message}");
-                    return null;
-                }
+                    gotifyNotification.Server = data.Server;
+                }
-                return gotifyNotification;
+                catch (Exception exception)
-            }, new ExecutionDataflowBlockOptions { CancellationToken = _cancellationToken });
-            var webSocketActionBlock = new ActionBlock<GotifyMessage>(async message =>
-            {
-                message.Server = _server;
-                var cachedImage = _applicationImageCache.Get($"{message.AppId}");
-                if (cachedImage is Stream cachedImageStream)
-                {
-                    using var cachedImageMemoryStream = new MemoryStream();
-                    await cachedImageStream.CopyToAsync(cachedImageMemoryStream);
+                {
-                    var cachedApplicationImage = new Bitmap(cachedImageMemoryStream);
-                    GotifyNotification?.Invoke(this,
-                        new GotifyNotificationEventArgs(message, cachedApplicationImage));
-                    return;
-                }
-                using var imageStream = await RetrieveGotifyApplicationImage(message.AppId, _cancellationToken);
+                    Log.Warning(exception, "Could not deserialize notification.");
-                    if (imageStream == null || imageStream.Length == 0)
                     return null;
                         Log.Warning("Could not find any application image for notification");
                 case "HTTPS":
                     webSocketsUriBuilder.Scheme = "wss";
                     break;
+            }
-            try
-            {
-                webSocketsUriBuilder.Path = Path.Combine(webSocketsUriBuilder.Path, "stream");
-            }
-            catch (ArgumentException exception)
+            if (!Uri.TryCreate(webSocketsUriBuilder.Uri, "stream", out var combinedUri))
-            {
-                Log.Error(
+            {
-                    $"No WebSockets URL could be built from the provided URL {_server.Url} due to {exception.Message}");
+                Log.Error($"No WebSockets URL could be built from the provided URL {_server.Url}.");
             }
-            _webSocketsUri = webSocketsUriBuilder.Uri;
+            _webSocketsUri = combinedUri;
+        }
+            }
             _cancellationTokenSource = new CancellationTokenSource();
             _cancellationToken = _cancellationTokenSource.Token;
-            Connect();
-            if (_configuration.RetrievePastNotificationHours != 0)
+            if (_webSocketSharp != null)
+            {
-                _initTask = RetrievePastMessages(_cancellationToken);
-            }
-            _runTask = HeartBeat(_cancellationToken);
-        }
                 return;
         private void Connect()
             _webSocketSharp = new WebSocket(_webSocketsUri.AbsoluteUri);
             _webSocketSharp.EmitOnPing = true;
             _webSocketSharp.OnMessage += WebSocketSharp_OnMessage;
             _webSocketSharp.OnError += WebSocketSharp_OnError;
             _webSocketSharp.OnOpen += WebSocketSharp_OnOpen;
             _webSocketSharp.OnClose += WebSocketSharp_OnClose;
+            _webSocketSharp.Connect();
+            _heartBeatTask = HeartBeat(_cancellationToken);
+            if (_configuration.RetrievePastNotificationHours != 0)
+            {
+                _retrievePastMessagesTask = RetrievePastMessages(_cancellationToken);
             _webSocketSharp.ConnectAsync();
+        }
         private void WebSocketSharp_OnClose(object sender, CloseEventArgs e)
+        {
             Log.Error(
                 $"Connection to WebSockets server {_webSocketsUri.AbsoluteUri} terminated unexpectedly with message {e.Message}",
                 e.Exception);
-            if (_cancellationToken.IsCancellationRequested)
-            {
-                Stop();
-                return;
-            }
             await Task.Delay(TimeSpan.FromSeconds(1), _cancellationToken);
             Log.Information($"Reconnecting to websocket server {_webSocketsUri.AbsoluteUri}");
-            Connect();
+            await Stop().ContinueWith(task => Start(), CancellationToken.None);
+        }
         private async void WebSocketSharp_OnMessage(object sender, MessageEventArgs e)
+        {
-            if (e.IsPing)
             if (e.IsPing)
                 Log.Information($"Server {_server} sent PING message");
+                Log.Information($"Server {_server} sent PING message");
                 _webSocketsServerResponseScheduledContinuation.Schedule(TimeSpan.FromMinutes(1), OnUnresponsiveServer, _cancellationToken);
+                _webSocketsServerResponseScheduledContinuation.Schedule(TimeSpan.FromMinutes(1), OnUnresponsiveServer, _cancellationToken);
                 return;
+            }
-            }
+            await _webSocketMessageBufferBlock.SendAsync(new GotifyConnectionData(e.RawData, _server), _cancellationToken);
+        }
         public async Task Stop()
+        {
+            if (_webSocketSharp == null || _cancellationTokenSource == null)
+            {
+                return;
+            }
+            _cancellationTokenSource.Cancel();
+            await _heartBeatTask;
+            await _retrievePastMessagesTask;
+            if (_webSocketSharp != null)
+            {
+                _webSocketSharp.OnMessage -= WebSocketSharp_OnMessage;
+                _webSocketSharp.OnError -= WebSocketSharp_OnError;
+                _webSocketSharp.OnOpen -= WebSocketSharp_OnOpen;
-            await _webSocketMessageBufferBlock.SendAsync(e.RawData, _cancellationToken);
+                _webSocketSharp.OnClose -= WebSocketSharp_OnClose;
                 _webSocketSharp.Close();
-        public void Stop()
+                _webSocketSharp = null;
+            }
-            if (_cancellationTokenSource == null) return;
-            _cancellationTokenSource.Cancel();
-        }
+            _cancellationTokenSource.Dispose();
             _cancellationTokenSource = null;
-        #endregion
-        #region Private Methods
+        }
-        private async Task RetrievePastMessages(CancellationToken cancellationToken)
-        {
             var messageUriBuilder = new UriBuilder(_httpUri);
+        #endregion
             var gotifyApplicationBufferBlock = new BufferBlock<GotifyApplication>(new DataflowBlockOptions { CancellationToken = cancellationToken });
-            var gotifyApplicationActionBlock = new ActionBlock<GotifyApplication>(async application =>
+        #region Private Methods
-            {
-                try
+        private async Task RetrievePastMessages(CancellationToken cancellationToken)
+        {
-                    messageUriBuilder.Path = Path.Combine(messageUriBuilder.Path, "application", $"{application.Id}",
+            var gotifyApplicationBufferBlock = new BufferBlock<GotifyConnectionApplication>(new DataflowBlockOptions { CancellationToken = cancellationToken });
+            var gotifyApplicationActionBlock = new ActionBlock<GotifyConnectionApplication>(async gotifyConnectionApplication =>
+            {
+                if (!Uri.TryCreate(_httpUri, $"application/{gotifyConnectionApplication.Application.Id}/message", out var combinedUri))
+                {
-                        "message");
+                    Log.Error($"Could not get application message Uri {gotifyConnectionApplication.Application.Id}.");
-                }
-                catch (ArgumentException exception)
+                    return;
-                {
+                }
                     Log.Error($"No application URL could be built for {_server.Url} due to {exception.Message}");
                 GotifyMessageQuery gotifyMessageQuery;
-                    return;
-                }
-                HttpResponseMessage messagesResponse;
-                try
-                {
-                    messagesResponse = await _httpClient.GetAsync(messageUriBuilder.Uri, cancellationToken);
-                }
-                catch (Exception exception)
-                {
-                    Log.Error($"Could not get application {application.Id} due to {exception.Message}");
+                try
+                {
-                    return;
+                    using var messageStream = await _httpClient.GetStreamAsync(combinedUri);
                     using var streamReader = new StreamReader(messageStream);
                     using var jsonTextReader = new JsonTextReader(streamReader);
-                var messages = await messagesResponse.Content.ReadAsStringAsync();
+                    gotifyMessageQuery = _jsonSerializer.Deserialize<GotifyMessageQuery>(jsonTextReader);
-                GotifyMessageQuery gotifyMessageQuery;
-                try
+                }
-                {
-                    gotifyMessageQuery =
-                        JsonConvert.DeserializeObject<GotifyMessageQuery>(messages);
-                }
-                catch (JsonSerializationException exception)
+                catch (HttpRequestException exception)
                 {
-                    Log.Warning($"Could not deserialize the message response: {exception.Message}");
+                    Log.Warning(exception, $"Could not get application {gotifyConnectionApplication.Application.Id}.");
+                    return;
+                }
+                catch (JsonSerializationException exception)
                     return;
-                }
+                    Log.Warning(exception,$"Could not deserialize the message response for application {gotifyConnectionApplication.Application.Id}.");
-                foreach (var message in gotifyMessageQuery.Messages.Where(message => message.Date >= DateTime.Now - TimeSpan.FromHours(_configuration.RetrievePastNotificationHours)))
                     return;
                     message.Server = _server;
+                if (gotifyMessageQuery == null || gotifyMessageQuery.Messages == null)
                     var cachedImage = _applicationImageCache.Get($"{message.AppId}");
-                    if (cachedImage is Stream cachedImageStream)
+                    Log.Warning("Invalid application messages deserialized deserialized.");
-                    {
-                        using var cachedImageMemoryStream = new MemoryStream();
-                        await cachedImageStream.CopyToAsync(cachedImageMemoryStream);
-                        var cachedApplicationImage = new Bitmap(cachedImageMemoryStream);
-                        GotifyNotification?.Invoke(this,
-                            new GotifyNotificationEventArgs(message, cachedApplicationImage));
-                        return;
-                    }
-                    using var imageStream = await RetrieveGotifyApplicationImage(message.AppId, _cancellationToken);
+                    return;
                     if (imageStream == null || imageStream.Length == 0)
-                        Log.Warning("Could not find any application image for notification");
+                foreach (var message in gotifyMessageQuery.Messages)
                         continue;
                     if (message.Date < DateTime.Now - TimeSpan.FromHours(_configuration.RetrievePastNotificationHours))
+                    {
+                        continue;
                     using var memoryStream = new MemoryStream();
+                    using var imageStream = await RetrieveGotifyApplicationImage(message.AppId, _cancellationToken);
-                    await imageStream.CopyToAsync(memoryStream);
+                    if (imageStream == null || imageStream.Length == 0)
+                    {
+                        Log.Warning("Could not find any application image for notification.");
                     var imageBytes = memoryStream.ToArray();
                         continue;
                     _applicationImageCache.Add($"{message.AppId}", imageBytes,
+            }
+        }
         private async IAsyncEnumerable<GotifyApplication> RetrieveGotifyApplications([EnumeratorCancellation] CancellationToken cancellationToken)
         {
-            var applicationsUriBuilder = new UriBuilder(_httpUri);
-            try
-            {
-                applicationsUriBuilder.Path = Path.Combine(applicationsUriBuilder.Path, "application");
-            }
-            catch (ArgumentException exception)
+            if (!Uri.TryCreate(_httpUri, "application", out var combinedUri))
             {
-                Log.Error($"No application URL could be built for {_server.Url} due to {exception}");
+                Log.Error($"No application URL could be built for {_server.Url}.");
                 yield break;
-            }
+            }
             HttpResponseMessage applicationsResponse;
+            GotifyApplication[] gotifyApplications;
-            try
-            {
+            try
-                applicationsResponse = await _httpClient.GetAsync(applicationsUriBuilder.Uri, cancellationToken);
-            }
+            {
-            catch (Exception exception)
+                using var messageStream = await _httpClient.GetStreamAsync(combinedUri);
-            {
-                Log.Error($"Could not retrieve applications: {exception.Message}");
-                yield break;
+                using var streamReader = new StreamReader(messageStream);
-            }
+                using var jsonTextReader = new JsonTextReader(streamReader);
-            var applications = await applicationsResponse.Content.ReadAsStringAsync();
+                gotifyApplications = _jsonSerializer.Deserialize<GotifyApplication[]>(jsonTextReader);
             GotifyApplication[] gotifyApplications;
-            try
+                if (gotifyApplications == null)
+                {
-                gotifyApplications =
+                    throw new ArgumentNullException();
                     JsonConvert.DeserializeObject<GotifyApplication[]>(applications);
+            }
-            catch (JsonSerializationException exception)
+            catch (Exception exception)
         private async Task<Stream> RetrieveGotifyApplicationImage(int appId, CancellationToken cancellationToken)
+        {
             await foreach (var application in RetrieveGotifyApplications(cancellationToken))
             {
+                if (application.Id != appId)
+                {
+                    continue;
                 if (application.Id != appId) continue;
                 if (!Uri.TryCreate(Path.Combine($"{_httpUri}", $"{application.Image}"), UriKind.Absolute, out var applicationImageUri))
+                {
                     Log.Warning("Could not build URL path to application icon");
                     Log.Warning("Could not build URL path to application icon");
-                    continue;
-                }
                     continue;
                 HttpResponseMessage imageResponse;
+                try
+                {
+                    var imageResponse = await _httpClient.GetAsync(applicationImageUri, cancellationToken);
+                    var memoryStream = new MemoryStream();
-                try
+                    await imageResponse.Content.CopyToAsync(memoryStream);
-                    imageResponse = await _httpClient.GetAsync(applicationImageUri, cancellationToken);
+                    return memoryStream;
+                }
-                catch (Exception exception)
-                {
-                    Log.Error($"Could not retrieve application image: {exception.Message}");
+                catch (Exception exception)
+                {
+                    Log.Error($"Could not retrieve application image: {exception.Message}");
+                }
-                    return new MemoryStream();
+            }
+            return new MemoryStream();
+        }
-                }
+        #endregion
+        private class GotifyConnectionApplication
+        {
-                var memoryStream = new MemoryStream();
+            public GotifyApplication Application { get; }
-                await imageResponse.Content.CopyToAsync(memoryStream);
             public Server Server { get; }
+            public GotifyConnectionApplication(Server server, GotifyApplication application)
+            {
+                Server = server;
+                Application = application;
+            }
-                memoryStream.Position = 0L;
+        }
+        private class GotifyConnectionData
+        {
+            public byte[] Payload { get; }
             public Server Server { get; }
                 return memoryStream;
             public GotifyConnectionData(byte[] payload, Server server)