Implement progress state reporting via mgmt hub

webprofusion-chrisc · webprofusion-chrisc · commit 3efe9405b6f6 · 2024-11-19T19:27:51.000+08:00
diff --git a/src/Certify.Client/ManagementServerClient.cs b/src/Certify.Client/ManagementServerClient.cs
@@ -137,5 +137,24 @@ public void SendInstanceInfo(Guid commandId, bool isCommandResponse = true)
             result.ObjectValue = _instanceInfo;
             _connection.SendAsync(ManagementHubMessages.ReceiveCommandResult, result);
         }
+
+        /// <summary>
+        /// Send mgmt hub a general notification message to be actioned
+        /// </summary>
+        public void SendNotificationToManagementHub(string msgCommandType, object updateMsg)
+        {
+            var result = new InstanceCommandResult
+            {
+                CommandId = Guid.NewGuid(),
+                InstanceId = _instanceInfo.InstanceId,
+                CommandType = msgCommandType,
+                Value = System.Text.Json.JsonSerializer.Serialize(updateMsg),
+                ObjectValue = updateMsg,
+                IsCommandResponse = false
+            };
+
+            result.ObjectValue = updateMsg;
+            _connection.SendAsync(ManagementHubMessages.ReceiveCommandResult, result);
+        }
     }
 }
diff --git a/src/Certify.Core/Management/CertifyManager/CertifyManager.ManagementHub.cs b/src/Certify.Core/Management/CertifyManager/CertifyManager.ManagementHub.cs
@@ -129,15 +129,26 @@ private async Task<InstanceCommandResult> _managementServerClient_OnGetCommandRe
                 var managedCertArg = args.FirstOrDefault(a => a.Key == "managedCert");
                 var managedCert = JsonSerializer.Deserialize<ManagedCertificate>(managedCertArg.Value);
 
-                val = await UpdateManagedCertificate(managedCert);
+                var item = await UpdateManagedCertificate(managedCert);
+
+                val = item;
+
+                ReportManagedItemUpdateToMgmtHub(item);
             }
-            else if (arg.CommandType == ManagementHubCommands.RemoveDeleteManagedItem)
+            else if (arg.CommandType == ManagementHubCommands.RemoveManagedItem)
             {
                 // delete a single managed item 
                 var args = JsonSerializer.Deserialize<KeyValuePair<string, string>[]>(arg.Value);
                 var managedCertIdArg = args.FirstOrDefault(a => a.Key == "managedCertId");
 
-                await DeleteManagedCertificate(managedCertIdArg.Value);
+                var actionResult = await DeleteManagedCertificate(managedCertIdArg.Value);
+
+                val = actionResult;
+
+                if (actionResult.IsSuccess)
+                {
+                    ReportManagedItemDeleteToMgmtHub(managedCertIdArg.Value);
+                }
             }
             else if (arg.CommandType == ManagementHubCommands.TestManagedItemConfiguration)
             {
@@ -264,9 +275,26 @@ private async Task<InstanceCommandResult> _managementServerClient_OnGetCommandRe
             return result;
         }
 
+        private void ReportManagedItemUpdateToMgmtHub(ManagedCertificate item)
+        {
+            if (item != null)
+            {
+                _managementServerClient?.SendNotificationToManagementHub(ManagementHubCommands.NotificationUpdatedManagedItem, item);
+            }
+        }
+        private void ReportManagedItemDeleteToMgmtHub(string id)
+        {
+            _managementServerClient?.SendNotificationToManagementHub(ManagementHubCommands.NotificationRemovedManagedItem, id);
+        }
+
+        private void ReportRequestProgressToMgmtHub(RequestProgressState progress)
+        {
+            _managementServerClient?.SendNotificationToManagementHub(ManagementHubCommands.NotificationManagedItemRequestProgress, progress);
+        }
+
         private void _managementServerClient_OnConnectionReconnecting()
         {
-            _serviceLog.Warning("Reconnecting to Management.");
+            _serviceLog.Warning("Reconnecting to Management Hub.");
         }
 
         private void GenerateDemoItems()
