Beispiel #1
0
        protected async Task <bool> RegisterAndLoadPluginFromContainer(IDependencyContainer container)
        {
            IPlugin plugin = container.Resolve <IPlugin>();

            Logger.LogDebug($"[{GetType().Name}] Trying to load plugin: " + plugin.Name);

            PluginCommandProvider cmdProvider = new PluginCommandProvider(plugin);

            ParentContainer.RegisterSingletonInstance <ICommandProvider>(cmdProvider, plugin.Name);

            var    asm       = plugin.GetType().Assembly;
            string pluginDir = plugin.WorkingDirectory;

            //if (!Directory.Exists(pluginDir))
            //    Directory.CreateDirectory(pluginDir);

            foreach (string s in asm.GetManifestResourceNames())
            {
                using (Stream stream = asm.GetManifestResourceStream(s))
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        if (stream != null)
                        {
                            stream.CopyTo(ms);
                            byte[] data     = ms.ToArray();
                            string fileName = s.Replace(plugin.GetType().Namespace, "");
                            File.WriteAllBytes(Path.Combine(pluginDir, fileName), data);
                        }
                    }
                }
            }

            bool success = await plugin.ActivateAsync(false);

            if (!success)
            {
                return(false);
            }

            IEnumerable <Type> listeners = plugin.FindTypes <IAutoRegisteredEventListener>(false);

            foreach (Type listener in listeners)
            {
                IAutoRegisteredEventListener instance = (IAutoRegisteredEventListener)container.Activate(listener);
                EventBus.AddEventListener(plugin, instance);
            }

            return(true);
        }
Beispiel #2
0
        public virtual void Init()
        {
            Logger.LogDebug($"[{GetType().Name}] Initializing plugins.");

            assemblies = LoadAssemblies();

            IRuntime runtime = Container.Resolve <IRuntime>();

            PluginManagerInitEvent pluginManagerInitEvent =
                new PluginManagerInitEvent(this, EventExecutionTargetContext.Sync);

            EventManager.Emit(runtime, pluginManagerInitEvent);

            if (pluginManagerInitEvent.IsCancelled)
            {
                Logger.LogDebug($"[{GetType().Name}] Loading of plugins was canacelled.");
                return;
            }


            List <IDependencyContainer> pluginContainers = new List <IDependencyContainer>();

            foreach (Assembly assembly in assemblies)
            {
                try
                {
                    Logger.LogDebug($"[{GetType().Name}] Loading from assembly: " + assembly.GetName().Name);
                    LoadPluginFromAssembly(assembly, out IDependencyContainer container);

                    if (container != null)
                    {
                        pluginContainers.Add(container);
                        Logger.LogDebug($"[{GetType().Name}] Plugin found in: " + assembly.GetName().Name);
                    }
                    else
                    {
                        Logger.LogDebug($"[{GetType().Name}] No plugins found in: " + assembly.GetName().Name);
                    }
                }
                catch (Exception ex)
                {
                    Logger.LogError($"[{GetType().Name}] Failed to load from assembly: " + assembly.GetName().Name, ex);
                }
            }

            foreach (IDependencyContainer childContainer in pluginContainers)
            {
                IPlugin plugin = childContainer.Resolve <IPlugin>();
                Logger.LogDebug($"[{GetType().Name}] Trying to load plugin: " + plugin.Name);

                PluginCommandProvider cmdProvider = new PluginCommandProvider(plugin, childContainer);
                ParentContainer.RegisterSingletonInstance <ICommandProvider>(cmdProvider, plugin.Name);

                Assembly asm       = plugin.GetType().Assembly;
                string   pluginDir = plugin.WorkingDirectory;
                if (!Directory.Exists(pluginDir))
                {
                    Directory.CreateDirectory(pluginDir);
                }

                foreach (string s in asm.GetManifestResourceNames())
                {
                    using (Stream stream = asm.GetManifestResourceStream(s))
                    {
                        using (MemoryStream ms = new MemoryStream())
                        {
                            if (stream == null)
                            {
                                return;
                            }

                            stream.CopyTo(ms);
                            byte[] data     = ms.ToArray();
                            string fileName = s.Replace(plugin.GetType().Namespace, "");
                            File.WriteAllBytes(Path.Combine(pluginDir, fileName), data);
                        }
                    }
                }

                plugin.Load(false);

                IEnumerable <Type> listeners = plugin.FindTypes <IAutoRegisteredEventListener>(false);
                foreach (Type listener in listeners)
                {
                    IAutoRegisteredEventListener instance = (IAutoRegisteredEventListener)childContainer.Activate(listener);
                    EventManager.AddEventListener(plugin, instance);
                }
            }
        }