Handles the loading, unloading, and general management of plugins. More...

Package Functions
void	LoadPlugin (FileInfo pluginFile)
	Loads one or plugins from an Assembly on disk.

bool	IsAssembly (FileInfo pluginFile)
	Gets a value indicating whether or not a give file is a valid assembly or not.

bool	ContainsPlugins (Assembly assembly, out List< Type > pluginTypes)
	Gets a value indicating whether or not a given assembly contains members inheriting from IPlugin.

void	RegisterPlugin (ref Assembly assembly, Type type)
	Internally registers an IPlugin class and calls the IPlugin.OnLoad(Serilog.ILogger) method once loaded.

void	DeregisterPlugin (Assembly assembly, Type type)

List< ICommand >	GetAllCommands ()
	Gets a list containing all ICommand instances known to the application at the current time.

void	AddSubscription (IPlugin plugin, string topic)
	Adds a plugin to a topic subscription list.

void	RemoveSubscription (IPlugin plugin, string topic)
	Removes a plugin from a topic subscription list.

Properties
ILogger?	AppLogger = null `[get, set]`

static PluginRegistry	Instance `[get]`
	Gets the current instance of this object.

List< IPlugin >	Plugins `[get]`
	Gets a list of all loaded IPlugin instances.

Dictionary< Assembly, Dictionary< Type, IPlugin > >	LoadedAssemblies = new Dictionary<Assembly, Dictionary<Type, IPlugin>>() `[get]`
	A Dictionary<Assembly, List<IPlugin>> containing all loaded assemblies and plugins contained within.

List< PluginDelegator >	PluginDelegators = new List<PluginDelegator>() `[get]`

List< ICommand >?	BuiltInCommands = null `[get, set]`

IPlugin?	LastRegisteredPlugin = null `[get, set]`
	Gets or sets the last IPlugin to be registered.

Dictionary< string, List< IPlugin > >	TopicSubscriptions = new Dictionary<string, List<IPlugin>>() `[get]`
	The topic subscription list.

Private Member Functions
	PluginRegistry ()

void	ConfigManager_ConfigLoaded (object? sender, ConfigLoadedEventArgs e)

void	ConfigManager_ConfigChanged (object? sender, ConfigChangedEventArgs e)

Assembly?	CurrentDomain_AssemblyResolve (object? sender, ResolveEventArgs args)

Static Private Attributes
static ? PluginRegistry	_instance

Detailed Description

Handles the loading, unloading, and general management of plugins.

This class knows which plugins are loaded at any given time, can all any commands provided by the plugin and also fire events.

Definition at line 21 of file PluginRegistry.cs.

Constructor & Destructor Documentation

◆ PluginRegistry()

Hermod.PluginFramework.PluginRegistry.PluginRegistry ( )

inlineprivate

Definition at line 26 of file PluginRegistry.cs.

                                 {
            ConfigManager.Instance.ConfigChanged += ConfigManager_ConfigChanged;
            ConfigManager.Instance.ConfigLoaded += ConfigManager_ConfigLoaded;
            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
        }

References Hermod.PluginFramework.PluginRegistry.ConfigManager_ConfigChanged(), Hermod.PluginFramework.PluginRegistry.ConfigManager_ConfigLoaded(), and Hermod.PluginFramework.PluginRegistry.CurrentDomain_AssemblyResolve().

Member Function Documentation

◆ AddSubscription()

void Hermod.PluginFramework.PluginRegistry.AddSubscription	(	IPlugin	plugin,
		string	topic
	)

inlinepackage

Adds a plugin to a topic subscription list.

Parameters

plugin	The plugin to add.
topic	The topic to subscribe to.

Exceptions

MalformedTopicException

Definition at line 23 of file PluginRegistry.Delegation.cs.

                                                                    {
            if (!TopicIsValid(ref topic)) {
                throw new MalformedTopicException(topic, "The topic is invalid!");
            }
 
            if (!TopicSubscriptions.ContainsKey(topic)) {
                TopicSubscriptions.Add(topic, new List<IPlugin>());
            }
 
            var subList = TopicSubscriptions[topic];
            if (subList.Contains(plugin)) { return; }
 
            subList.Add(plugin);
        }

References Hermod.PluginFramework.PluginRegistry.TopicSubscriptions.

