Staging (#566)

* First pass at plugin 'reload' system. Main benefit will be to those who rent from a provider and want to make config changes on the fly without restarting the server. (#561)

* Plugin hot reloading (#563)

* First pass at plugin 'reload' system. Main benefit will be to those who rent from a provider and want to make config changes on the fly without restarting the server.

* Flag for plugins authors to set if their plugin supports reloading or not (false by default)

* Plugin hot reloading (#564)

* First pass at plugin 'reload' system. Main benefit will be to those who rent from a provider and want to make config changes on the fly without restarting the server.

* Flag for plugins authors to set if their plugin supports reloading or not (false by default)

* Add new flag to bypass check to see if a plugin supports reloading or not.

* Fix autosave occurring when user specified to not save. (#565)

* Fix for world saving even when the user specified to not save with !stop or !restart. Also fixed typo.

* Made AutoSavePatch internal

---------

Co-authored-by: WesternGamer <80211714+WesternGamer@users.noreply.github.com>

Author: Bishbash777

Torch.API/ITorchConfig.cs

@@ -18,6 +18,7 @@ public interface ITorchConfig
         bool LocalPlugins { get; set; }
         bool RestartOnCrash { get; set; }
         bool ShouldUpdatePlugins { get; }
+        bool BypassIsReloadableFlag { get; set; }
         bool ShouldUpdateTorch { get; }
         int TickTimeout { get; set; }
         string WaitForPID { get; set; }

Torch.API/Plugins/ITorchPlugin.cs

@@ -23,6 +23,11 @@ public interface ITorchPlugin : IDisposable
         /// The name of the plugin.
         /// </summary>
         string Name { get; }
+        
+        /// <summary>
+        /// Enable/Disable Plugin reloading
+        /// </summary>
+        bool IsReloadable { get; set; }
 
         /// <summary>
         /// This is called before the game loop is started.

Torch.Server/TorchConfig.cs

@@ -47,6 +47,7 @@ public class TorchConfig : CommandLine, ITorchConfig, INotifyPropertyChanged
         private bool _sendLogsToKeen;
         private bool _deleteMiniDumps = true;
         private string _loginToken;
+        private bool bypassIsReloadableFlag;
 
 
         /// <inheritdoc />
@@ -119,6 +120,10 @@ public string InstancePath
         /// <inheritdoc />
         [Display(Name = "Update Plugins", Description = "Check every start for new versions of plugins.", GroupName = "Server")]
         public bool GetPluginUpdates { get => _getPluginUpdates; set => Set(value, ref _getPluginUpdates); }
+        
+        /// <inheritdoc />
+        [Display(Name = "Bypass reloadable flag", Description = "Bypass the reloadable flag on plugins (forces true).", GroupName = "Server")]
+        public bool BypassIsReloadableFlag { get => bypassIsReloadableFlag; set => Set(value, ref bypassIsReloadableFlag); }
 
         /// <inheritdoc />
         [Display(Name = "Watchdog Timeout", Description = "Watchdog timeout (in seconds).", GroupName = "Server")]

Torch.Server/ViewModels/PluginViewModel.cs

@@ -31,6 +31,11 @@ public PluginViewModel(ITorchPlugin plugin)
                 {
                     Control = p.GetControl();
                 }
+                catch(InvalidOperationException ex)
+                {
+                    //ignore as its likely a hot reload, we can figure out a better solution in the future.
+                    Control = null;
+                }
                 catch (Exception ex)
                 {
                     _log.Error(ex, $"Exception loading interface for plugin {Plugin.Name}! Plugin interface will not be available!");

Torch.Server/Views/PluginsControl.xaml.cs

@@ -54,9 +54,10 @@ public void BindServer(ITorchServer server)
         {
             _server = server;
             _server.Initialized += Server_Initialized;
+            _server.Managers.GetManager<PluginManager>().PluginsReloaded += PluginsReloaded;
         }
 
-        private void Server_Initialized(ITorchServer obj)
+        private void Server_Initialized(ITorchServer obj = null)
         {
             Dispatcher.InvokeAsync(() =>
             {
@@ -65,7 +66,11 @@ private void Server_Initialized(ITorchServer obj)
                 DataContext = pluginManager;
                 pluginManager.PropertyChanged += PluginManagerOnPropertyChanged;
             });
+        }
 
+        private void PluginsReloaded()
+        {
+            Server_Initialized();
         }
 
         private void OpenFolder_OnClick(object sender, RoutedEventArgs e)

Torch/Commands/TorchCommands.cs

@@ -20,6 +20,7 @@
 using Torch.Managers;
 using Torch.Mod;
 using Torch.Mod.Messages;
+using Torch.Patches;
 using VRage.Game;
 using VRage.Game.ModAPI;
 
@@ -176,6 +177,43 @@ public void Version()
             var ver = Context.Torch.TorchVersion;
             Context.Respond($"Torch version: {ver} SE version: {MyFinalBuildConstants.APP_VERSION}");
         }
+        
+        [Command("reload", "Reloads a specified plugin or all plugins if none specified.")]
+        [Permission(MyPromoteLevel.Admin)]
+        public void Reload(string plugin = null)
+        {
+            var pluginManager = Context.Torch.Managers.GetManager<PluginManager>();
+            if (pluginManager == null)
+            {
+                Context.Respond("Plugin manager not found.");
+                return;
+            }
+
+            if (string.IsNullOrEmpty(plugin))
+            {
+                pluginManager.ReloadPlugins();
+                Context.Respond("Reloaded all plugins.");
+            }
+            else
+            {
+                //find plugin by name
+                var pluginToReload = pluginManager.Plugins.Values.FirstOrDefault(p => p.Name.Equals(plugin, StringComparison.InvariantCultureIgnoreCase));
+                if (pluginToReload == null) //not found
+                {
+                    Context.Respond($"Plugin {plugin} not found.");
+                    return;
+                }
+
+                if (!pluginToReload.IsReloadable && !Context.Torch.Config.BypassIsReloadableFlag)
+                {
+                    Context.Respond($"{pluginToReload.Name} does not support reloading.");
+                }
+                
+                
+                pluginManager.ReloadPlugin(pluginToReload.Id);
+                Context.Respond($"Reloaded plugin");
+            }
+        }
 
         [Command("plugins", "Lists the currently loaded plugins.")]
         [Permission(MyPromoteLevel.None)]
@@ -292,6 +330,7 @@ private IEnumerable StopCountdown(int countdown, bool save)
                 }
                 else
                 {
+                    AutoSavePatch.SaveFromCommand = true;
                     if (save)
                     {
                         Log.Info("Saving game before stop.");
@@ -345,9 +384,10 @@ private IEnumerable RestartCountdown(int countdown, bool save)
                 }
                 else
                 {
+                    AutoSavePatch.SaveFromCommand = true;
                     if (save)
                     {
-                        Log.Info("Savin game before restart.");
+                        Log.Info("Saving game before restart.");
                         Context.Torch.CurrentSession.Managers.GetManager<IChatManagerClient>()
                            .SendMessageAsSelf($"Saving game before restart.");
                     }

Torch/Managers/PatchManager/PatchManager.cs

@@ -209,6 +209,7 @@ public override void Detach()
         {
             lock (_contexts)
             {
+                _log.Info("Removing all patches...");
                 foreach (List<PatchContext> set in _contexts.Values)
                     foreach (PatchContext ctx in set)
                         ctx.RemoveAll();

Torch/Patches/AutoSavePatch.cs

@@ -0,0 +1,87 @@
+using NLog;
+using Sandbox;
+using Sandbox.Game.World;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using Torch.Managers.PatchManager;
+using Torch.Managers.PatchManager.MSIL;
+
+namespace Torch.Patches
+{
+    /* 
+       The purpose of this patch is to prevent a autosave from occurring unintentionally during world unload initiated by the !stop or !restart command.
+       Due to the user using the command(s) potentally performing a autosave or an opting out of a autosave, Keen's autosave code during unload has to be disabled.
+       Setting MySandboxGame.ConfigDedicated.RestartSave to false can resolve this issue, but this method (patch method) prevents us from changing the config file in order to prevent confusion.
+    */
+    [PatchShim]
+    internal static class AutoSavePatch
+    {
+        private static readonly Logger _log = LogManager.GetCurrentClassLogger();
+
+        /// <summary>
+        /// If set to true, specifies that the session is being unloaded from a torch ingame chat command and that saving is being handled by the command.
+        /// </summary>
+        public static bool SaveFromCommand { get; set; } = false;
+
+        public static void Patch(PatchContext ctx)
+        {
+            var transpiler = typeof(AutoSavePatch).GetMethod(nameof(Transpile), BindingFlags.NonPublic | BindingFlags.Static);
+            ctx.GetPattern(typeof(MySession).GetMethod("Unload", BindingFlags.Public | BindingFlags.Instance))
+               .Transpilers.Add(transpiler);
+            _log.Info("Patching autosave on unload.");
+        }
+
+        private static IEnumerable<MsilInstruction> Transpile(IEnumerable<MsilInstruction> instructions)
+        {
+            var msil = instructions.ToList();
+
+            for (var i = 0; i < msil.Count; i++)
+            {
+                var instruction = msil[i];
+                if (instruction.OpCode == OpCodes.Ldsfld && instruction.Operand is MsilOperandInline.MsilOperandReflected<FieldInfo> operandReflected 
+                    && operandReflected.Value.FieldType == typeof(bool) && operandReflected.Value.Name == "IsDedicated")
+                {
+                    for (int c = 0; c < 13; c++)
+                    {
+                        msil.RemoveAt(i);
+                    }
+
+                    var call = new MsilInstruction(OpCodes.Call);
+                    (call.Operand as MsilOperandInline.MsilOperandReflected<MethodBase>).Value = typeof(AutoSavePatch).GetMethod(nameof(SaveIfNeeded), BindingFlags.NonPublic | BindingFlags.Static);
+                    msil.Insert(i, call);
+
+                    break;
+                }
+            }
+
+            return msil;
+        }
+
+        // Reimplementation of Keen's autosaving code during world unload with SaveFromCommand check and with save status being outputed to console.
+        private static void SaveIfNeeded()
+        {
+            if (SaveFromCommand)
+            {
+                return;
+            }
+
+            if (Sandbox.Engine.Platform.Game.IsDedicated && MySandboxGame.ConfigDedicated.RestartSave)
+            {
+                _log.Info("Autosaving during world unloading.");
+                // We have to use the vanilla implementation as the torch implementation does not work in Sandbox.Game.World.MySession:Unload()
+                bool result = MySession.Static.Save();
+
+                if (result)
+                {
+                    _log.Info("Autosave successful.");
+                }
+                else
+                {
+                    _log.Warn("Autosave failed.");
+                }
+            }
+        }
+    }
+}

Torch/Plugins/PluginManager.cs

@@ -9,7 +9,9 @@
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Windows;
 using System.Xml.Serialization;
+using Havok;
 using NLog;
 using Torch.API;
 using Torch.API.Managers;
@@ -25,6 +27,9 @@ namespace Torch.Managers
     /// <inheritdoc />
     public class PluginManager : Manager, IPluginManager
     {
+        
+        //event for when the plugins are reloaded
+        public event Action PluginsReloaded;
         private class PluginItem
         {
             public string Filename { get; set; }
@@ -40,6 +45,8 @@ private class PluginItem
 
         public readonly string PluginDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Plugins");
         private readonly MtObservableSortedDictionary<Guid, ITorchPlugin> _plugins = new MtObservableSortedDictionary<Guid, ITorchPlugin>();
+        private readonly List<PluginItem> _pluginItems = new List<PluginItem>();
+        private readonly List<Guid> _reloadList = new List<Guid>();
         private CommandManager _mgr;
 
 #pragma warning disable 649
@@ -192,17 +199,36 @@ public void LoadPlugins()
                 // This will happen on cylic dependencies.
                 _log.Error(e);
             }
-            
-            // Actually load the plugins now.
-            foreach (var item in pluginsToLoad)
+
+            if (_reloadList.Count > 0)
             {
-                LoadPlugin(item);
-            } 
-            
-            foreach (var plugin in _plugins.Values)
+                foreach (var item in _pluginItems)
+                {
+                    LoadPlugin(item);
+                }
+
+                foreach (var plugin in _plugins.Values)
+                {
+                    plugin.Init(Torch);
+                }
+            }
+            else
             {
-                plugin.Init(Torch);
+                foreach (var plugin in pluginsToLoad)
+                {
+                    _pluginItems.Add(plugin);
+                    LoadPlugin(plugin);
+                }
+                
+                foreach (var plugin in _plugins.Values)
+                {
+                    plugin.Init(Torch);
+                }
             }
+            
+            _reloadList.Clear();
+            
+            
             _log.Info($"Loaded {_plugins.Count} plugins.");
             PluginsLoaded?.Invoke(_plugins.Values.AsReadOnly());
         }
@@ -444,6 +470,38 @@ private static bool IsAssemblyCompatible(AssemblyName a, AssemblyName b)
         {
             return a.Name == b.Name && a.Version.Major == b.Version.Major && a.Version.Minor == b.Version.Minor;
         }
+
+        public void ReloadPlugins()
+        {
+            _log.Info("Reloading plugins.");
+            
+            var plugins = _plugins.ToList();
+
+            if (!Torch.Config.BypassIsReloadableFlag)
+                plugins = plugins.Where(p => p.Value.IsReloadable).ToList();
+            
+            foreach (var plugin in plugins)
+            {
+                _reloadList.Add(plugin.Key);
+                plugin.Value?.Dispose();
+                _plugins.Remove(plugin.Key);
+            }
+            
+            LoadPlugins();
+            PluginsReloaded?.Invoke();
+        }
+
+        public void ReloadPlugin(Guid guid)
+        {
+            var plugin = _plugins[guid];
+            
+            plugin.Dispose();
+            _plugins.Remove(guid);
+            _log.Info($"{plugin.Name} {plugin.Version} has been unloaded.");
+
+            LoadPlugin(_pluginItems.First(p => p.Manifest.Guid == guid));
+            _log.Info($"{plugin.Name} {plugin.Version} has been reloaded.");
+        }
 
         private void InstantiatePlugin(PluginManifest manifest, IEnumerable<Assembly> assemblies)
         {

Torch/Torch.csproj

@@ -240,6 +240,7 @@
     <Compile Include="Managers\PatchManager\Transpile\MethodContext.cs" />
     <Compile Include="Managers\PatchManager\Transpile\MethodTranspiler.cs" />
     <Compile Include="MySteamServiceWrapper.cs" />
+    <Compile Include="Patches\AutoSavePatch.cs" />
     <Compile Include="Patches\GameAnalyticsPatch.cs" />
     <Compile Include="Patches\GameStatePatchShim.cs" />
     <Compile Include="Patches\KeenLogPatch.cs" />