diff --git a/src/Certify.Core/Management/CertifyManager/CertifyManager.cs b/src/Certify.Core/Management/CertifyManager/CertifyManager.cs
@@ -1,4 +1,4 @@
-using System;
+﻿using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
@@ -325,7 +325,7 @@ private async Task InitDataStore()
                 {
                     _itemManager = new SQLiteManagedItemStore("", _serviceLog);
                     _credentialsManager = new SQLiteCredentialStore("", _serviceLog);
-                    
+
                     _configStore = new SQLiteConfigurationStore("", _serviceLog);
                     _accessControl = new AccessControl(_serviceLog, _configStore);
                 }
@@ -425,10 +425,12 @@ public void ReportProgress(IProgress<RequestProgressState> progress, RequestProg
                 progress.Report(state);
             }
 
-            // report request state to status hub clients
+            // report request state to status hub clients and optionally mgmt hub
 
             _statusReporting?.ReportRequestProgress(state);
 
+            ReportRequestProgressToMgmtHub(state);
+
             if (state.ManagedCertificate != null && logThisEvent)
             {
                 if (state.CurrentState == RequestState.Error)
diff --git a/src/Certify.Models/Hub/ManagementHubMessages.cs b/src/Certify.Models/Hub/ManagementHubMessages.cs
@@ -7,6 +7,7 @@ public class ManagementHubMessages
     {
         public const string SendCommandRequest = "SendCommandRequest";
         public const string ReceiveCommandResult = "ReceiveCommandResult";
+        public const string Notification = "Notification";
         public const string GetCommandResult = "GetCommandResult";
     }
 
@@ -20,7 +21,7 @@ public class ManagementHubCommands
         public const string GetManagedItemRenewalPreview = "GetManagedItemRenewalPreview";
 
         public const string UpdateManagedItem = "UpdateManagedItem";
-        public const string RemoveDeleteManagedItem = "RemoveManagedItem";
+        public const string RemoveManagedItem = "RemoveManagedItem";
         public const string TestManagedItemConfiguration = "TestManagedItemConfiguration";
         public const string PerformManagedItemRequest = "PerformManagedItemRequest";
 
@@ -43,6 +44,13 @@ public class ManagementHubCommands
         public const string ExecuteDeploymentTask = "ExecuteDeploymentTask";
 
         public const string Reconnect = "Reconnect";
+
+        /// <summary>
+        /// Notification messages are used to send topic specific info ad-hoc back to the mgmt hub
+        /// </summary>
+        public const string NotificationRemovedManagedItem = "NotificationRemovedManagedItem";
+        public const string NotificationUpdatedManagedItem = "NotificationUpdatedManagedItem";
+        public const string NotificationManagedItemRequestProgress = "NotificationManagedItemRequestProgress";
     }
 
     /// <summary>
