accepted user commands and alerts are now registered as events (#127)

* accepted user commands and alerts are now registered as events

By registering these low frequency events it will be possible later to check relevant actions and alerts that have been triggered for the system

Also:
* fixed bug in multi command alerts
* CommandHandler.AlertFired has been removed, use CommandHandler.EventFired and check type == EventType.Alert instead
* fixed double firing of command events

CA_DataUploaderLib/Alerts.cs

@@ -72,7 +72,7 @@ protected override Task Command(List<string> args)
 
         public override void OnNewVectorReceived(object sender, NewVectorReceivedArgs e)
         {
-            var timestamp = e.GetVectorTime().ToString("yyyy.MM.dd HH:mm:ss");
+            var timestamp = e.GetVectorTime();
             var (alertsToTrigger, noSensorAlerts) = GetAlertsToTrigger(e); // we gather alerts separately from triggering, to reduce time locking the _alerts list
 
             foreach (var a in alertsToTrigger ?? Enumerable.Empty<IOconfAlert>())
@@ -104,17 +104,16 @@ public override void OnNewVectorReceived(object sender, NewVectorReceivedArgs e)
                 noSensorAlerts ?? Enumerable.Empty<IOconfAlert>());
         }
 
-        private void TriggerAlert(IOconfAlert a, string timestamp, string message)
+        private void TriggerAlert(IOconfAlert a, DateTime timestamp, string message)
         {
-            message = timestamp + message;
-            logger.LogError(message);
+            logger.LogError(timestamp.ToString("yyyy.MM.dd HH:mm:ss") + message);
             if (a.Command != default)
             {
                 foreach (var commands in a.Command.Split('|'))
-                    ExecuteCommand(a.Command);
+                    ExecuteCommand(commands);
             }
 
-            _cmd.FireAlert(message);            
+            _cmd.FireAlert(message, timestamp);            
         }
 
         private List<T> EnsureInitialized<T>(ref List<T> list) => list = list ?? new List<T>();

CA_DataUploaderLib/CommandHandler.cs

@@ -25,7 +25,7 @@ public sealed class CommandHandler : IDisposable
         private Lazy<VectorFilterAndMath> _fullsystemFilterAndMath;
 
         public event EventHandler<NewVectorReceivedArgs> NewVectorReceived;
-        public event EventHandler<AlertFiredArgs> AlertFired;
+        public event EventHandler<EventFiredArgs> EventFired;
         public bool IsRunning { get { return _running; } }
 
         public CommandHandler(SerialNumberMapper mapper = null)
@@ -99,11 +99,12 @@ public bool AssertArgs(List<string> args, int minimumLen)
 
         public void OnNewVectorReceived(IEnumerable<SensorSample> vector) =>
             NewVectorReceived?.Invoke(this, new NewVectorReceivedArgs(vector.ToDictionary(v => v.Name, v => v.Value)));