Referenced by Hermod.PluginFramework.PluginDelegator.SubscribeTopics().

◆ ConfigManager_ConfigChanged()

void Hermod.PluginFramework.PluginRegistry.ConfigManager_ConfigChanged	(	object?	sender,
		ConfigChangedEventArgs	e
	)

inlineprivate

Definition at line 193 of file PluginRegistry.cs.

                                                                                           {
            foreach (var plugin in Plugins) {
                plugin.OnConfigChanged(e);
            }
        }

References Hermod.PluginFramework.PluginRegistry.Plugins.

Referenced by Hermod.PluginFramework.PluginRegistry.PluginRegistry().

◆ ConfigManager_ConfigLoaded()

void Hermod.PluginFramework.PluginRegistry.ConfigManager_ConfigLoaded	(	object?	sender,
		ConfigLoadedEventArgs	e
	)

inlineprivate

Definition at line 187 of file PluginRegistry.cs.

                                                                                         {
            foreach (var plugin in Plugins) {
                plugin.OnConfigLoaded();
            }
        }

References Hermod.PluginFramework.PluginRegistry.Plugins.

Referenced by Hermod.PluginFramework.PluginRegistry.PluginRegistry().

◆ ContainsPlugins()

bool Hermod.PluginFramework.PluginRegistry.ContainsPlugins	(	Assembly	assembly,
		out List< Type >	pluginTypes
	)

inlinepackage

Gets a value indicating whether or not a given assembly contains members inheriting from IPlugin.

Parameters

assembly	The Assembly to check in.
pluginTypes	Out var; the list of Types inheriting from IPlugin contained within the assembly.

Returns

Definition at line 116 of file PluginRegistry.cs.

                                                                                     {
            pluginTypes = new List<Type>();
 
            foreach (var type in assembly.GetTypes()) {
                var isSubclass = type.IsSubclassOf(typeof(IPlugin)) || type.IsSubclassOf(typeof(Plugin));
                var attribute = type.GetCustomAttribute<PluginAttribute>();
 
                if (isSubclass && attribute is not null) {
                    pluginTypes.Add(type);
                }
            }
 
            return pluginTypes.Count > 0;
        }

Referenced by Hermod.PluginFramework.PluginRegistry.LoadPlugin().

◆ CurrentDomain_AssemblyResolve()

Assembly? Hermod.PluginFramework.PluginRegistry.CurrentDomain_AssemblyResolve	(	object?	sender,
		ResolveEventArgs	args
	)

inlineprivate

Definition at line 199 of file PluginRegistry.cs.

                                                                                               {
            AppLogger?.Warning("Failed to resolve assembly {argname}", args.Name);
            var loadedAssembly = AppDomain.CurrentDomain.GetAssemblies()?.Where(x => x.FullName == args.RequestingAssembly?.FullName)?.FirstOrDefault();
            if (loadedAssembly is not null) {
                return loadedAssembly;
            }
 
            var folderPath = Path.GetDirectoryName(args.RequestingAssembly?.Location);
            var asmName = new AssemblyName(args.Name);
            if (folderPath is null || asmName.Name is null) {
                AppLogger?.Error("Could not find assembly in {location}", folderPath);
                return default;
            }
 
            var rawPath = Path.Combine(folderPath, asmName.Name);
            var asmPath = rawPath + ".dll";
 
            if (!File.Exists(asmPath)) {
                AppLogger?.Warning("Could not find {asmPath}! Is it an executable?", asmPath);
                asmPath = rawPath + ".exe";
                if (!File.Exists(asmPath)) {
                    AppLogger?.Warning("Could not find {asmPath}!", asmPath);
                    return default;
                }
            }
 
            return Assembly.LoadFrom(asmPath);
        }

References Hermod.PluginFramework.PluginRegistry.AppLogger.

Referenced by Hermod.PluginFramework.PluginRegistry.PluginRegistry().

◆ DeregisterPlugin()

void Hermod.PluginFramework.PluginRegistry.DeregisterPlugin	(	Assembly	assembly,
		Type	type
	)

inlinepackage

