Context Navigation

← Previous Changeset
Next Changeset →

Changeset 2291

Timestamp:

1/4/2011 5:38:18 AM (2 years ago)

Author:

lowjoel

Message:

Split the LoadingPolicy? attribute, PluginInstance? class and IPlugin interface from Host.cs

Location:

branches/eraser6/pluginsRewrite

Files:

: 4 added
: 1 edited
: 1 moved

Eraser.Manager/ManagerLibrary.cs (modified) (1 diff)
Eraser.Plugins/AssemblyInfo.cs (added)
Eraser.Plugins/Host.cs (moved) (moved from branches/eraser6/pluginsRewrite/Eraser.Plugins/Plugins.cs) (4 diffs)
Eraser.Plugins/IPlugin.cs (added)
Eraser.Plugins/LoadingPolicy.cs (added)
Eraser.Plugins/PluginInstance.cs (added)

Legend:

: Unmodified
: Added
: Removed

branches/eraser6/pluginsRewrite/Eraser.Manager/ManagerLibrary.cs

r2288	r2291
50	50	ErasureTargetRegistrar = new ErasureTargetRegistrar();
51	51	FileSystemRegistrar = new FileSystemRegistrar();
	52	Host.Initialise();
	53	Host.Instance.Load();
52	54	}
53	55

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

-                      r2288
+                      r2291
         /// <summary>
+        /// Initialises the Plugins library. Call <see cref="Host.Load"/> when object
+        /// initialisation is complete.
+        /// </summary>
+        /// <remarks>Call <see cref="Host.Instance.Dispose"/> when exiting.</remarks>
+        public static void Initialise()
+        {
+            new DefaultHost();
+        }
+        /// <summary>
         /// Constructor. Sets the global Plugin Host instance.
         /// </summary>
 …
+    {
         /// <summary>
         /// Constructor. Loads all plugins in the Plugins folder.
+        /// Constructor.
         /// </summary>
         public DefaultHost() : base()
+        {
-            Load();
+        }
-        public override void Load()
+        {
             //Specify additional places to load assemblies from
             AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
             AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += ResolveReflectionDependency;
+        }
+        public override void Load()
+        {
             //Load all core plugins first
             foreach (KeyValuePair<string, string> plugin in CorePlugins)
 …
+        }
+        public override IList<PluginInstance> Plugins
+        {
+            get { return plugins.AsReadOnly(); }
+        }
+        /// <summary>
+        /// Verifies whether the provided assembly is a plugin.
+        /// </summary>
+        /// <param name="assembly">The assembly to verify.</param>
+        /// <returns>True if the assembly provided is a plugin, false otherwise.</returns>
+        private bool IsPlugin(Assembly assembly)
+        {
+            //Iterate over every exported type, checking if it implements IPlugin
+            Type typePlugin = assembly.GetExportedTypes().FirstOrDefault(
+                    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.
+            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);
+            //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."));
+            //OK this assembly is a plugin
+            lock (plugins)
+                plugins.Add(instance);
+            //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(
+                    Assembly.GetExecutingAssembly().GetName().GetPublicKey()))
+            {
+                throw new FileLoadException(S._("The provided Core plugin does not have an " +
+                    "identical public key as the Eraser assembly.\n\nCheck that the Eraser " +
+                    "installation is not corrupt, or reinstall the program."));
+            }
+            //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);
+            }
+        }
+        private Assembly AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            //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 (assembly.GetName().FullName == args.Name)
+                            return Assembly.LoadFile(file.FullName);
+                    }
+                    catch (BadImageFormatException)
+                    {
+                    }
+                    catch (FileLoadException)
+                    {
+                    }
+            }
+            return null;
+        }
+        private Assembly ResolveReflectionDependency(object sender, ResolveEventArgs args)
+        {
+            return Assembly.ReflectionOnlyLoad(args.Name);
+        }
         /// <summary>
         /// The path to the folder containing the plugins.
 …
             };