-
-        public void FireAlert(string msg)
-        {
-            AlertFired?.Invoke(this, new AlertFiredArgs(msg));
-        }
+
+        public void FireAlert(string msg) => FireAlert(msg, DateTime.UtcNow);
+        public void FireAlert(string msg, DateTime timespan) => FireCustomEvent(msg, timespan, (byte)EventType.Alert);
+        /// <summary>registers a custom event (low frequency, such like user commands and alerts that have a max firing rate)</summary>
+        /// <remarks>preferably use values above 100 for eventType to avoid future collisions with built in event types</remarks>
+        public void FireCustomEvent(string msg, DateTime timespan, byte eventType) => EventFired?.Invoke(this, new EventFiredArgs(msg, eventType, timespan));
         private bool Stop(List<string> args)
         {
             _running = false;
@@ -168,14 +169,18 @@ private void HandleCommand(string cmdString, bool addToCommandHistory)
         private List<bool> RunCommandFunctions(string cmdString, bool addToCommandHistory, List<string> cmd, List<Func<List<string>, bool>> commandFunctions)
         {
             List<bool> executionResults = new List<bool>(commandFunctions.Count);
+            var isFirstAccepted = true;
             foreach (var func in commandFunctions)
             {
                 try
                 {
                     bool accepted;
                     executionResults.Add(accepted = func.Invoke(cmd));
-                    if (accepted)
+                    if (accepted && isFirstAccepted)
+                    {//avoid unnecesarily trying to add the command multiple times + triggering the command's EventFired
+                        isFirstAccepted = false;
                         OnCommandAccepted(cmdString, addToCommandHistory); // track it in the history if at least one execution accepted the command
+                    }
                     else
                         break; // avoid running the command on another subsystem when it was already rejected
                 }
@@ -208,6 +213,7 @@ private void OnCommandAccepted(string cmdString, bool addToCommandHistory)
             if (AcceptedCommands.LastOrDefault() != cmdString)
                 AcceptedCommands.Add(cmdString);
             AcceptedCommandsIndex = AcceptedCommands.Count;
+            FireCustomEvent(cmdString, DateTime.UtcNow, (byte)EventType.Command);
         }
 
         private string GetCommand()

CA_DataUploaderLib/EventFiredArgs.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace CA_DataUploaderLib
+{
+    public class EventFiredArgs : EventArgs
+    {
+        public EventFiredArgs(string data, EventType eventType, DateTime timespan) : this(data, (byte) eventType, timespan) { }
+        public EventFiredArgs(string data, byte eventType, DateTime timespan)
+        {
+            Data = data;
+            EventType = eventType;
+            TimeSpan = timespan;
+        }
+
+        public string Data { get; }
+        public byte EventType { get; }
+        public DateTime TimeSpan { get; }
+
+        public byte[] ToByteArray()
+        {
+            var timeTicks = TimeSpan.Ticks;
+            var encoding = Encoding.UTF8;
+            var dataBytesCount = encoding.GetByteCount(Data);
+            var bytes = new byte[1 + 1 + sizeof(long) + dataBytesCount]; //version + event type + time ticks + data bytes
+            bytes[0] = 0;
+            bytes[1] = EventType;
+            MemoryMarshal.Write(bytes.AsSpan()[2..], ref timeTicks);
+            var startOfDataIndex = 1 + 1 + sizeof(long);
+            if (dataBytesCount != encoding.GetBytes(Data, 0, Data.Length, bytes, startOfDataIndex))
+                throw new InvalidOperationException($"unexpected error getting utf8 bytes for event: {Data}");
+            return bytes;
+        }
+    }
+}

CA_DataUploaderLib/EventType.cs

@@ -0,0 +1,8 @@
+namespace CA_DataUploaderLib
+{
+    public enum EventType : byte
+    {
+        Alert = 0,
+        Command = 1
+    }
+}

CA_DataUploaderLib/ServerUploader.cs

@@ -8,7 +8,6 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Security.Cryptography;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
@@ -20,7 +19,7 @@ public sealed class ServerUploader : IDisposable
         private readonly PlotConnection _plot;
         private readonly Signing _signing;
         private readonly Queue<DataVector> _queue = new Queue<DataVector>();
-        private readonly Queue<string> _alertQueue = new Queue<string>();
+        private readonly Queue<EventFiredArgs> _eventsQueue = new Queue<EventFiredArgs>();
         private readonly List<DateTime> _badPackages = new List<DateTime>();
         private DateTime _lastTimestamp;
         private bool _running;
@@ -47,7 +46,7 @@ public ServerUploader(VectorDescription vectorDescription, CommandHandler cmd)
                 _cmd = cmd;
                 cmd?.AddCommand("escape", Stop);
                 if (cmd != null)
-                    cmd.AlertFired += SendAlert;
+                    cmd.EventFired += SendEvent;
             }
             catch (Exception ex)
             {
@@ -56,12 +55,11 @@ public ServerUploader(VectorDescription vectorDescription, CommandHandler cmd)
             }
         }
 
-        private void SendAlert(object sender, AlertFiredArgs e) => SendAlert(e.Message);
-        internal void SendAlert(string message)
+        private void SendEvent(object sender, EventFiredArgs e)
         {
-            lock (_alertQueue)
-                if (_alertQueue.Count < 10000)  // if sending thread can't catch up, then drop packages.
-                    _alertQueue.Enqueue(message);
+            lock (_eventsQueue)
+                if (_eventsQueue.Count < 10000)  // if sending thread can't catch up, then drop packages.
+                    _eventsQueue.Enqueue(e);
         }
 
         public void SendVector(List<double> vector, DateTime timestamp)