Definition at line 171 of file PluginRegistry.cs.

                                                                     {
            if (LoadedAssemblies is null || LoadedAssemblies?.Count == 0) { return; }
 
            var pluginAssembly = LoadedAssemblies?.FirstOrDefault(a => a.Key == assembly);
            if (pluginAssembly is null) { return; }
 
            pluginAssembly?.Value.Remove(type);
            try {
                PluginDelegators?.Remove(PluginDelegators.First(pd => pd.Plugin?.GetType() == type));
            } catch { /* if an exception occurs, no PluginDelegator instance was loaded. */ }
 
            if (pluginAssembly?.Value.Count == 0) {
                LoadedAssemblies?.Remove(assembly);
            }
        }

References Hermod.PluginFramework.PluginRegistry.LoadedAssemblies, and Hermod.PluginFramework.PluginRegistry.PluginDelegators.

Referenced by Hermod.PluginFramework.PluginRegistry.RegisterPlugin().

◆ GetAllCommands()

List< ICommand > Hermod.PluginFramework.PluginRegistry.GetAllCommands ( )

inlinepackage

Gets a list containing all ICommand instances known to the application at the current time.

Returns: A list of all known commands.

Definition at line 232 of file PluginRegistry.cs.

                                                 {
            var list = BuiltInCommands ?? new List<ICommand>();
 
            Plugins.ForEach(p => list.AddRange(p.PluginCommands));
 
            return list;
        }

References Hermod.PluginFramework.PluginRegistry.BuiltInCommands, and Hermod.PluginFramework.PluginRegistry.Plugins.

Referenced by Hermod.Hermod.GetAutocompletion(), and Hermod.Hermod.HandleDisplayCommandHelp().

◆ IsAssembly()

bool Hermod.PluginFramework.PluginRegistry.IsAssembly ( FileInfo pluginFile )

inlinepackage

Gets a value indicating whether or not a give file is a valid assembly or not.

Parameters

pluginFile The file to check for validity.

Returns: true

if the file contains a valid assembly.

Definition at line 98 of file PluginRegistry.cs.

                                                      {
            try {
                using (var fStream = pluginFile.OpenRead())
                using (var peReader = new PEReader(fStream)) {
                    if (!peReader.HasMetadata) { return false; }
 
                    var metaDataReader = peReader.GetMetadataReader();
                    return metaDataReader.IsAssembly;
                }
            } catch (Exception) { return false; }
        }

Referenced by Hermod.PluginFramework.PluginRegistry.LoadPlugin().

◆ LoadPlugin()

void Hermod.PluginFramework.PluginRegistry.LoadPlugin ( FileInfo pluginFile )

inlinepackage

Loads one or plugins from an Assembly on disk.

Parameters

pluginFile The file from which to load plugins.

Exceptions

FileNotFoundException	If the file does not exist.
NotAPluginException	If the given file is not a valid Assembly or does not contain instances off IPlugin or Plugin

Definition at line 74 of file PluginRegistry.cs.

                                                      {
            AppLogger?.Information($"Attempting to load { pluginFile.FullName }...");
            if (!pluginFile.Exists) { throw new FileNotFoundException("The file does not exist.", pluginFile.FullName); }
            if (!IsAssembly(pluginFile)) { throw new NotAPluginException(pluginFile); }
 
            AppLogger?.Information("Loading assembly...");
            var assembly = Assembly.LoadFile(pluginFile.FullName);
 
            List<Type> pluginTypes;
            if (!ContainsPlugins(assembly, out pluginTypes)) {
                throw new NotAPluginException(pluginFile);
            }
 
            AppLogger?.Information($"Found { pluginTypes.Count } plugins in assembly...");
            foreach (var pluginType in pluginTypes) {
                RegisterPlugin(ref assembly, pluginType);
            }
        }

References Hermod.PluginFramework.PluginRegistry.AppLogger, Hermod.PluginFramework.PluginRegistry.ContainsPlugins(), Hermod.PluginFramework.PluginRegistry.IsAssembly(), and Hermod.PluginFramework.PluginRegistry.RegisterPlugin().

Referenced by Hermod.Hermod.HandleLoadPlugin(), and Hermod.Hermod.StartUp().

◆ RegisterPlugin()

void Hermod.PluginFramework.PluginRegistry.RegisterPlugin	(	ref Assembly	assembly,
		Type	type
	)