diff --git a/src/Certify.Server/Certify.Server.Api.Public/SignalR/ManagementHub/InstanceManagementHub.cs b/src/Certify.Server/Certify.Server.Api.Public/SignalR/ManagementHub/InstanceManagementHub.cs
@@ -39,16 +39,18 @@ public class InstanceManagementHub : Hub<IInstanceManagementHub>, IInstanceManag
     {
         private IInstanceManagementStateProvider _stateProvider;
         private ILogger<InstanceManagementHub> _logger;
+        private IHubContext<UserInterfaceStatusHub> _uiStatusHub;
 
         /// <summary>
         /// Set up instance management hub
         /// </summary>
         /// <param name="stateProvider"></param>
         /// <param name="logger"></param>
-        public InstanceManagementHub(IInstanceManagementStateProvider stateProvider, ILogger<InstanceManagementHub> logger)
+        public InstanceManagementHub(IInstanceManagementStateProvider stateProvider, ILogger<InstanceManagementHub> logger, IHubContext<UserInterfaceStatusHub> uiStatusHub)
         {
             _stateProvider = stateProvider;
             _logger = logger;
+            _uiStatusHub = uiStatusHub;
         }
 
         /// <summary>
@@ -170,7 +172,7 @@ public Task ReceiveCommandResult(InstanceCommandResult result)
                     if (!string.IsNullOrWhiteSpace(instanceId))
                     {
                         // action this message from this instance
-                        _logger?.LogInformation("Received instance command result {result}", result);
+                        _logger?.LogInformation("Received instance command result {result}", result.CommandType);
 
                         if (cmd.CommandType == ManagementHubCommands.GetManagedItems)
                         {
@@ -189,12 +191,32 @@ public Task ReceiveCommandResult(InstanceCommandResult result)
                         else
                         {
                             // store for something else to consume
-                            _stateProvider.AddAwaitedCommandResult(result);
+                            if (result.IsCommandResponse)
+                            {
+                                _stateProvider.AddAwaitedCommandResult(result);
+                            }
+                            else
+                            {
+                                // item was not requested, queue for processing
+                                if (result.CommandType == ManagementHubCommands.NotificationUpdatedManagedItem)
+                                {
+                                    _uiStatusHub.Clients.All.SendAsync(Providers.StatusHubMessages.SendManagedCertificateUpdateMsg, System.Text.Json.JsonSerializer.Deserialize<Models.ManagedCertificate>(result.Value));
+                                }
+                                else if (result.CommandType == ManagementHubCommands.NotificationManagedItemRequestProgress)
+                                {
+                                    _uiStatusHub.Clients.All.SendAsync(Providers.StatusHubMessages.SendProgressStateMsg, System.Text.Json.JsonSerializer.Deserialize<Models.RequestProgressState>(result.Value));
+                                }
+                                else if (result.CommandType == ManagementHubCommands.NotificationRemovedManagedItem)
+                                {
+                                    // deleted :TODO
+                                    _uiStatusHub.Clients.All.SendAsync(Providers.StatusHubMessages.SendMsg, $"Deleted item {result.Value}");
+                                }
+                            }
                         }
                     }
                     else
                     {
-                        _logger?.LogError("Received instance command result for an unknown instance {result}", result);
+                        _logger?.LogError("Received instance command result for an unknown instance {result}", result.CommandType);
                     }
                 }
             }
diff --git a/src/Certify.Server/Certify.Server.Api.Public/SignalR/ManagementHub/InstanceManagementStateProvider.cs b/src/Certify.Server/Certify.Server.Api.Public/SignalR/ManagementHub/InstanceManagementStateProvider.cs
@@ -189,19 +189,10 @@ public ConcurrentDictionary<string, StatusSummary> GetManagedInstanceStatusSumma
         public void UpdateCachedManagedInstanceItem(string instanceId, ManagedCertificate managedCertificate)
         {
             _managedInstanceItems.TryGetValue(instanceId, out var instance);
-
-            if (instance != null)
+            if (instance?.Items != null)
             {
-                foreach (var item in instance.Items)
-                {
-                    if (item.Id == managedCertificate.Id)
-                    {
-                        instance.Items.Remove(item);
-                        managedCertificate.InstanceId = instanceId;
-                        instance.Items.Add(managedCertificate);
-                        return;
-                    }
-                }
+                instance.Items.RemoveAll(r => r.Id == managedCertificate.Id);
+                instance.Items.Add(managedCertificate);
             }
         }
 
@@ -219,16 +210,9 @@ public void DeleteCachedManagedInstanceItem(string instanceId, string managedCer
         {
             _managedInstanceItems.TryGetValue(instanceId, out var instance);
 
-            if (instance != null)
+            if (instance?.Items != null)
             {
-                foreach (var item in instance.Items)
-                {
-                    if (item.Id == managedCertificateId)
-                    {
-                        instance.Items.Remove(item);
-                        return;
-                    }
-                }
+                instance.Items.RemoveAll(r => r.Id == managedCertificateId);
             }
         }
     }
