Adds run history to the UI

Fixes an issue with wcf channels timing out Fixes an issue where the notes field did not save
lithnet · Aug 20, 2017 · 013306b · 013306b
1 parent 221de54
commit 013306b
Show file tree

Hide file tree

Showing 29 changed files with 663 additions and 271 deletions.
diff --git a/src/.vs/Lithnet.Miiserver.AutoSync/v15/sqlite3/storage.ide b/src/.vs/Lithnet.Miiserver.AutoSync/v15/sqlite3/storage.ide
diff --git a/src/Lithnet.Miiserver.AutoSync/Config/RegistrySettings.cs b/src/Lithnet.Miiserver.AutoSync/Config/RegistrySettings.cs
@@ -19,7 +19,7 @@ public static RegistryKey BaseKey
             {
                 if (RegistrySettings.key == null)
                 {
-                    RegistrySettings.key = Registry.LocalMachine.OpenSubKey("System\\CurrentControlSet\\Services\\miisautosync\\Parameters", true);
+                    RegistrySettings.key = Registry.LocalMachine.OpenSubKey("System\\CurrentControlSet\\Services\\miisautosync\\Parameters", false);
                 }
 
                 return RegistrySettings.key;
@@ -30,10 +30,9 @@ public static bool ExecutionEngineEnabled
         {
             get
             {
-                int? value = RegistrySettings.BaseKey.GetValue("ExecutionEngineEnabled", 0) as int?;
+                int? value = RegistrySettings.BaseKey.GetValue("ExecutionEngineEnabled", 1) as int?;
                 return value.HasValue && value.Value != 0;
             }
-            set => RegistrySettings.BaseKey.SetValue("ExecutionEngineEnabled", value ? 1 : 0);
         }
 
         public static string LogPath

diff --git a/src/Lithnet.Miiserver.AutoSync/ConfigService/ConfigClient.cs b/src/Lithnet.Miiserver.AutoSync/ConfigService/ConfigClient.cs
@@ -4,6 +4,7 @@
 using System.Text;
 using System.ServiceModel;
 using System.Runtime.Serialization;
+using System.ServiceModel.Channels;
 using System.ServiceModel.Description;
 
 namespace Lithnet.Miiserver.AutoSync
@@ -82,5 +83,7 @@ public void RestartChangedExecutors()
         {
             this.Channel.RestartChangedExecutors();
         }
+
+
     }
 }
diff --git a/src/Lithnet.Miiserver.AutoSync/ConfigService/ConfigService.cs b/src/Lithnet.Miiserver.AutoSync/ConfigService/ConfigService.cs
@@ -57,6 +57,7 @@ public ConfigFile GetConfig()
             try
             {
                 Trace.WriteLine($"Calling {nameof(this.GetConfig)} as {Environment.UserName}");
+                Global.ThrowOnSyncEngineNotRunning();
                 ProtectedString.EncryptOnWrite = false;
                 return Program.ActiveConfig;
             }
@@ -96,6 +97,7 @@ public void PutConfigAndReloadChanged(ConfigFile config)
             try
             {
                 Trace.WriteLine($"Calling {nameof(this.PutConfig)} as {Environment.UserName}");
+                Global.ThrowOnSyncEngineNotRunning();
                 ProtectedString.EncryptOnWrite = true;
                 ConfigFile.Save(config, RegistrySettings.ConfigurationFile);
                 Program.ActiveConfig = config;
@@ -113,6 +115,7 @@ public void Reload()
             try
             {
                 Trace.WriteLine($"Calling {nameof(this.Reload)} as {Environment.UserName}");
+                Global.ThrowOnSyncEngineNotRunning();
                 Program.Reload();
             }
             catch (Exception ex)
@@ -153,6 +156,7 @@ public void Start(string managementAgentName)
         {
             try
             {
+                Global.ThrowOnSyncEngineNotRunning();
                 Program.StartExecutor(managementAgentName);
             }
             catch (Exception ex)
@@ -179,6 +183,7 @@ public void StartAll()
         {
             try
             {
+                Global.ThrowOnSyncEngineNotRunning();
                 Program.StartExecutors();
             }
             catch (Exception ex)
@@ -195,6 +200,7 @@ public ExecutorState GetEngineState()
 
         public IList<string> GetManagementAgentNames()
         {
+            Global.ThrowOnSyncEngineNotRunning();
             return ManagementAgent.GetManagementAgents().Select(t => t.Name).ToList();
         }
 
@@ -205,6 +211,7 @@ public IList<string> GetManagementAgentsPendingRestart()
 
         public void RestartChangedExecutors()
         {
+            Global.ThrowOnSyncEngineNotRunning();
             Program.RestartChangedExecutors();
         }
     }

diff --git a/src/Lithnet.Miiserver.AutoSync/EventService/EventService.cs b/src/Lithnet.Miiserver.AutoSync/EventService/EventService.cs
@@ -1,10 +1,8 @@
 using System;
-using System.Collections.Generic;
+using System.Collections.Concurrent;
 using System.Linq;
 using System.ServiceModel;
 using System.ServiceModel.Description;
-using System.Text;
-using System.Threading.Tasks;
 using Lithnet.Logging;
 using System.Diagnostics;
 
@@ -49,21 +47,51 @@ public static ServiceHost CreateInstance()
             }
         }
 
