Winify – Diff between revs 66 and 67

Subversion Repositories:

?pathlinks?

Rev 66 – Rev 68 – 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.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Runtime.Caching;
 using System.Runtime.CompilerServices;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 using System.Text;
 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;
+{
     public class GotifyConnection : IDisposable
+    {
         #region Public Events & Delegates
-        public event EventHandler<GotifyNotificationEventArgs> GotifyNotification;
+        public event EventHandler<GotifyMessageEventArgs> GotifyMessage;
         private readonly Uri _httpUri;
         private WebSocket _webSocketSharp;
         private readonly Configuration.Configuration _configuration;
         private IDisposable _tplRetrievePastMessagesLink;
         private IDisposable _tplWebSocketsBufferBlockTransformLink;
-        private IDisposable _tplWebSocketsTransformActionLink;
-        private IDisposable _tplWebSocketsTransformActionNullLink;
         private readonly BufferBlock<GotifyConnectionData> _webSocketMessageBufferBlock;
         private readonly Stopwatch _webSocketsClientPingStopWatch;
         private readonly ScheduledContinuation _webSocketsServerResponseScheduledContinuation;
                 new DataflowBlockOptions
+                {
                     CancellationToken = _cancellationToken
                 });
-            var webSocketTransformBlock = new TransformBlock<GotifyConnectionData, GotifyMessage>(data =>
+            var webSocketActionBlock = new ActionBlock<GotifyConnectionData>(async gotifyConnectionData =>
             {
-                if (data.Payload == null || data.Payload.Length == 0)
+                try
+                {
-                {
+                    using var memoryStream = new MemoryStream(gotifyConnectionData.Payload);
-                    return null;
+                    using var streamReader = new StreamReader(memoryStream);
-                }
+                    using var jsonTextReader = new JsonTextReader(streamReader);
-                GotifyMessage gotifyNotification;
-                try
+                    var gotifyMessage = _jsonSerializer.Deserialize<GotifyMessage>(jsonTextReader) ?? throw new ArgumentNullException();
-                {
-                    var message = Encoding.UTF8.GetString(data.Payload, 0, data.Payload.Length);
+                    gotifyMessage.Server = gotifyConnectionData.Server;
+                    using var imageStream = await RetrieveGotifyApplicationImage(gotifyMessage.AppId, _cancellationToken);
-                    gotifyNotification = JsonConvert.DeserializeObject<GotifyMessage>(message);
+                    if (imageStream == null || imageStream.Length == 0)
+                    {
+                        Log.Warning("Could not find any application image for notification.");
+                        return;
+                    }
-                    if (gotifyNotification == null)
+                    var image = new Bitmap(imageStream);
-                    {
-                        throw new ArgumentNullException();
+                    GotifyMessage?.Invoke(this,
-                    }
+                        new GotifyMessageEventArgs(gotifyMessage, image));
-                    gotifyNotification.Server = data.Server;
-                catch (Exception exception)
-                {
+                    Log.Debug($"Notification message received: {gotifyMessage.Message}");
-                    Log.Warning(exception, "Could not deserialize notification.");
-                    return null;
-                }
-                return gotifyNotification;
             }, new ExecutionDataflowBlockOptions { CancellationToken = _cancellationToken });
+                catch (JsonSerializationException exception)
-            var webSocketActionBlock = new ActionBlock<GotifyMessage>(async message =>
-            {
                 using var imageStream = await RetrieveGotifyApplicationImage(message.AppId, _cancellationToken);
-                if (imageStream == null || imageStream.Length == 0)
-                {
-                    Log.Warning("Could not find any application image for notification.");
-                    return;
-                }
-                var image = new Bitmap(imageStream);
+                    Log.Warning(exception, "Could not deserialize notification message.");
+                }
-                GotifyNotification?.Invoke(this,
+                catch (Exception exception)
-                    new GotifyNotificationEventArgs(message, image));
-                Log.Debug($"Notification message received: {message.Message}");
             }, new ExecutionDataflowBlockOptions { CancellationToken = _cancellationToken });
                     Log.Warning(exception, "Generic failure.");
             _tplWebSocketsBufferBlockTransformLink = _webSocketMessageBufferBlock.LinkTo(webSocketTransformBlock,
                 new DataflowLinkOptions { PropagateCompletion = true });
+            {
                 _tplWebSocketsBufferBlockTransformLink.Dispose();
                 _tplWebSocketsBufferBlockTransformLink = null;
+            }
-            if (_tplWebSocketsTransformActionLink != null)
-            {
-                _tplWebSocketsTransformActionLink.Dispose();
-                _tplWebSocketsTransformActionLink = null;
-            }
-            if (_tplWebSocketsTransformActionNullLink != null)
-            {
-                _tplWebSocketsTransformActionNullLink.Dispose();
-                _tplWebSocketsTransformActionNullLink = null;
-            }
             if (_tplRetrievePastMessagesLink != null)
+            {
                 _tplRetrievePastMessagesLink.Dispose();
                 _tplRetrievePastMessagesLink = null;
             _webSocketsServerResponseScheduledContinuation.Schedule(TimeSpan.FromMinutes(1), OnUnresponsiveServer, _cancellationToken);
+        }
         private void OnUnresponsiveServer()
         {
-            Log.Warning($"Server {_server} has not responded in a long while...");
+            Log.Warning($"Server {_server.Name} has not responded in a long while...");
+        }
         private async void WebSocketSharp_OnError(object sender, ErrorEventArgs e)
         private async void WebSocketSharp_OnMessage(object sender, MessageEventArgs e)
+        {
             if (e.IsPing)
             {
-                Log.Information($"Server {_server} sent PING message");
+                Log.Information($"Server {_server.Name} sent PING message");
                 _webSocketsServerResponseScheduledContinuation.Schedule(TimeSpan.FromMinutes(1), OnUnresponsiveServer, _cancellationToken);
                     Log.Error($"Could not get application message Uri {gotifyConnectionApplication.Application.Id}.");
                     return;
-                }
+                }
                 GotifyMessageQuery gotifyMessageQuery;
                 try
+                {
                     using var messageStream = await _httpClient.GetStreamAsync(combinedUri);
                     using var streamReader = new StreamReader(messageStream);
+                    using var jsonTextReader = new JsonTextReader(streamReader);
+                    var gotifyMessageQuery = _jsonSerializer.Deserialize<GotifyMessageQuery>(jsonTextReader) ??
+                                             throw new ArgumentNullException();
+                    if (gotifyMessageQuery.Messages == null)
+                    {
+                        Log.Warning("Invalid application messages deserialized deserialized.");
+                        return;
+                    }
+                    foreach (var message in gotifyMessageQuery.Messages)
+                    {
+                        if (message.Date <
+                            DateTime.Now - TimeSpan.FromHours(_configuration.RetrievePastNotificationHours))
+                        {
+                            continue;
+                        }
+                        using var imageStream = await RetrieveGotifyApplicationImage(message.AppId, _cancellationToken);
+                        if (imageStream == null || imageStream.Length == 0)
+                        {
+                            Log.Warning("Could not find any application image for notification.");
+                            continue;
+                        }
+                        var image = new Bitmap(imageStream);
+                        message.Server = gotifyConnectionApplication.Server;
-                    using var jsonTextReader = new JsonTextReader(streamReader);
+                        GotifyMessage?.Invoke(this,
                             new GotifyMessageEventArgs(message, image));
                     gotifyMessageQuery = _jsonSerializer.Deserialize<GotifyMessageQuery>(jsonTextReader);
+                }
-                catch (HttpRequestException exception)
-                {
-                    Log.Warning(exception, $"Could not get application {gotifyConnectionApplication.Application.Id}.");
+                catch (HttpRequestException exception)
+                {
-                    return;
+                    Log.Warning(exception, $"Could not get application {gotifyConnectionApplication.Application.Id}.");
-                }
-                catch (JsonSerializationException exception)
-                {
+                }
-                    Log.Warning(exception,$"Could not deserialize the message response for application {gotifyConnectionApplication.Application.Id}.");
-                    return;
-                }
+                catch (JsonSerializationException exception)
-                if (gotifyMessageQuery == null || gotifyMessageQuery.Messages == null)
-                {
                     Log.Warning("Invalid application messages deserialized deserialized.");
-                    return;
+                    Log.Warning(exception,
                         $"Could not deserialize the message response for application {gotifyConnectionApplication.Application.Id}.");
-                foreach (var message in gotifyMessageQuery.Messages)
-                {
-                    if (message.Date < DateTime.Now - TimeSpan.FromHours(_configuration.RetrievePastNotificationHours))
-                    {
-                        continue;
-                    }
-                    using var imageStream = await RetrieveGotifyApplicationImage(message.AppId, _cancellationToken);
-                    if (imageStream == null || imageStream.Length == 0)
-                    {
-                        Log.Warning("Could not find any application image for notification.");
-                        continue;
+                }
-                    }
-                    var image = new Bitmap(imageStream);
-                    message.Server = gotifyConnectionApplication.Server;
                 catch (Exception exception)
-                    GotifyNotification?.Invoke(this,
                         new GotifyNotificationEventArgs(message, image));
                     Log.Warning(exception, "Generic failure.");
+                }
+            }
             await Task.WhenAll(tasks);
             gotifyApplicationBufferBlock.Complete();
-            await gotifyApplicationActionBlock.Completion;
             await gotifyApplicationActionBlock.Completion;
+        }
         private async Task HeartBeat(CancellationToken cancellationToken)
                     await Task.Delay(TimeSpan.FromMinutes(1), cancellationToken);
                     _webSocketsClientPingStopWatch.Restart();
                     if (!_webSocketSharp.Ping())
                     {
-                        Log.Warning($"Server {_server} did not respond to PING message.");
+                        Log.Warning($"Server {_server.Name} did not respond to PING message.");
                         continue;
+                    }
                     var delta = _webSocketsClientPingStopWatch.ElapsedMilliseconds;
-                    Log.Information($"PING response latency for {_server} is {delta}ms");
+                    Log.Information($"PING response latency for {_server.Name} is {delta}ms");
                     _webSocketsServerResponseScheduledContinuation.Schedule(TimeSpan.FromMinutes(1), OnUnresponsiveServer, _cancellationToken);
                 } while (!cancellationToken.IsCancellationRequested);
+            }
             catch (Exception exception) when (exception is OperationCanceledException ||
                                               exception is ObjectDisposedException)
             {
+            }
             catch (Exception exception)
+            {
-                Log.Warning(exception, $"Heartbeat for server {_server} has failed due to {exception.Message}");
+                Log.Warning(exception, $"Heartbeat for server {_server.Name} has failed.");
                     continue;
+                }
                 try
                 {
-                    var imageResponse = await _httpClient.GetAsync(applicationImageUri, cancellationToken);
+                    var imageResponse = await _httpClient.GetStreamAsync(applicationImageUri);
                     var memoryStream = new MemoryStream();
-                    await imageResponse.Content.CopyToAsync(memoryStream);
+                    await imageResponse.CopyToAsync(memoryStream);
                     return memoryStream;
+                }
                 catch (Exception exception)
+                {
-                    Log.Error($"Could not retrieve application image: {exception.Message}");
+                    Log.Error(exception,"Could not retrieve application image.");