diff --git a/src/Certify.Server/Certify.Server.Core/Certify.Server.Core/Controllers/ManagedCertificateController.cs b/src/Certify.Server/Certify.Server.Core/Certify.Server.Core/Controllers/ManagedCertificateController.cs
@@ -1,4 +1,4 @@
-﻿using Certify.Config;
+using Certify.Config;
 using Certify.Models.Hub;
 using Certify.Management;
 using Certify.Models;

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using System;`
	`1`	`+using System;`
`2`	`2`	`using System.Collections.Concurrent;`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.IO;`
`@@ -325,7 +325,7 @@ private async Task InitDataStore()`
`325`	`325`	`{`
`326`	`326`	`_itemManager = new SQLiteManagedItemStore("", _serviceLog);`
`327`	`327`	`_credentialsManager = new SQLiteCredentialStore("", _serviceLog);`
`328`		`-`
	`328`	`+`
`329`	`329`	`_configStore = new SQLiteConfigurationStore("", _serviceLog);`
`330`	`330`	`_accessControl = new AccessControl(_serviceLog, _configStore);`
`331`	`331`	`}`
`@@ -425,10 +425,12 @@ public void ReportProgress(IProgress<RequestProgressState> progress, RequestProg`
`425`	`425`	`progress.Report(state);`
`426`	`426`	`}`
`427`	`427`
`428`		`- // report request state to status hub clients`
	`428`	`+ // report request state to status hub clients and optionally mgmt hub`
`429`	`429`
`430`	`430`	`_statusReporting?.ReportRequestProgress(state);`
`431`	`431`
	`432`	`+ ReportRequestProgressToMgmtHub(state);`
	`433`	`+`
`432`	`434`	`if (state.ManagedCertificate != null && logThisEvent)`
`433`	`435`	`{`
`434`	`436`	`if (state.CurrentState == RequestState.Error)`
Original file line number	Diff line number	Diff line change
`@@ -39,16 +39,18 @@ public class InstanceManagementHub : Hub<IInstanceManagementHub>, IInstanceManag`
`39`	`39`	`{`
`40`	`40`	`private IInstanceManagementStateProvider _stateProvider;`
`41`	`41`	`private ILogger<InstanceManagementHub> _logger;`
	`42`	`+ private IHubContext<UserInterfaceStatusHub> _uiStatusHub;`
`42`	`43`
`43`	`44`	`/// <summary>`
`44`	`45`	`/// Set up instance management hub`
`45`	`46`	`/// </summary>`
`46`	`47`	`/// <param name="stateProvider"></param>`
`47`	`48`	`/// <param name="logger"></param>`
`48`		`- public InstanceManagementHub(IInstanceManagementStateProvider stateProvider, ILogger<InstanceManagementHub> logger)`
	`49`	`+ public InstanceManagementHub(IInstanceManagementStateProvider stateProvider, ILogger<InstanceManagementHub> logger, IHubContext<UserInterfaceStatusHub> uiStatusHub)`
`49`	`50`	`{`
`50`	`51`	`_stateProvider = stateProvider;`
`51`	`52`	`_logger = logger;`
	`53`	`+ _uiStatusHub = uiStatusHub;`
`52`	`54`	`}`
`53`	`55`
`54`	`56`	`/// <summary>`
`@@ -170,7 +172,7 @@ public Task ReceiveCommandResult(InstanceCommandResult result)`
`170`	`172`	`if (!string.IsNullOrWhiteSpace(instanceId))`
`171`	`173`	`{`
`172`	`174`	`// action this message from this instance`
`173`		`- _logger?.LogInformation("Received instance command result {result}", result);`
	`175`	`+ _logger?.LogInformation("Received instance command result {result}", result.CommandType);`