-        private static Dictionary<string, MAStateChangedEventHandler> eventHandlers;
+        private static ConcurrentDictionary<string, MAStateChangedEventHandler> statusChangedEventHandlers;
+
+        private static ConcurrentDictionary<string, RunProfileExecutionCompleteEventHandler> executionCompleteEventHandlers;
 
         internal delegate void MAStateChangedEventHandler(MAStatus status);
 
-        internal static void NotifySubscribers(MAStatus status)
+        internal delegate void RunProfileExecutionCompleteEventHandler(string runProfileName, string runProfileResult);
+
+        internal static void NotifySubscribersOnStatusChange(MAStatus status)
+        {
+            if (EventService.statusChangedEventHandlers.ContainsKey(status.MAName))
+            {
+                try
+                {
+                    EventService.statusChangedEventHandlers[status.MAName]?.Invoke(status);
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine("Error notifying client");
+                    Logger.WriteException(ex);
+                }
+            }
+        }
+
+        internal static void NotifySubscribersOnRunProfileExecutionComplete(string managementAgentName, string runProfileName, string runProfileResult)
         {
-            if (EventService.eventHandlers.ContainsKey(status.MAName))
+            if (EventService.executionCompleteEventHandlers.ContainsKey(managementAgentName))
             {
-                EventService.eventHandlers[status.MAName]?.Invoke(status);
+                try
+                {
+                    EventService.executionCompleteEventHandlers[managementAgentName]?.Invoke(runProfileName, runProfileResult);
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine("Error notifying client");
+                    Logger.WriteException(ex);
+                }
             }
         }
 
+
         static EventService()
         {
-            EventService.eventHandlers = new Dictionary<string, MAStateChangedEventHandler>(StringComparer.OrdinalIgnoreCase);
+            EventService.statusChangedEventHandlers = new ConcurrentDictionary<string, MAStateChangedEventHandler>(StringComparer.OrdinalIgnoreCase);
+            EventService.executionCompleteEventHandlers = new ConcurrentDictionary<string, RunProfileExecutionCompleteEventHandler>(StringComparer.OrdinalIgnoreCase);
         }
 
         public void Register(string managementAgentName)
@@ -72,12 +100,32 @@ public void Register(string managementAgentName)
             {
                 IEventCallBack subscriber = OperationContext.Current.GetCallbackChannel<IEventCallBack>();
 
-                if (!EventService.eventHandlers.ContainsKey(managementAgentName))
+                if (!EventService.statusChangedEventHandlers.ContainsKey(managementAgentName))
+                {
+                    EventService.statusChangedEventHandlers.TryAdd(managementAgentName, null);
+                }
+
+                EventService.statusChangedEventHandlers[managementAgentName] += subscriber.MAStatusChanged;
+
+
+                if (!EventService.executionCompleteEventHandlers.ContainsKey(managementAgentName))
                 {
-                    EventService.eventHandlers.Add(managementAgentName, null);
+                    EventService.executionCompleteEventHandlers.TryAdd(managementAgentName, null);
                 }
 
-                EventService.eventHandlers[managementAgentName] += subscriber.MAStatusChanged;
+                EventService.executionCompleteEventHandlers[managementAgentName] += subscriber.RunProfileExecutionComplete;
+
+
+                // ReSharper disable once SuspiciousTypeConversion.Global
+                ICommunicationObject commObj = subscriber as ICommunicationObject;
+                if (commObj != null)
+                {
+                    commObj.Faulted += this.CommObj_Faulted;
+                    commObj.Closed += this.CommObj_Closed;
+                }
+
+                Trace.WriteLine($"Registered callback channel for {managementAgentName}");
+
             }
             catch (Exception ex)
             {
@@ -87,6 +135,43 @@ public void Register(string managementAgentName)
             }
         }
 
