private void _createAssemblyIfNeeded()
{
if (_pluginAssembly == null)
{
_pluginAssembly = DistribIOC.Kernel.Get<IPluginAssemblyFactory>().CreatePluginAssemblyFromPath(_assemblyPath);
}
}
public IPluginInstance CreatePluginInstance(IPluginDescriptor descriptor, IPluginAssembly parentAssembly)
{
return _ioc.Get<IPluginInstance>(new[]
{
new IOCConstructorArgument("descriptor", descriptor),
new IOCConstructorArgument("pluginAssembly", parentAssembly),
});
}
/// <summary>
/// Finds and returns the PluginAssembly in the specified list of type PluginAssembly whose FQN matches the specified FQN.
/// </summary>
/// <param name="fqn">The FQN of the desired PluginAssembly.</param>
/// <returns>
/// The PluginAssembly instance whose FQN matches the specified FQN, or the default PluginAssembly if not found.
/// </returns>
public IPluginAssembly FindPluginAssembly(string fqn)
{
logger.EnterMethod(xLogger.Params(fqn, new xLogger.ExcludedParam()));
IPluginAssembly retVal = PluginAssemblies.Where(p => p.FQN == fqn).FirstOrDefault();
logger.ExitMethod(retVal);
return(retVal);
}
/// <summary>
/// Iterates over the specified List of type <see cref="PluginManagerConfigurationPluginInstance"/>, retrieves the
/// matching PluginAssembly from the supplied List of type PluginAssembly and instantiates each instance, passing the
/// instance name and an instance of xLogger with the Fully Qualified Name of the instance.
/// </summary>
/// <remarks>
/// The <see cref="InstantiatePlugin{T}(IApplicationManager, string, xLogger)"/> method is invoked via reflection so
/// that the type parameter for the method can be specified dynamically.
/// </remarks>
/// <returns>A Result containing the result of the operation and a Dictionary containing the instantiated Plugins.</returns>
private Result <List <IPluginInstance> > InstantiatePlugins()
{
logger.EnterMethod();
logger.Info("Creating Plugin Instances...");
Result <List <IPluginInstance> > retVal = new Result <List <IPluginInstance> >();
retVal.ReturnValue = new List <IPluginInstance>();
IApplicationManager applicationManager = Dependency <IApplicationManager>();
// iterate over the configured plugin instances from the configuration
foreach (PluginManagerConfigurationPluginInstance instance in Configuration.Instances)
{
logger.SubSubHeading(LogLevel.Debug, "Instance: " + instance.InstanceName);
logger.Info("Creating instance '" + instance.InstanceName + "' of Type '" + instance.AssemblyName + "'...");
// locate the PluginAssembly matching the instance
IPluginAssembly assembly = FindPluginAssembly(instance.AssemblyName);
if (assembly == default(PluginAssembly))
{
retVal.AddWarning("Plugin assembly '" + instance.AssemblyName + "' not found in the list of loaded assemblies.");
}
else
{
// create an instance of xLogger for the new instance
xLogger instanceLogger = (xLogger)LogManager.GetLogger(assembly.FQN + "." + instance.InstanceName, typeof(xLogger));
// invoke the CreatePluginInstance method
MethodInfo method = this.GetType().GetMethod("InstantiatePlugin").MakeGenericMethod(assembly.Type);
Result <IPluginInstance> invokeResult = (Result <IPluginInstance>)method.Invoke(this, new object[] { applicationManager, instance.InstanceName, instanceLogger });
// if the invocation succeeded, add the result to the Instances Dictionary
if (invokeResult.ResultCode == ResultCode.Success)
{
retVal.ReturnValue.Add(invokeResult.ReturnValue);
logger.Info("Instantiated " + assembly.PluginType.ToString() + " plugin '" + instance.InstanceName + "'.");
}
invokeResult.LogResult(logger, "InstantiatePlugin");
retVal.Incorporate(invokeResult);
}
}
retVal.LogResult(logger);
logger.ExitMethod(retVal);
return(retVal);
}
protected override void DoUninit()
{
try
{
lock (_lock)
{
if (_processInstance != null)
{
_processInstance.UninitProcess();
}
if (_pluginAssembly != null && _pluginAssembly.IsInitialised)
{
_pluginAssembly.Unitialise();
}
_pluginAssembly = null;
_pluginInstance = null;
_processInstance = null;
}
}
catch (Exception ex)
{
throw new ApplicationException("Failed to do uninit", ex);
}
}
protected override void DoInit()
{
try
{
lock (_lock)
{
Assembly.LoadFrom(_pluginDescriptor.AssemblyPath);
AppDomain.CurrentDomain.AssemblyResolve += (s, e) =>
{
return AppDomain.CurrentDomain.GetAssemblies()
.DefaultIfEmpty(null)
.SingleOrDefault(asm => asm.FullName == e.Name);
};
try
{
_pluginAssembly = _pluginAssemblyFactory.CreatePluginAssemblyFromPath(_pluginDescriptor.AssemblyPath);
var initRes = _pluginAssembly.Initialise();
if (!initRes.HasUsablePlugins)
{
throw new ApplicationException("The plugin assembly contains no usable plugins");
}
if (initRes.UsablePlugins.DefaultIfEmpty(null)
.SingleOrDefault(p => p.Match(_pluginDescriptor)) == null)
{
throw new ApplicationException("A matching plugin descriptor couldn't be found in the plugin assembly");
}
}
catch (Exception ex)
{
throw new ApplicationException("Failed to initialise plugin assembly and locate plugin", ex);
}
try
{
_pluginInstance = _pluginAssembly.CreatePluginInstance(_pluginDescriptor);
_pluginInstance.Initialise();
}
catch (Exception ex)
{
throw new ApplicationException("Failed to create and initialise the plugin instance", ex);
}
try
{
_processInstance = _pluginInstance.GetUnderlyingInstance<IProcess>();
_processInstance.InitProcess();
if (_processInstance.JobDefinitions == null || _processInstance.JobDefinitions.Count == 0)
{
throw new ApplicationException("Process doesn't have any job definitions");
}
}
catch (Exception ex)
{
throw new ApplicationException("Failed to create and initialise the process", ex);
}
}
}
catch (Exception ex)
{
throw new ApplicationException("Failed to perform init", ex);
}
}
static void Main(string[] args)
{
try
{
string[] pluginPaths = new string[]
{
@"D:\Work\Digger\src\FindReplace\bin\Debug\netcoreapp3.0\FindReplace.Plugin.dll",
@"D:\Work\Digger\src\Analysis\bin\Debug\netcoreapp3.0\Analysis.Plugin.dll"
};
var plugins = pluginPaths.SelectMany(pluginPath => { return(PluginLoader.CreateInstance(pluginPath)); }).ToList();
if (args.Length == 0)
{
Prompt(ConsoleColor.White, "Digger CLI by Asif Raja", ConsoleColor.DarkCyan, " (https://github.com/asifraja)", true);
Console.WriteLine();
Prompt("Usage:", true);
foreach (IPluginAssembly command in plugins)
{
Prompt(ConsoleColor.White, " digger");
Prompt($" {command.Verb}");
Prompt(ConsoleColor.DarkGreen, " [options]");
Prompt(ConsoleColor.DarkCyan, $" ## {command.Description}", true);
}
Prompt(ConsoleColor.White, " digger");
Prompt(ConsoleColor.DarkGreen, " [path-to-options-file] |");
Prompt(ConsoleColor.DarkGreen, " [options]");
Prompt(ConsoleColor.DarkCyan, " ## provide options in a file", true);
Console.WriteLine();
Prompt(ConsoleColor.DarkGreen, "options:", true);
Prompt(" --help");
Prompt(ConsoleColor.DarkCyan, " ## List all available options", true);
Prompt(" --version", true);
Console.WriteLine();
Prompt(ConsoleColor.DarkGreen, "path-to-options-file:", true);
Prompt(" [<path to file containg option flags>]");
}
else
{
var commandName = args[0].ToLower().Trim();
Prompt(ConsoleColor.White, $"Command : {commandName}");
Console.WriteLine();
IPluginAssembly command = plugins.FirstOrDefault(c => c.Verb == commandName);
if (command == null)
{
Console.WriteLine($"{commandName} is an unknown command.");
return;
}
var fi = command.Execute(args);
if (fi != null)
{
foreach (var f in fi.OrderBy(o => o.Order))
{
Prompt(ConsoleColor.Magenta, $"{f.Files.Count()} files in {f.Path}", true);
foreach (var str in f.SeekStrings)
{
Prompt(ConsoleColor.DarkMagenta, $" {str.Value} instances of {str.Key}", true);
foreach (var fl in f.Files.Where(f => f.FoundLines.Count() > 0 && f.FoundLines.Any(x => x.SeekString == str.Key)).OrderBy(f => f.Path))
{
Prompt(ConsoleColor.DarkGreen, $" {fl.Path}", true);
foreach (var l in fl.FoundLines.OrderBy(f => f.SeekedString).ThenBy(f => f.Filename).ThenBy(f => f.LineNo))
{
Prompt(ConsoleColor.Green, $" {l.LineNo} {l.Line.Trim()}", true);
}
}
}
Console.WriteLine();
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine();
Console.WriteLine();
Console.Write("Press any key to exist...");
Console.ReadKey();
}
public void Init()
{
if (_pluginAssembly == null)
{
_pluginAssembly = _pluginAssemblyFactory.CreatePluginAssemblyFromPath(_path);
}
_initResult = _pluginAssembly.Initialise();
}
