PluginRegistry.cs

Go to the documentation of this file.

using System;
 
namespace Hermod.PluginFramework {
 
    using Config;
    using Core.Attributes;
    using Core.Commands;
    using Core.Exceptions;
    using Serilog;
 
    using System.Reflection;
    using System.Reflection.Metadata;
    using System.Reflection.PortableExecutable;
 
    internal sealed partial class PluginRegistry {
 
        public ILogger? AppLogger { get; internal set; } = null;
 
        #region Singleton
        private PluginRegistry() {
            ConfigManager.Instance.ConfigChanged += ConfigManager_ConfigChanged;
            ConfigManager.Instance.ConfigLoaded += ConfigManager_ConfigLoaded;
            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
        }
 
        private static PluginRegistry? _instance;
 
        public static PluginRegistry Instance => _instance ??= new PluginRegistry();
        #endregion
 
        internal List<IPlugin> Plugins {
            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;
            }
        }
 
        internal Dictionary<Assembly, Dictionary<Type, IPlugin>> LoadedAssemblies { get; } = new Dictionary<Assembly, Dictionary<Type, IPlugin>>();
 
        internal List<PluginDelegator> PluginDelegators { get; } = new List<PluginDelegator>();
 
        internal List<ICommand>? BuiltInCommands { get; set; } = null;
 
        internal IPlugin? LastRegisteredPlugin { get; set; } = null;
 
        internal void LoadPlugin(FileInfo pluginFile) {
            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);
            }
        }
 
        internal bool IsAssembly(FileInfo pluginFile) {
            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; }
        }
 
        internal bool ContainsPlugins(Assembly assembly, out List<Type> pluginTypes) {
            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;
        }
 
        internal void RegisterPlugin(ref Assembly assembly, Type type) {
            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;
            }
        }
 
        internal void DeregisterPlugin(Assembly assembly, Type type) {
            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);
            }
        }
 
        private void ConfigManager_ConfigLoaded(object? sender, ConfigLoadedEventArgs e) {
            foreach (var plugin in Plugins) {
                plugin.OnConfigLoaded();
            }
        }
 
        private void ConfigManager_ConfigChanged(object? sender, ConfigChangedEventArgs e) {
            foreach (var plugin in Plugins) {
                plugin.OnConfigChanged(e);
            }
        }
 
        private Assembly? CurrentDomain_AssemblyResolve(object? sender, ResolveEventArgs args) {
            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);
        }
 
        internal List<ICommand> GetAllCommands() {
            var list = BuiltInCommands ?? new List<ICommand>();
 
            Plugins.ForEach(p => list.AddRange(p.PluginCommands));
 
            return list;
        }
 
    }
}