+        public override IList<PluginInstance> Plugins
+        {
+            get { return plugins.AsReadOnly(); }
+        }
+        /// <summary>
+        /// Verifies whether the provided assembly is a plugin.
+        /// </summary>
+        /// <param name="assembly">The assembly to verify.</param>
+        /// <returns>True if the assembly provided is a plugin, false otherwise.</returns>
+        private bool IsPlugin(Assembly assembly)
+        {
+            //Iterate over every exported type, checking if it implements IPlugin
+            Type typePlugin = assembly.GetExportedTypes().FirstOrDefault(
+                    type => type.GetInterface("Eraser.Manager.Plugin.IPlugin", true) != null);
+            //If the typePlugin type is empty the assembly doesn't implement IPlugin it's 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);
+            //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."));
+            //OK this assembly is a plugin
+            lock (plugins)
+                plugins.Add(instance);
+            //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(
+                    Assembly.GetExecutingAssembly().GetName().GetPublicKey()))
+            {
+                throw new FileLoadException(S._("The provided Core plugin does not have an " +
+                    "identical public key as the Eraser assembly.\n\nCheck that the Eraser " +
+                    "installation is not corrupt, or reinstall the program."));
+            }
+            //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);
+            }
+        }
+        private Assembly AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            //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 (assembly.GetName().FullName == args.Name)
+                            return Assembly.LoadFile(file.FullName);
+                    }
+                    catch (BadImageFormatException)
+                    {
+                    }
+                    catch (FileLoadException)
+                    {
+                    }
+            }
+            return null;
+        }
+        private Assembly ResolveReflectionDependency(object sender, ResolveEventArgs args)
+        {
+            return Assembly.ReflectionOnlyLoad(args.Name);
+        }
+        /// <summary>
+        /// Stores the list of plugins found within the Plugins folder.
+        /// </summary>
         private List<PluginInstance> plugins = new List<PluginInstance>();