`174`	`176`
`175`	`177`	`if (cmd.CommandType == ManagementHubCommands.GetManagedItems)`
`176`	`178`	`{`
`@@ -189,12 +191,32 @@ public Task ReceiveCommandResult(InstanceCommandResult result)`
`189`	`191`	`else`
`190`	`192`	`{`
`191`	`193`	`// store for something else to consume`
`192`		`- _stateProvider.AddAwaitedCommandResult(result);`
	`194`	`+ if (result.IsCommandResponse)`
	`195`	`+ {`
	`196`	`+ _stateProvider.AddAwaitedCommandResult(result);`
	`197`	`+ }`
	`198`	`+ else`
	`199`	`+ {`
	`200`	`+ // item was not requested, queue for processing`
	`201`	`+ if (result.CommandType == ManagementHubCommands.NotificationUpdatedManagedItem)`
	`202`	`+ {`
	`203`	`+ _uiStatusHub.Clients.All.SendAsync(Providers.StatusHubMessages.SendManagedCertificateUpdateMsg, System.Text.Json.JsonSerializer.Deserialize<Models.ManagedCertificate>(result.Value));`
	`204`	`+ }`
	`205`	`+ else if (result.CommandType == ManagementHubCommands.NotificationManagedItemRequestProgress)`
	`206`	`+ {`
	`207`	`+ _uiStatusHub.Clients.All.SendAsync(Providers.StatusHubMessages.SendProgressStateMsg, System.Text.Json.JsonSerializer.Deserialize<Models.RequestProgressState>(result.Value));`
	`208`	`+ }`
	`209`	`+ else if (result.CommandType == ManagementHubCommands.NotificationRemovedManagedItem)`
	`210`	`+ {`
	`211`	`+ // deleted :TODO`
	`212`	`+ _uiStatusHub.Clients.All.SendAsync(Providers.StatusHubMessages.SendMsg, $"Deleted item {result.Value}");`
	`213`	`+ }`
	`214`	`+ }`
`193`	`215`	`}`
`194`	`216`	`}`
`195`	`217`	`else`
`196`	`218`	`{`
`197`		`- _logger?.LogError("Received instance command result for an unknown instance {result}", result);`
	`219`	`+ _logger?.LogError("Received instance command result for an unknown instance {result}", result.CommandType);`
`198`	`220`	`}`
`199`	`221`	`}`
`200`	`222`	`}`
Original file line number	Diff line number	Diff line change
`@@ -189,19 +189,10 @@ public ConcurrentDictionary<string, StatusSummary> GetManagedInstanceStatusSumma`
`189`	`189`	`public void UpdateCachedManagedInstanceItem(string instanceId, ManagedCertificate managedCertificate)`
`190`	`190`	`{`
`191`	`191`	`_managedInstanceItems.TryGetValue(instanceId, out var instance);`
`192`		`-`
`193`		`- if (instance != null)`
	`192`	`+ if (instance?.Items != null)`
`194`	`193`	`{`
`195`		`- foreach (var item in instance.Items)`
`196`		`- {`
`197`		`- if (item.Id == managedCertificate.Id)`
`198`		`- {`
`199`		`- instance.Items.Remove(item);`
`200`		`- managedCertificate.InstanceId = instanceId;`
`201`		`- instance.Items.Add(managedCertificate);`
`202`		`- return;`
`203`		`- }`
`204`		`- }`
	`194`	`+ instance.Items.RemoveAll(r => r.Id == managedCertificate.Id);`
	`195`	`+ instance.Items.Add(managedCertificate);`
`205`	`196`	`}`
`206`	`197`	`}`
`207`	`198`
`@@ -219,16 +210,9 @@ public void DeleteCachedManagedInstanceItem(string instanceId, string managedCer`
`219`	`210`	`{`
`220`	`211`	`_managedInstanceItems.TryGetValue(instanceId, out var instance);`
`221`	`212`
`222`		`- if (instance != null)`
	`213`	`+ if (instance?.Items != null)`
`223`	`214`	`{`
`224`		`- foreach (var item in instance.Items)`
`225`		`- {`
`226`		`- if (item.Id == managedCertificateId)`
`227`		`- {`
`228`		`- instance.Items.Remove(item);`
`229`		`- return;`
`230`		`- }`
`231`		`- }`
	`215`	`+ instance.Items.RemoveAll(r => r.Id == managedCertificateId);`
`232`	`216`	`}`
`233`	`217`	`}`
`234`	`218`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using Certify.Config;`
	`1`	`+using Certify.Config;`
`2`	`2`	`using Certify.Models.Hub;`
`3`	`3`	`using Certify.Management;`
`4`	`4`	`using Certify.Models;`