Load plugins from Plugins directory, refine publish command args

Author: ethanhann

docs-src/commands.md

@@ -219,14 +219,14 @@ The **InEngine.Core** plugin's command to clear the InEngine.NET queues produces
 InEngine 3.x
 Copyright © 2017 Ethan Hann
 
-  --command-plugin    Required. The name of a command plugin file, e.g. 
+  --plugin            Required. The name of a command plugin file, e.g. 
                       InEngine.Core
 
-  --command-verb      A plugin command verb, e.g. echo
+  --command           A command name, e.g. echo
 
-  --command-class     A command class name, e.g. 
+  --class             A command class, e.g. 
                       InEngine.Core.Commands.AlwaysSucceed. Takes precedence 
-                      over --command-verb if both are specified.
+                      over --command if both are specified.
 
   --args              An optional list of arguments to publish with the 
                       command.

docs-src/configuration.md

@@ -7,9 +7,9 @@ The **-c, --configuration** argument can also be used to specify an alternate co
 ```json
 {
   "InEngine": {
-    "Plugins": [
-      "path/to/MyCommandPlugin"
-    ],
+    "Plugins": {
+      "MyPlugin": "/path/to/plugin/assembly"
+    },
     "ExecWhitelist": {
       "foo": "/path/to/foo.exe"
     },
@@ -37,10 +37,10 @@ The **-c, --configuration** argument can also be used to specify an alternate co
 
 ## Top-level Settings
 
-| Setting                   | Type              | Description                                                                                                           |
-| ------------------------- | ----------------- | --------------------------------------------------------------------------------------------------------------------- |
-| Plugins                   | array of strings  | A list of paths of plugin assemblies, with ".dll" omitted from the assembly name.                                     |
-| ExecWhitelist             | object            | A set of key/value pairs, where the value is the file system path of an executable and the key is a command alias.    |
+| Setting                   | Type              | Description                                                                                                                                |
+| ------------------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| Plugins                   | object            | A set of key/value pairs, where the value is the directory where the plugin is located and the key is the plugin name sans .dll extension. |
+| ExecWhitelist             | object            | A set of key/value pairs, where the value is the file system path of an executable and the key is a command alias.                         |
 
 
 ## Mail Settings

docs-src/index.md

@@ -37,7 +37,7 @@ Want to queue our example echo command to run in the background or possibly on a
 Use the core plugin's **queue:publish** command:
 
 ```bash
-inengine.exe queue:publish --command-plugin=InEngine.Core --command-verb=echo --args "text=Hello, world"
+inengine.exe queue:publish --plugin=InEngine.Core --command=echo --args "text=Hello, world"
 ``` 
 
 How do we consume that queued echo command?
@@ -86,5 +86,5 @@ It opens up the possibility of running shell scripts, ETLs, Java programs, etc.
 The example python script can be queued:
 
 ```bash
-inengine queue:publish --command-plugin=InEngine.Core --command-verb=exec --args="executable=helloworld"
+inengine queue:publish --plugin=InEngine.Core --command=exec --args="executable=helloworld"
 ```

docs-src/queuing.md

@@ -98,7 +98,7 @@ Enqueue.Command(() => Console.WriteLine("Hello, world!"))
 The **exec** command allows for external programs to be executed.
 
 ```bash
-inengine queue:publish --command-plugin=InEngine.Core --command-verb=exe --args="command=/usr/bin/python" "args=--version"
+inengine queue:publish --plugin=InEngine.Core --command=exe --args="command=/usr/bin/python" "args=--version"
 ```
 
 !!! note "Do not include "--" for the command and args parameters."
@@ -171,19 +171,19 @@ Note that all queue commands reside in the **InEngine.Core** plugin.
 This is an example of how to publish a command from the CLI by specifying the command's plugin, class name, and arguments:
 
 ```bash
-inengine.exe queue:publish --command-plugin=MyCommandPlugin --command-class=MyCommand --args "text=bar"
+inengine.exe queue:publish --plugin=MyCommandPlugin --class=MyCommand --args "text=bar"
 ```
 
 There is an "Echo" command in the *InEngine.Core* package. It is useful for end-to-end testing with the queue feature.
 
 ```bash
-inengine.exe queue:publish --command-plugin=InEngine.Core --command-class=InEngine.Core.Commands.Echo --args "text=foo"
+inengine.exe queue:publish --plugin=InEngine.Core --class=InEngine.Core.Commands.Echo --args "text=foo"
 ```
 
 The command verb can also be specified instead of the full class name:
 
 ```bash
