Changeset 2295 for branches/eraser6/pluginsRewrite

Timestamp:

1/4/2011 7:05:39 AM (2 years ago)

Author:

lowjoel

Message:

• Fixed the PluginInfo?.Load function to not load the assembly twice if it was loaded normally and not using the reflection-only context (this rule was relaxed in the newest Host implementation)
• Core plugins will still be loaded before the rest of the plugins, but they will be loaded only by assembly name and not by path
• Plugin initialisation is handled by the PluginInfo? class as initialisation modifies properties in the PluginInfo? class
• Non-core plugins call a callback function provided by the host owner to determine if they will be loaded by the host
• AssemblyResolve? will now support matching of one or more components found in the full name of an assembly name

Location:

branches/eraser6/pluginsRewrite/Eraser.Plugins

Files:

• Host.cs (modified) (9 diffs)
• PluginInfo.cs (modified) (2 diffs)

branches/eraser6/pluginsRewrite/Eraser.Plugins/Host.cs

@@ -90 +90 @@
         /// </summary>
         /// <remarks>The returned list is read-only</remarks>
-        public abstract IList<PluginInstance> Plugins
+        public abstract IList<PluginInfo> Plugins
         {
             get;
@@ -149 +149 @@
         {
             //Load all core plugins first
-            foreach (KeyValuePair<string, string> plugin in CorePlugins)
-            {
-                LoadCorePlugin(Path.Combine(PluginsFolder, plugin.Key), plugin.Value);
+            foreach (string name in CorePlugins)
+            {
+                if (!LoadPlugin(new AssemblyName(name)))
+                    throw new FileLoadException(S._("The required Core plugin {0} could not be " +
+                        "loaded. Repair the Eraser installation and try again."));
             }
 
@@ -181 +183 @@
                 //Unload all the plugins. This will cause all the plugins to execute
                 //the cleanup code.
-                foreach (PluginInstance plugin in plugins)
+                foreach (PluginInfo plugin in plugins)
                     if (plugin.Plugin != null)
                         plugin.Plugin.Dispose();
@@ -189 +191 @@
         }
 
-        public override IList<PluginInstance> Plugins
+        public override IList<PluginInfo> Plugins
         {
             get { return plugins.AsReadOnly(); }
@@ -205 +207 @@
                     type => type.GetInterface("Eraser.Plugins.IPlugin", true) != null);
 
-            //If the typePlugin type is empty the assembly doesn't implement IPlugin it's not
-            //a plugin.
+            //If the typePlugin type is empty, the assembly doesn't implement IPlugin and thus
+            //it is not a plugin.
             return typePlugin != null;
         }
 
-        /// <summary>
-        /// Loads the assembly at the specified path, and verifying its assembly name,
-        /// ensuring that the assembly contains a core plugin.
-        /// </summary>
-        /// <param name="filePath">The path to the assembly.</param>
-        /// <param name="assemblyName">The name of the assembly.</param>
-        private void LoadCorePlugin(string filePath, string assemblyName)
-        {
-            Assembly assembly = Assembly.ReflectionOnlyLoadFrom(filePath);
-            if (assembly.GetName().FullName.Substring(0, assemblyName.Length + 1) !=
-                assemblyName + ",")
-            {
-                throw new FileLoadException(S._("The Core plugin assembly is not one which" +
-                    "Eraser expects.\n\nCheck that the Eraser installation is not corrupt, or " +
-                    "reinstall the program."));
-            }
-
-            //Create the PluginInstance structure
-            PluginInstance instance = new PluginInstance(assembly, null);
+        public bool LoadPlugin(AssemblyName name)
+        {
+            //Check the plugins folder
+            foreach (string fileName in Directory.GetFiles(PluginsFolder))
+            {
+                FileInfo file = new FileInfo(fileName);
+                if (file.Extension.Equals(".dll"))
+                    try
+                    {
+                        Assembly assembly = Assembly.ReflectionOnlyLoadFrom(file.FullName);
+                        if (AssemblyMatchesName(assembly, name))
+                        {
+                            return LoadPlugin(assembly);
+                        }
+                    }
+                    catch (BadImageFormatException)
+                    {
+                    }
+                    catch (FileLoadException)
+                    {
+                    }
+            }
+
+            return false;
+        }
+
+        public override bool LoadPlugin(string filePath)
+        {
+            return LoadPlugin(Assembly.ReflectionOnlyLoadFrom(filePath));
+        }
+
+        /// <summary>
+        /// Checks the provided assembly for its name and attempts to load it using the
+        /// plugin loading rules.
+        /// </summary>
+        /// <param name="assembly">The plugin to load. This assembly can be loaded
+        /// in the reflection-only context for security.</param>
+        /// <returns>True if the assembly was a plugin and loaded without error.</returns>
+        private bool LoadPlugin(Assembly assembly)
+        {
+            PluginInfo instance = new PluginInfo(assembly, null);
+
+            //Check that the plugin hasn't yet been loaded.
+            if (Plugins.Count(
+                    plugin => plugin.Assembly.GetName().FullName ==
+                    assembly.GetName().FullName) > 0)
+            {
+                return true;
+            }
 
             //Ignore non-plugins
             if (!IsPlugin(instance.Assembly))
-                throw new FileLoadException(S._("The provided Core plugin assembly is not a " +
-                    "plugin.\n\nCheck that the Eraser installation is not corrupt, or reinstall " +
-                    "the program."));
+                return false;
 
             //OK this assembly is a plugin
@@ -240 +270 @@
                 plugins.Add(instance);
 
+            //Load the plugin, depending on type
+            bool result = instance.LoadingPolicy == LoadingPolicy.Core ?
+                LoadCorePlugin(instance) : LoadNonCorePlugin(instance);
+            if (result)
+            {
+                //And broadcast the plugin load event
+                OnPluginLoaded(this, new PluginLoadedEventArgs(instance));
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Verifies the assembly name and strong name of a plugin, ensuring that the assembly
+        /// contains a core plugin before loading and initialising it.
+        /// </summary>
+        /// <param name="info">The plugin to load.</param>
+        /// <returns>True if the plugin was loaded.</returns>
+        private bool LoadCorePlugin(PluginInfo info)
+        {
+            //Check that this plugin's name appears in our list of core plugins, otherwise this
+            //is a phony
+            if (CorePlugins.Count(x => x == info.Assembly.GetName().Name) == 0)
+                return LoadNonCorePlugin(info);
+
             //Check for the presence of a valid signature: Core plugins must have the same
             //public key as the current assembly
-            if (!assembly.GetName().GetPublicKey().SequenceEqual(
+            if (!info.Assembly.GetName().GetPublicKey().SequenceEqual(
                     Assembly.GetExecutingAssembly().GetName().GetPublicKey()))
             {
@@ -250 +305 @@
             }
 
-            //Okay, everything's fine, initialise the plugin
-            instance.Assembly = Assembly.Load(instance.Assembly.GetName());
-            instance.LoadingPolicy = LoadingPolicy.Core;
-            InitialisePlugin(instance);
-        }
-
-        public override bool LoadPlugin(string filePath)
-        {
-            //Create the PluginInstance structure
-            Assembly reflectAssembly = Assembly.ReflectionOnlyLoadFrom(filePath);
-            PluginInstance instance = new PluginInstance(reflectAssembly, null);
-
-            //Check that the plugin hasn't yet been loaded.
-            if (Plugins.Count(
-                    plugin => plugin.Assembly.GetName().FullName ==
-                    reflectAssembly.GetName().FullName) > 0)
-            {
-                return true;
-            }
-
-            //Ignore non-plugins
-            if (!IsPlugin(instance.Assembly))
-                return false;
-
-            //OK this assembly is a plugin
-            lock (plugins)
-                plugins.Add(instance);
-
-            PluginLoadEventArgs e = new PluginLoadEventArgs(instance);
-            PluginLoad(this, e);
-            if (PluginLoad == null || e.Load)
-            {
-                InitialisePlugin(instance);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Initialises the given plugin from the plugin's description.
-        /// </summary>
-        /// <param name="instance">The <see cref="PluginInstance"/> structure to fill.</param>
-        /// <exception cref="System.IO.FileLoadException" />
-        private void InitialisePlugin(PluginInstance instance)
-        {
-            try
-            {
-                //Iterate over every exported type, checking for the IPlugin implementation
-                Type typePlugin = instance.Assembly.GetExportedTypes().First(
-                    type => type.GetInterface("Eraser.Manager.Plugin.IPlugin", true) != null);
-                if (typePlugin == null)
-                    return;
-
-                //Initialize the plugin
-                instance.Plugin = (IPlugin)Activator.CreateInstance(
-                    instance.Assembly.GetType(typePlugin.ToString()));
-                instance.Plugin.Initialize(this);
-
-                //And broadcast the plugin load event
-                OnPluginLoaded(this, new PluginLoadedEventArgs(instance));
-            }
-            catch (System.Security.SecurityException e)
-            {
-                throw new FileLoadException(S._("Could not load the plugin."),
-                    instance.Assembly.Location, e);
-            }
+            //Load the plugin.
+            info.Load(this);
+            return true;
+        }
+
+        /// <summary>
+        /// Queries the Plugin Host's owner on whether to load the current plugin.
+        /// </summary>
+        /// <param name="info">The plugin to load.</param>
+        /// <returns>True if the plugin was loaded.</returns>
+        private bool LoadNonCorePlugin(PluginInfo info)
+        {
+            PluginLoadEventArgs e = new PluginLoadEventArgs(info);
+            if (PluginLoad != null)
+                PluginLoad(this, e);
+            
+            if (e.Load)
+                info.Load(this);
+
+            return e.Load;
+        }
+
+        private static bool AssemblyMatchesName(Assembly assembly, AssemblyName name)
+        {
+            AssemblyName assemblyName = assembly.GetName();
+            return (name.Name == assemblyName.Name &&
+                (name.Version == null || name.Version == assemblyName.Version) &&
+                (name.ProcessorArchitecture == ProcessorArchitecture.None || name.ProcessorArchitecture == assemblyName.ProcessorArchitecture) &&
+                (name.GetPublicKey() == null || name.GetPublicKey().SequenceEqual(assemblyName.GetPublicKey()))
+            );
         }
 
         private Assembly AssemblyResolve(object sender, ResolveEventArgs args)
         {
+            //Parse the assembly name
+            AssemblyName name = new AssemblyName(args.Name);
+
             //Check the plugins folder
             foreach (string fileName in Directory.GetFiles(PluginsFolder))
@@ -329 +350 @@
                     {
                         Assembly assembly = Assembly.ReflectionOnlyLoadFrom(file.FullName);
-                        if (assembly.GetName().FullName == args.Name)
+                        if (AssemblyMatchesName(assembly, name))
+                        {
                             return Assembly.LoadFile(file.FullName);
+                        }
                     }
                     catch (BadImageFormatException)
@@ -357 +380 @@
 
         /// <summary>
-        /// The list of plugins which are core, the key is the file name, the value
-        /// is the assembly name.
-        /// </summary>
-        private readonly KeyValuePair<string, string>[] CorePlugins =
-            new KeyValuePair<string, string>[]
-            {
-                new KeyValuePair<string, string>(
-                    "Eraser.DefaultPlugins.dll",
-                    "Eraser.DefaultPlugins"
-                )
-            };
+        /// The list of plugins which are core. This list contains the names of every
+        /// assembly which are expected to be core plugins.
+        /// </summary>
+        private readonly string[] CorePlugins = new string[] {
+            "Eraser.DefaultPlugins"
+        };
 
         /// <summary>
         /// Stores the list of plugins found within the Plugins folder.
         /// </summary>
-        private List<PluginInstance> plugins = new List<PluginInstance>();
+        private List<PluginInfo> plugins = new List<PluginInfo>();
     }
 }

branches/eraser6/pluginsRewrite/Eraser.Plugins/PluginInfo.cs

@@ -67 +67 @@
         internal void Load(Host host)
         {
-            Assembly = Assembly.Load(Assembly.GetName());
+            if (Assembly.ReflectionOnly)
+                Assembly = Assembly.Load(Assembly.GetName());
 
             try
@@ -73 +74 @@
                 //Iterate over every exported type, checking for the IPlugin implementation
                 Type typePlugin = Assembly.GetExportedTypes().First(
-                    type => type.GetInterface("Eraser.Manager.Plugin.IPlugin", true) != null);
-                if (typePlugin == null)
-                    throw new FileLoadException(S._("Could not load the plugin."),
-                        Assembly.Location);
+                    type => type.GetInterface("Eraser.Plugins.IPlugin", true) != null);
 
                 //Initialize the plugin
-                Plugin = (IPlugin)Activator.CreateInstance(Assembly.GetType(typePlugin.ToString()));
+                Plugin = (IPlugin)Activator.CreateInstance(typePlugin);
                 Plugin.Initialize(host);
+            }
+            catch (InvalidOperationException e)
+            {
+                throw new FileLoadException(S._("Could not load the plugin."),
+                    Assembly.Location, e);
             }
             catch (System.Security.SecurityException e)