inlinepackage

Internally registers an IPlugin class and calls the IPlugin.OnLoad(Serilog.ILogger) method once loaded.

Parameters

assembly	The Assembly in which the plugin resides.
type	The Type of the plugin.

Definition at line 136 of file PluginRegistry.cs.

                                                                       {
            if (!LoadedAssemblies.ContainsKey(assembly)) {
                AppLogger?.Debug($"Plugin assembly seems to be new; registering { assembly.GetName().FullName } for the first time!");
                LoadedAssemblies.Add(assembly, new Dictionary<Type, IPlugin>());
            } else if (LoadedAssemblies[assembly].ContainsKey(type)) {
                AppLogger?.Error($"The plugin { type.Name } has already been loaded as a plugin! Silently ignoring...");
                return;
            }
 
            try {
                var plugin = Activator.CreateInstance(type) as IPlugin;
                if (plugin is null) {
                    throw new PluginLoadException(type.Name);
                }
 
                LoadedAssemblies[assembly].Add(type, plugin);
                var pluginDelegator = new PluginDelegator(plugin);
                PluginDelegators.Add(pluginDelegator);
 
                plugin = LoadedAssemblies[assembly][type];
                plugin.OnLoad(pluginDelegator);
 
                LastRegisteredPlugin = plugin;
                AppLogger?.Information($"Loaded plugin { plugin.PluginName } { plugin.PluginVersion.ToString() }");
            } catch (Exception ex) {
                AppLogger?.Error("Failed to load plugin from assembly!");
                AppLogger?.Error($"Error: { ex.Message }");
 
                AppLogger?.Warning("Deregisterung plugin...");
                DeregisterPlugin(assembly, type);
 
                throw;
            }
        }

References Hermod.PluginFramework.PluginRegistry.AppLogger, Hermod.PluginFramework.PluginRegistry.DeregisterPlugin(), Hermod.PluginFramework.PluginRegistry.LastRegisteredPlugin, Hermod.PluginFramework.PluginRegistry.LoadedAssemblies, and Hermod.PluginFramework.PluginRegistry.PluginDelegators.

Referenced by Hermod.PluginFramework.PluginRegistry.LoadPlugin().

◆ RemoveSubscription()

void Hermod.PluginFramework.PluginRegistry.RemoveSubscription	(	IPlugin	plugin,
		string	topic
	)

inlinepackage

Removes a plugin from a topic subscription list.

Parameters

plugin	The plugin to remove from the list.
topic	The topic to unsubscribe the plugin from.

Exceptions

MalformedTopicException If the passed topic is invalid or malformed.

Definition at line 44 of file PluginRegistry.Delegation.cs.

                                                                       {
            if (!TopicIsValid(ref topic)) {
                throw new MalformedTopicException(topic, "The topic is invalid!");
            }
 
            if (!TopicSubscriptions.ContainsKey(topic)) { return; }
 
            var subList = TopicSubscriptions[topic];
            if (!subList.Contains(plugin)) { return; }
 
            subList.Remove(plugin);
        }

References Hermod.PluginFramework.PluginRegistry.TopicSubscriptions.

Member Data Documentation

◆ _instance

? PluginRegistry Hermod.PluginFramework.PluginRegistry._instance

staticprivate

Definition at line 32 of file PluginRegistry.cs.

Property Documentation

◆ AppLogger

ILogger? Hermod.PluginFramework.PluginRegistry.AppLogger = null

getset

Definition at line 23 of file PluginRegistry.cs.

23{ get; internal set; } = null;

Referenced by Hermod.PluginFramework.PluginRegistry.CurrentDomain_AssemblyResolve(), Hermod.PluginFramework.PluginRegistry.LoadPlugin(), and Hermod.PluginFramework.PluginRegistry.RegisterPlugin().

◆ BuiltInCommands

List<ICommand>? Hermod.PluginFramework.PluginRegistry.BuiltInCommands = null

getsetpackage

Definition at line 61 of file PluginRegistry.cs.

61{ get; set; } = null;

Referenced by Hermod.PluginFramework.PluginRegistry.GetAllCommands().

◆ Instance

PluginRegistry Hermod.PluginFramework.PluginRegistry.Instance

staticget

Gets the current instance of this object.