-inengine.exe queue:publish --command-plugin=InEngine.Core --command-verb=echo--args "text=foo"
+inengine.exe queue:publish --plugin=InEngine.Core --command=echo--args "text=foo"
 ```
 
 ## Consuming Commands

src/InEngine.Core/Exceptions/PluginNotRegisteredException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace InEngine.Core.Exceptions
+{
+    public class PluginNotRegisteredException : Exception
+    {
+        public PluginNotRegisteredException(string message = "") : base(message)
+        {}
+
+        public PluginNotRegisteredException(string message, Exception innerException) : base(message, innerException)
+        {}
+    }
+}

src/InEngine.Core/InEngineSettings.cs

@@ -12,7 +12,7 @@ public class InEngineSettings
     {
         public static string BasePath { get; set; } = Directory.GetCurrentDirectory();
         public static string ConfigurationFile { get; set; } = "appsettings.json";
-        public List<string> Plugins { get; set; } = new List<string>();
+        public IDictionary<string, string> Plugins { get; set; } = new Dictionary<string, string>();
         public QueueSettings Queue { get; set; } = new QueueSettings();
         public MailSettings Mail { get; set; } = new MailSettings();
         public IDictionary<string, string> ExecWhitelist { get; set; } = new Dictionary<string, string>();

src/InEngine.Core/PluginAssembly.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Threading;
 using CommandLine;
 using InEngine.Core.Exceptions;
 
@@ -14,50 +15,48 @@ public class PluginAssembly
         public string Name { get { return Assembly.GetName().Name; } }
         public string Version { get { return Assembly.GetName().Version.ToString(); } }
         public List<AbstractPlugin> Plugins { get; set; }
+        public volatile static bool isAssemblyResolverRegistered = false;
+        public static Mutex assemblyResolverLock = new Mutex();
+
         public PluginAssembly(Assembly assembly)
         {
             Assembly = assembly;
             Plugins = Make<AbstractPlugin>();
         }
 
-        public static PluginAssembly LoadFrom(string assemblyPath)
+        public static PluginAssembly LoadFrom(string pluginName)
         {
-            var path = Path.Combine(InEngineSettings.BasePath, assemblyPath);
+            RegisterPluginAssemblyResolver();
+            var path = MakeFullPluginAssemblyPath(pluginName);
             try
             {
-                return new PluginAssembly(Assembly.LoadFrom(path));   
+                return new PluginAssembly(Assembly.LoadFrom(path));
             }
             catch (Exception exception)
             {
                 throw new PluginNotFoundException($"Plugin not found at {path}", exception);
             }
         }
 
-        public List<T> Make<T>() where T : class, IPlugin
-        {
-            return Assembly
-                .GetTypes()
-                .Where(x => x.IsClass && typeof(T).IsAssignableFrom(x) && !x.IsAbstract)
-                .Select(x => Assembly.CreateInstance(x.FullName) as T)
-                .ToList();
-        }
-
-        public static List<PluginAssembly> Load<T>() where T : IPlugin
+        public static List<PluginAssembly> Load<T>(bool shouldLoadCorePlugin = true) where T : IPlugin
         {
+            RegisterPluginAssemblyResolver();
             var pluginList = new List<PluginAssembly>();
+
             try
             {
-                pluginList.Add(new PluginAssembly(Assembly.GetExecutingAssembly()));    
-            } 
+                if (shouldLoadCorePlugin)
+                    pluginList.Add(new PluginAssembly(Assembly.GetExecutingAssembly()));
+            }
             catch (Exception exception)
             {
                 throw new PluginNotFoundException("Could not load InEngine.Core plugin.", exception);
             }
-                    
+
             var assemblies = InEngineSettings
                 .Make()
                 .Plugins
-                .Select(x => Assembly.LoadFrom($"{x}.dll"));
+                .Select(x => Assembly.LoadFrom(Path.Combine(x.Value, $"{x.Key}.dll")));
             foreach (var assembly in assemblies)
             {
                 try
@@ -75,6 +74,48 @@ public static List<PluginAssembly> Load<T>() where T : IPlugin
             return pluginList.OrderBy(x => x.Name).ToList();
         }
 
+        public static void RegisterPluginAssemblyResolver()
+        {
+            assemblyResolverLock.WaitOne();
+            if (!isAssemblyResolverRegistered) {
+                isAssemblyResolverRegistered = true;
+                AppDomain.CurrentDomain.AssemblyResolve += LoadPluginEventHandler;
+            }
+            assemblyResolverLock.ReleaseMutex();
+        }
+
+        static Assembly LoadPluginEventHandler(object sender, ResolveEventArgs args)
+        {
+            var assemblyName = new AssemblyName(args.Name).Name;
+            var pluginName = assemblyName.Substring(0, assemblyName.Length - 4);
+            var assemblyPath = MakeFullPluginAssemblyPath(pluginName);
+            if (!File.Exists(assemblyPath))
+                return null;
+            return Assembly.LoadFrom(assemblyPath);
+        }
+
+        static string MakeFullPluginAssemblyPath(string pluginName)
+        {
+            var plugins = InEngineSettings.Make().Plugins;
+            if (!plugins.ContainsKey(pluginName))
+                throw new PluginNotRegisteredException(pluginName);
+            
+            return Path.Combine(
+                Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
+                plugins[pluginName],
+                $"{pluginName}.dll"
+            );
+        }
+
+        public List<T> Make<T>() where T : class, IPlugin
+        {
+            return Assembly
+                .GetTypes()
+                .Where(x => x.IsClass && typeof(T).IsAssignableFrom(x) && !x.IsAbstract)
+                .Select(x => Assembly.CreateInstance(x.FullName) as T)
+                .ToList();
+        }
+
         public AbstractCommand CreateCommandFromClass(string fullCommandName)
         {
             return Assembly.CreateInstance(fullCommandName) as AbstractCommand;
@@ -96,7 +137,7 @@ public AbstractCommand CreateCommandFromVerb(string verbName)
                 throw new AmbiguousCommandException(verbName);
             if (commandCount == 0)
                 throw new CommandNotFoundException(verbName);
-            return Assembly.CreateInstance(commandClassNames.First()) as AbstractCommand;   
+            return Assembly.CreateInstance(commandClassNames.First()) as AbstractCommand;
         }
     }
 }

src/InEngine.Core/Queuing/Commands/Publish.cs

@@ -7,13 +7,13 @@ namespace InEngine.Core.Queuing.Commands
 {
     public class Publish : AbstractCommand
     {
-        [Option("command-plugin", Required = true, HelpText = "The name of a command plugin file, e.g. InEngine.Core")]
-        public string CommandPlugin { get; set; }
+        [Option("plugin", Required = true, HelpText = "The name of a command plugin file, e.g. InEngine.Core")]
+        public string PluginName { get; set; }
 
-        [Option("command-verb", HelpText =  "A plugin command verb, e.g. echo.")]
+        [Option("command", HelpText =  "A command name, e.g. echo.")]
         public string CommandVerb { get; set; }
 
-        [Option("command-class", HelpText = "A command class name, e.g. InEngine.Core.Commands.AlwaysSucceed. Takes precedence over --command-verb if both are specified.")]
+        [Option("class", HelpText = "A command class, e.g. InEngine.Core.Commands.AlwaysSucceed. Takes precedence over --command if both are specified.")]
         public string CommandClass { get; set; }
 
         [OptionArray("args", HelpText = "An optional list of arguments to publish with the command.")]
@@ -29,8 +29,8 @@ public override void Run()
         {
             var command = Command;
 
-            if (command == null && !string.IsNullOrWhiteSpace(CommandPlugin)) {
-                var plugin = PluginAssembly.LoadFrom($"{CommandPlugin}.dll");
+            if (command == null && !string.IsNullOrWhiteSpace(PluginName)) {
+                var plugin = PluginAssembly.LoadFrom(PluginName);
                 if (!string.IsNullOrWhiteSpace(CommandClass))
                     command = plugin.CreateCommandFromClass(CommandClass);
                 else if (!string.IsNullOrWhiteSpace(CommandVerb)) {

src/InEngine.Core/Queuing/QueueAdapter.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 using InEngine.Core.Exceptions;
 using InEngine.Core.Queuing.Clients;
 using InEngine.Core.Queuing.Message;

src/InEngine/appsettings.json

@@ -1,8 +1,7 @@
 {
   "InEngine": {
-    "Plugins": [
-      "InEngine.Commands"
-    ],
+    "Plugins": {
+    },
     "ExecWhitelist": {
     },
     "Mail": {
@@ -14,7 +13,7 @@
       "UseCompression": false,
       "PrimaryQueueConsumers": 16,
       "SecondaryQueueConsumers": 4,
-      "QueueDriver": "redis",
+      "QueueDriver": "file",
       "QueueName": "InEngineQueue",
       "RedisHost": "localhost",
       "RedisPort": 6379,