+        private void CommObj_Closed(object sender, EventArgs e)
+        {
+            this.DeregisterCallbackChannel(sender);
+            Trace.WriteLine("Deregistered closed callback channel");
+        }
+
+        private void CommObj_Faulted(object sender, EventArgs e)
+        {
+            this.DeregisterCallbackChannel(sender);
+            Trace.WriteLine("Deregistered faulted callback channel");
+        }
+
+        private void DeregisterCallbackChannel(object sender)
+        {
+            IEventCallBack subscriber = sender as IEventCallBack;
+
+            if (subscriber != null)
+            {
+                foreach (string ma in EventService.statusChangedEventHandlers.Keys.ToArray())
+                {
+                    EventService.statusChangedEventHandlers[ma] -= subscriber.MAStatusChanged;
+                }
+
+                foreach (string ma in EventService.executionCompleteEventHandlers.Keys.ToArray())
+                {
+                    EventService.executionCompleteEventHandlers[ma] -= subscriber.RunProfileExecutionComplete;
+                }
+
+                // ReSharper disable once SuspiciousTypeConversion.Global
+                ICommunicationObject commObj = subscriber as ICommunicationObject;
+                if (commObj != null)
+                {
+                    commObj.Closed -= this.CommObj_Closed;
+                }
+            }
+        }
+
         public MAStatus GetFullUpdate(string managementAgentName)
         {
             try

diff --git a/src/Lithnet.Miiserver.AutoSync/EventService/EventServiceConfiguration.cs b/src/Lithnet.Miiserver.AutoSync/EventService/EventServiceConfiguration.cs
@@ -38,16 +38,16 @@ public static Binding NetNamedPipeBinding
         {
             get
             {
-                int timeout = System.Diagnostics.Debugger.IsAttached ? 900 : 100;
+                int timeout = System.Diagnostics.Debugger.IsAttached ? 60 : 60;
 
                 NetNamedPipeBinding binding = new NetNamedPipeBinding();
                 binding.MaxReceivedMessageSize = int.MaxValue;
                 binding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
                 binding.ReaderQuotas.MaxBytesPerRead = int.MaxValue;
                 binding.CloseTimeout = TimeSpan.FromSeconds(timeout);
                 binding.OpenTimeout = TimeSpan.FromSeconds(timeout);
-                binding.ReceiveTimeout = TimeSpan.FromSeconds(timeout);
-                binding.SendTimeout = TimeSpan.FromSeconds(timeout);
+                binding.ReceiveTimeout = TimeSpan.MaxValue;
+                binding.SendTimeout = TimeSpan.MaxValue;
                 binding.TransactionFlow = false;
                 binding.Security.Mode = NetNamedPipeSecurityMode.Transport;
                 binding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None;

diff --git a/src/Lithnet.Miiserver.AutoSync/EventService/IEventCallback.cs b/src/Lithnet.Miiserver.AutoSync/EventService/IEventCallback.cs
@@ -11,5 +11,8 @@ public interface IEventCallBack
     {
         [OperationContract (IsOneWay = true)]
         void MAStatusChanged(MAStatus status);
+
+        [OperationContract(IsOneWay = true)]
+        void RunProfileExecutionComplete(string runProfileName, string result);
     }
 }
diff --git a/src/Lithnet.Miiserver.AutoSync/Exceptions/SyncEngineStoppedException.cs b/src/Lithnet.Miiserver.AutoSync/Exceptions/SyncEngineStoppedException.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace Lithnet.Miiserver.AutoSync
+{
+    [Serializable]
+    public class SyncEngineStoppedException : Exception
+    {
+        public SyncEngineStoppedException()
+        {
+        }
+
+        public SyncEngineStoppedException(string message)
+            : base(message)
+        {
+        }
+
+        public SyncEngineStoppedException(string message, Exception innerException)
+        : base(message, innerException)
+        {
+        }
+    }
+}
diff --git a/src/Lithnet.Miiserver.AutoSync/ExecutionEngine.cs b/src/Lithnet.Miiserver.AutoSync/ExecutionEngine.cs
@@ -85,7 +85,17 @@ public IList<string> GetManagementAgentsPendingRestart()
                     continue;
                 }
 
-                if (e.Configuration == null || e.Configuration.Version != newItem.Version)
+                if (e.ControlState == ControlState.Stopped)
+                {
+                    continue;
+                }
+
+                if (e.Configuration == null)
+                {
+                    continue;
+                }
+
+                if (e.Configuration.Version != newItem.Version)
                 {
                     restartItems.Add(newItem.ManagementAgentName);
                 }
@@ -172,51 +182,50 @@ private void InitializeMAExecutors()
             {
                 MAExecutor x = new MAExecutor(ma);
                 x.StateChanged += this.X_StateChanged;
+                x.RunProfileExecutionComplete += this.X_RunProfileExecutionComplete;
                 this.maExecutors.Add(ma.Name, x);
             }
         }
 