Definition at line 37 of file PluginRegistry.cs.

Referenced by Hermod.Hermod.GetAutocompletion(), Hermod.Hermod.HandleDisplayCommandHelp(), Hermod.Hermod.HandleDisplayHelp(), Hermod.Hermod.HandleLoadPlugin(), Hermod.Hermod.StartUp(), Hermod.PluginFramework.PluginDelegator.SubscribeTopics(), and Hermod.Hermod.TryGetCommand().

◆ LastRegisteredPlugin

IPlugin? Hermod.PluginFramework.PluginRegistry.LastRegisteredPlugin = null

getsetpackage

Gets or sets the last IPlugin to be registered.

Definition at line 66 of file PluginRegistry.cs.

66{ get; set; } = null;

Referenced by Hermod.Hermod.HandleLoadPlugin(), and Hermod.PluginFramework.PluginRegistry.RegisterPlugin().

◆ LoadedAssemblies

Dictionary<Assembly, Dictionary<Type, IPlugin> > Hermod.PluginFramework.PluginRegistry.LoadedAssemblies = new Dictionary<Assembly, Dictionary<Type, IPlugin>>()

getpackage

A Dictionary<Assembly, List<IPlugin>> containing all loaded assemblies and plugins contained within.

Definition at line 57 of file PluginRegistry.cs.

57{ get; } = new Dictionary<Assembly, Dictionary<Type, IPlugin>>();

Referenced by Hermod.PluginFramework.PluginRegistry.DeregisterPlugin(), and Hermod.PluginFramework.PluginRegistry.RegisterPlugin().

◆ PluginDelegators

List<PluginDelegator> Hermod.PluginFramework.PluginRegistry.PluginDelegators = new List<PluginDelegator>()

getpackage

Definition at line 59 of file PluginRegistry.cs.

59{ get; } = new List<PluginDelegator>();

Referenced by Hermod.PluginFramework.PluginRegistry.DeregisterPlugin(), and Hermod.PluginFramework.PluginRegistry.RegisterPlugin().

◆ Plugins

List<IPlugin> Hermod.PluginFramework.PluginRegistry.Plugins

getpackage

Gets a list of all loaded IPlugin instances.

Definition at line 43 of file PluginRegistry.cs.

                                       {
            get {
                List<IPlugin> plugins = new List<IPlugin>();
                foreach (var pluginList in LoadedAssemblies.Select(x => x.Value.Select(y => y.Value))) {
                    plugins.AddRange(pluginList);
                }
 
                return plugins;
            }
        }

Referenced by Hermod.PluginFramework.PluginRegistry.ConfigManager_ConfigChanged(), Hermod.PluginFramework.PluginRegistry.ConfigManager_ConfigLoaded(), Hermod.PluginFramework.PluginRegistry.GetAllCommands(), Hermod.Hermod.HandleDisplayHelp(), and Hermod.Hermod.TryGetCommand().

◆ TopicSubscriptions

Dictionary<string, List<IPlugin> > Hermod.PluginFramework.PluginRegistry.TopicSubscriptions = new Dictionary<string, List<IPlugin>>()

getpackage

The topic subscription list.

Definition at line 15 of file PluginRegistry.Delegation.cs.

15{ get; } = new Dictionary<string, List<IPlugin>>();

Referenced by Hermod.PluginFramework.PluginRegistry.AddSubscription(), and Hermod.PluginFramework.PluginRegistry.RemoveSubscription().

The documentation for this class was generated from the following files:

Package Functions

Properties

Private Member Functions

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PluginRegistry()

Member Function Documentation

◆ AddSubscription()

◆ ConfigManager_ConfigChanged()

◆ ConfigManager_ConfigLoaded()

◆ ContainsPlugins()

◆ CurrentDomain_AssemblyResolve()

◆ DeregisterPlugin()

◆ GetAllCommands()

◆ IsAssembly()

◆ LoadPlugin()

◆ RegisterPlugin()

◆ RemoveSubscription()

Member Data Documentation

◆ _instance

Property Documentation

◆ AppLogger

◆ BuiltInCommands

◆ Instance

◆ LastRegisteredPlugin

◆ LoadedAssemblies

◆ PluginDelegators

◆ Plugins

◆ TopicSubscriptions