@@ -103,11 +101,11 @@ private void LoopForever()
                     if (list != null)
                         PostVectorAsync(GetSignedVectors(list), list.First().timestamp);
 
-                    var alerts = DequeueAllEntries(_alertQueue);
-                    if (alerts != null)
+                    var events = DequeueAllEntries(_eventsQueue);
+                    if (events != null)
                     {
-                        foreach (var alert in alerts)
-                            PostAlertAsync(alert);
+                        foreach (var @event in events)
+                            PostEventAsync(@event);
                     }
 
                     PrintBadPackagesMessage(false);
@@ -164,10 +162,10 @@ private byte[] GetSignedVectors(List<DataVector> vectors)
             return SignAndCompress(listLen.Concat(theData).ToArray());
         }
 
-        private byte[] SignedMessage(string message)
-        {
-            var buffer = Encoding.UTF8.GetBytes(message);
-            return _signing.GetSignature(buffer).Concat(buffer).ToArray();
+        private byte[] GetSignedEvent(EventFiredArgs @event)
+        { //this can be made more efficient to avoid extra allocations and/or use a memory pool, but these are for low frequency events so postponing looking at that.
+            var bytes = @event.ToByteArray();
+            return _signing.GetSignature(bytes).Concat(bytes).ToArray(); 
         }
 
         private static void OnError(string message, Exception ex) => CALog.LogErrorAndConsoleLn(LogID.A, message, ex);
@@ -188,19 +186,20 @@ private async void PostVectorAsync(byte[] buffer, DateTime timestamp)
             }
         }
 
-        private async void PostAlertAsync(string message)
+        private async void PostEventAsync(EventFiredArgs args)
         {
             try
             {
-                await _plot.PostAlertAsync(SignedMessage(message));
+                await _plot.PostEventAsync(GetSignedEvent(args));
             }
             catch (Exception ex)
             {
                 lock (_badPackages)
                 {
                     _badPackages.Add(DateTime.UtcNow);
                 }
-                OnError("failed posting alert: " + message, ex);
+
+                OnError($"failed posting event: {args.EventType} - {args.Data} - {args.TimeSpan}", ex);
             }
         }
 
@@ -252,9 +251,9 @@ public async Task PostVectorAsync(byte[] buffer, DateTime timestamp)
                 response.EnsureSuccessStatusCode();
             }
 
-            public async Task PostAlertAsync(byte[] signedMessage)
+            public async Task PostEventAsync(byte[] signedMessage)
             {
-                string query = $"api/LoopApi/AlertMessage?plotnameID={_plotID}";
+                string query = $"api/LoopApi/LogEvent?plotnameID={_plotID}";
                 var response = await _client.PutAsJsonAsync(query, signedMessage);
                 response.EnsureSuccessStatusCode();
             }

UnitTests/EventFiredArgsTests.cs

@@ -0,0 +1,24 @@
+using CA_DataUploaderLib;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Linq;
+using System.Text;
+
+namespace UnitTests
+{
+    [TestClass]
+    public class EventFiredArgsTests
+    {
+        [TestMethod]
+        public void ToByteArrayReturnsExpectedBytes()
+        {
+            const string Data = "my message";
+            DateTime timespan = new DateTime(2012, 1, 1, 1, 1, 1, 1, DateTimeKind.Utc);
+            var args = new EventFiredArgs(Data, 2, timespan);
+            var bytes = args.ToByteArray();
+            CollectionAssert.AreEqual(new byte[] { 0, 2 }, bytes.Take(2).ToList());
+            CollectionAssert.AreEqual(BitConverter.GetBytes(timespan.Ticks), bytes.Skip(2).Take(sizeof(long)).ToList());
+            CollectionAssert.AreEqual(Encoding.UTF8.GetBytes(Data), bytes.Skip(2).Skip(sizeof(long)).ToList());
+        }
+    }
+}