+        private void X_RunProfileExecutionComplete(object sender, string runProfileName, string result)
+        {
+            EventService.NotifySubscribersOnRunProfileExecutionComplete(((MAExecutor)sender).ManagementAgentName, runProfileName, result);
+        }
+
+        private void X_StateChanged(object sender, MAStatusChangedEventArgs e)
+        {
+            EventService.NotifySubscribersOnStatusChange(e.Status);
+        }
+
         private void StartMAExecutors()
         {
             this.cancellationToken = new CancellationTokenSource();
 
-            if (RegistrySettings.ExecutionEngineEnabled)
+            foreach (MAConfigParameters c in Program.ActiveConfig.ManagementAgents)
             {
-                foreach (MAConfigParameters c in Program.ActiveConfig.ManagementAgents)
+                if (c.IsMissing)
                 {
-                    if (c.IsMissing)
-                    {
-                        Logger.WriteLine("{0}: Skipping management agent because it is missing from the Sync Engine", c.ManagementAgentName);
-                        continue;
-                    }
+                    Logger.WriteLine("{0}: Skipping management agent because it is missing from the Sync Engine", c.ManagementAgentName);
+                    continue;
+                }
 
-                    if (this.maExecutors.ContainsKey(c.ManagementAgentName))
+                if (this.maExecutors.ContainsKey(c.ManagementAgentName))
+                {
+                    Trace.WriteLine($"Starting {c.ManagementAgentName}");
+                    Task.Run(() =>
                     {
-                        Trace.WriteLine($"Starting {c.ManagementAgentName}");
-                        Task.Run(() =>
+                        MAExecutor e = this.maExecutors[c.ManagementAgentName];
+                        lock (e)
                         {
-                            MAExecutor e = this.maExecutors[c.ManagementAgentName];
-                            lock (e)
-                            {
-                                e.Start(c);
-                            }
-                        }, this.cancellationToken.Token);
-                    }
-                    else
-                    {
-                        Logger.WriteLine($"Cannot start management agent executor '{c.ManagementAgentName}' because the management agent was not found");
-                    }
+                            e.Start(c);
+                        }
+                    }, this.cancellationToken.Token);
+                }
+                else
+                {
+                    Logger.WriteLine($"Cannot start management agent executor '{c.ManagementAgentName}' because the management agent was not found");
                 }
             }
-            else
-            {
-                Logger.WriteLine("Execution engine has been disabled");
-            }
-        }
-
-        private void X_StateChanged(object sender, MAStatusChangedEventArgs e)
-        {
-            EventService.NotifySubscribers(e.Status);
         }
 
         private void StopMAExecutors()