+    }
-    /// <summary>
-    /// Structure holding the instance values of the plugin like handle and path.
-    /// </summary>
-    public class PluginInstance
+    {
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="assembly">The assembly representing this plugin.</param>
-        /// <param name="path">The path to the ass</param>
-        /// <param name="plugin"></param>
-        internal PluginInstance(Assembly assembly, IPlugin plugin)
+        {
-            Assembly = assembly;
-            Plugin = plugin;
-            //Verify the certificate in the assembly.
-            if (Security.VerifyAuthenticode(assembly.Location))
+            {
-                X509Certificate2 cert = new X509Certificate2(
-                    X509Certificate.CreateFromSignedFile(assembly.Location));
-                AssemblyAuthenticode = cert;
+            }
+        }
-        /// <summary>
-        /// Gets the Assembly this plugin instance came from.
-        /// </summary>
-        public Assembly Assembly
+        {
-            get
+            {
-                return assembly;
+            }
-            internal set
+            {
-                assembly = value;
-                AssemblyInfo info = new AssemblyInfo();
-                info.Version = assembly.GetFileVersion();
-                IList<CustomAttributeData> attributes = CustomAttributeData.GetCustomAttributes(assembly);
-                foreach (CustomAttributeData attr in attributes)
-                    if (attr.Constructor.DeclaringType == typeof(GuidAttribute))
-                        info.Guid = new Guid((string)attr.ConstructorArguments[0].Value);
-                    else if (attr.Constructor.DeclaringType == typeof(AssemblyCompanyAttribute))
-                        info.Author = (string)attr.ConstructorArguments[0].Value;
-                    else if (attr.Constructor.DeclaringType == typeof(LoadingPolicyAttribute))
+                    {
-                        LoadingPolicy = (LoadingPolicy)attr.ConstructorArguments[0].Value;
-                        if (LoadingPolicy == LoadingPolicy.Core)
-                            LoadingPolicy = LoadingPolicy.None;
+                    }
-                this.AssemblyInfo = info;
+            }
+        }
-        /// <summary>
-        /// Gets the attributes of the assembly, loading from reflection-only sources.
-        /// </summary>
-        public AssemblyInfo AssemblyInfo { get; private set; }
-        /// <summary>
-        /// The Authenticode signature used for signing the assembly.
-        /// </summary>
-        public X509Certificate2 AssemblyAuthenticode { get; private set; }
-        /// <summary>
-        /// Gets whether the plugin is required for the functioning of Eraser (and
-        /// therefore cannot be disabled.)
-        /// </summary>
-        public LoadingPolicy LoadingPolicy { get; internal set; }
-        /// <summary>
-        /// Gets the IPlugin interface which the plugin exposed. This may be null
-        /// if the plugin was not loaded.
-        /// </summary>
-        public IPlugin Plugin { get; internal set; }
-        /// <summary>
-        /// Gets whether this particular plugin is currently loaded in memory.
-        /// </summary>
-        public bool Loaded
+        {
-            get { return Plugin != null; }
+        }
-        private Assembly assembly;
+    }
-    /// <summary>
-    /// Reflection-only information retrieved from the assembly.
-    /// </summary>
-    public struct AssemblyInfo
+    {
-        /// <summary>
-        /// The GUID of the assembly.
-        /// </summary>
-        public Guid Guid { get; set; }
-        /// <summary>
-        /// The publisher of the assembly.
-        /// </summary>
-        public string Author { get; set; }
-        /// <summary>
-        /// The version of the assembly.
-        /// </summary>
-        public Version Version { get; set; }
-        public override bool Equals(object obj)
+        {
-            if (!(obj is AssemblyInfo))
-                return false;
-            return Equals((AssemblyInfo)obj);
+        }
-        public bool Equals(AssemblyInfo other)
+        {
-            return Guid == other.Guid;
+        }
-        public static bool operator ==(AssemblyInfo assembly1, AssemblyInfo assembly2)
+        {
-            return assembly1.Equals(assembly2);
+        }
-        public static bool operator !=(AssemblyInfo assembly1, AssemblyInfo assembly2)
+        {
-            return !assembly1.Equals(assembly2);
+        }
-        public override int GetHashCode()
+        {
-            return Guid.GetHashCode();
+        }
+    }
-    /// <summary>
-    /// Basic plugin interface which allows for the main program to utilize the
-    /// functions in the DLL
-    /// </summary>
-    public interface IPlugin : IDisposable
+    {
-        /// <summary>
-        /// Initializer.
-        /// </summary>
-        /// <param name="host">The host object which can be used for two-way
-        /// communication with the program.</param>
-        void Initialize(Host host);
-        /// <summary>
-        /// The name of the plug-in, used for descriptive purposes in the UI
-        /// </summary>
-        string Name
+        {
-            get;
+        }
-        /// <summary>
-        /// The author of the plug-in, used for display in the UI and for users
-        /// to contact the author about bugs. Must be in the format:
-        ///     (.+) \&lt;([a-zA-Z0-9_.]+)@([a-zA-Z0-9_.]+)\.([a-zA-Z0-9]+)\&gt;
-        /// </summary>
-        /// <example>Joel Low <joel@joelsplace.sg></example>
-        string Author
+        {
-            get;
+        }
-        /// <summary>
-        /// Determines whether the plug-in is configurable.
-        /// </summary>
-        bool Configurable
+        {
-            get;
+        }
-        /// <summary>
-        /// Fulfil a request to display the settings for this plug-in.
-        /// </summary>
-        /// <param name="parent">The parent control which the settings dialog should
-        /// be parented with.</param>
-        void DisplaySettings(System.Windows.Forms.Control parent);
+    }
-    /// <summary>
-    /// Loading policies applicable for a given plugin.
-    /// </summary>
-    public enum LoadingPolicy
+    {
-        /// <summary>
-        /// The host decides the best policy for loading the plugin.
-        /// </summary>
-        None,
-        /// <summary>
-        /// The host will enable the plugin by default.
-        /// </summary>
-        DefaultOn,
-        /// <summary>
-        /// The host will disable the plugin by default
-        /// </summary>
-        DefaultOff,
-        /// <summary>
-        /// The host must always load the plugin.
-        /// </summary>
-        /// <remarks>This policy does not have an effect when declared in the
-        /// <see cref="LoadingPolicyAttribute"/> attribute and will be equivalent
-        /// to <see cref="None"/>.</remarks>
-        Core
+    }
-    /// <summary>
-    /// Declares the loading policy for the assembly containing the plugin. Only
-    /// plugins signed with an Authenticode signature will be trusted and have
-    /// this attribute checked at initialisation.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = false)]
-    public sealed class LoadingPolicyAttribute : Attribute
+    {
-        /// <summary>
-        /// Constructor.
-        /// </summary>
-        /// <param name="policy">The policy used for loading the plugin.</param>
-        public LoadingPolicyAttribute(LoadingPolicy policy)
+        {
-            Policy = policy;
+        }
-        /// <summary>
-        /// The loading policy to be applied to the assembly.
-        /// </summary>
-        public LoadingPolicy Policy
+        {
-            get;
-            set;
+        }
+    }
+}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 2291

Legend:

branches/eraser6/pluginsRewrite/Eraser.Manager/ManagerLibrary.cs

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

Download in other formats: