Changeset 1981 for trunk/eraser

Timestamp:

4/28/2010 8:26:57 AM (3 years ago)

Author:

lowjoel

Message:

Allow different types of loading policies for plugins. The old CoreAttribute? has been superseded by the LoadingPolicyAttribute?. This allows us to specify the loading policy for plugins such as BlackBox? which will have the same strong name as the main program, an Authenticode signature, but should not be loaded by default.

Location:

trunk/eraser

Files:

• Eraser.BlackBox/Eraser.BlackBox.csproj (modified) (1 diff)
• Eraser.BlackBox/Plugin.cs (modified) (1 diff)
• Eraser.BlackBox/Properties/AssemblyInfo.cs (modified) (1 diff)
• Eraser.DefaultPlugins/Properties/AssemblyInfo.cs (modified) (1 diff)
• Eraser.Manager/Plugins.cs (modified) (5 diffs)
• Eraser.Util/Eraser.Util.csproj (modified) (1 diff)
• Eraser/SettingsPanel.cs (modified) (2 diffs)

trunk/eraser/Eraser.BlackBox/Eraser.BlackBox.csproj

@@ -116 +116 @@
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <None Include="Strong Name.snk" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

trunk/eraser/Eraser.BlackBox/Plugin.cs

@@ -47 +47 @@
         public string Name
         {
-            get { throw new NotImplementedException(); }
+            get { return "Eraser BlackBox"; }
         }
 
         public string Author
         {
-            get { throw new NotImplementedException(); }
+            get { return "The Eraser Project <eraser-development@lists.sourceforge.net>"; }
         }
 
         public bool Configurable
         {
-            get { throw new NotImplementedException(); }
+            get { return false; }
         }
 

trunk/eraser/Eraser.BlackBox/Properties/AssemblyInfo.cs

@@ -24 +24 @@
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("3460478d-ed1b-4ecc-96c9-2ca0e8500557")]
+
+// The plugin is an optional Eraser plugin, which should default to not load.
+[assembly: Eraser.Manager.Plugin.LoadingPolicy(Eraser.Manager.Plugin.LoadingPolicy.DefaultOff)]

trunk/eraser/Eraser.DefaultPlugins/Properties/AssemblyInfo.cs

@@ -26 +26 @@
 
 // The plugin is a Core Eraser plugin, declare it so.
-[assembly: Eraser.Manager.Plugin.Core]
+[assembly: Eraser.Manager.Plugin.LoadingPolicy(Eraser.Manager.Plugin.LoadingPolicy.Core)]

trunk/eraser/Eraser.Manager/Plugins.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Text;
+using System.Linq;
+
 using System.IO;
 using System.Reflection;
@@ -213 +215 @@
                 plugins.Add(instance);
 
-            //The plugin was not disabled or it was loaded for the first time. Check
-            //the plugin for the presence of a valid signature.
+            //If the plugin does not have an approval or denial, check for the presence of
+            //a valid signature.
             IDictionary<Guid, bool> approvals = ManagerLibrary.Settings.PluginApprovals;
-            if ((reflectAssembly.GetName().GetPublicKey().Length == 0 ||
+            if (!approvals.ContainsKey(instance.AssemblyInfo.Guid) &&
+                (reflectAssembly.GetName().GetPublicKey().Length == 0 ||
                 !Security.VerifyStrongName(filePath) ||
-                instance.AssemblyAuthenticode == null) &&
-                !approvals.ContainsKey(instance.AssemblyInfo.Guid))
+                instance.AssemblyAuthenticode == null))
             {
                 return;
             }
 
-            //Load the plugin
+            //The plugin either is explicitly allowed or disallowed to load, or
+            //it has an Authenticode Signature as well as a Strong Name. Get the
+            //loading policy of the plugin.
             instance.Assembly = Assembly.LoadFrom(filePath);
-
-            //See if the plugin belongs to us (same signature) and if the assembly
-            //declares an IsCore attribute.
-            if (reflectAssembly.GetName().GetPublicKey().Length ==
-                Assembly.GetExecutingAssembly().GetName().GetPublicKey().Length)
-            {
-                bool sameKey = true;
-                byte[] reflectAssemblyKey = reflectAssembly.GetName().GetPublicKey();
-                byte[] thisAssemblyKey = Assembly.GetExecutingAssembly().GetName().GetPublicKey();
-                for (int i = 0, j = reflectAssemblyKey.Length; i != j; ++i)
-                    if (reflectAssemblyKey[i] != thisAssemblyKey[i])
+            LoadingPolicy policy = LoadingPolicy.None;
+            {
+                object[] attr = instance.Assembly.GetCustomAttributes(typeof(LoadingPolicyAttribute), true);
+                if (attr.Length != 0)
+                {
+                    policy = ((LoadingPolicyAttribute)attr[0]).Policy;
+
+                    //If the loading policy is that the plugin is Core, we need to verify
+                    //the public key of the assembly.
+                    if (policy == LoadingPolicy.Core &&
+                        !reflectAssembly.GetName().GetPublicKey().SequenceEqual(
+                            Assembly.GetExecutingAssembly().GetName().GetPublicKey()))
                     {
-                        sameKey = false;
-                        break;
+                        policy = LoadingPolicy.None;
                     }
-
-                //Check for the IsCore attribute.
-                if (sameKey)
+                }
+            }
+
+            bool loadPlugin = false;
+
+            //If the loading policy is such that the plugin is a core plugin, ALWAYS load it.
+            if (policy == LoadingPolicy.Core)
+                loadPlugin = true;
+
+            //The plugin is not a core plugin, is there an approval or denial?
+            else if (approvals.ContainsKey(instance.AssemblyInfo.Guid))
+                loadPlugin = approvals[instance.AssemblyInfo.Guid];
+
+            //There's no approval or denial, what is the specified loading policy?
+            else
+                loadPlugin = policy != LoadingPolicy.DefaultOff;
+
+
+            if (loadPlugin)
+            {
+                try
                 {
-                    object[] attr = instance.Assembly.GetCustomAttributes(typeof(CoreAttribute), true);
-                    if (attr.Length != 0)
-                        instance.IsCore = true;
+                    //Initialize the plugin
+                    IPlugin pluginInterface = (IPlugin)Activator.CreateInstance(
+                        instance.Assembly.GetType(typePlugin.ToString()));
+                    pluginInterface.Initialize(this);
+                    instance.Plugin = pluginInterface;
+
+                    //And broadcast the plugin load event
+                    OnPluginLoaded(this, new PluginLoadedEventArgs(instance));
                 }
-            }
-
-            //See if the user disabled this plugin (users cannot disable Core plugins)
-            if (approvals.ContainsKey(instance.AssemblyInfo.Guid) &&
-                !approvals[instance.AssemblyInfo.Guid] && !instance.IsCore)
-            {
-                return;
-            }
-
-            try
-            {
-                //Initialize the plugin
-                IPlugin pluginInterface = (IPlugin)Activator.CreateInstance(
-                    instance.Assembly.GetType(typePlugin.ToString()));
-                pluginInterface.Initialize(this);
-                instance.Plugin = pluginInterface;
-
-                //And broadcast the plugin load event
-                OnPluginLoaded(this, new PluginLoadedEventArgs(instance));
-            }
-            catch (System.Security.SecurityException e)
-            {
-                MessageBox.Show(S._("Could not load the plugin {0}.\n\nThe error returned was: {1}",
-                    filePath, e.Message), S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error,
-                    MessageBoxDefaultButton.Button1, Localisation.IsRightToLeft(null) ?
-                        MessageBoxOptions.RtlReading | MessageBoxOptions.RightAlign : 0);
+                catch (System.Security.SecurityException e)
+                {
+                    MessageBox.Show(S._("Could not load the plugin {0}.\n\nThe error returned was: {1}",
+                        filePath, e.Message), S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error,
+                        MessageBoxDefaultButton.Button1, Localisation.IsRightToLeft(null) ?
+                            MessageBoxOptions.RtlReading | MessageBoxOptions.RightAlign : 0);
+                }
             }
         }
@@ -310 +318 @@
             Assembly = assembly;
             Plugin = plugin;
-            IsCore = false;
 
             //Verify the certificate in the assembly.
@@ -361 +368 @@
         /// therefore cannot be disabled.)
         /// </summary>
-        public bool IsCore { get; internal set; }
+        public LoadingPolicy LoadingPolicy { get; internal set; }
 
         /// <summary>
@@ -477 +484 @@
 
     /// <summary>
-    /// Declares that the entity referenced is a core plugin and cannot be unloaded.
-    /// Only plugins signed with the same signature as the Manager library will be
-    /// considered to be safe and therefore checked for this attribute.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
-    public sealed class CoreAttribute : Attribute
-    {
+    /// 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>For this policy to have an effect, the plugin assembly must
+        /// have the same Strong Name as the loading assembly, otherwise it defaults
+        /// to 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;
+        }
     }
 }

trunk/eraser/Eraser.Util/Eraser.Util.csproj

@@ -63 +63 @@
     </Reference>
     <Reference Include="System.Data" />
+    <Reference Include="System.Data.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
     <Reference Include="System.Drawing" />
     <Reference Include="System.Management" />

trunk/eraser/Eraser/SettingsPanel.cs

@@ -77 +77 @@
             //Visually display the other metadata associated with the assembly
             item.ImageIndex = e.Instance.AssemblyAuthenticode == null ? -1 : 0;
-            item.Group = e.Instance.IsCore ? pluginsManager.Groups[0] :
-                pluginsManager.Groups[1];
+            item.Group = e.Instance.LoadingPolicy == LoadingPolicy.Core ?
+                pluginsManager.Groups[0] : pluginsManager.Groups[1];
             item.SubItems.Add(e.Instance.Assembly.GetName().Version.ToString());
             item.SubItems.Add(e.Instance.Assembly.Location);
@@ -308 +308 @@
             ListViewItem item = pluginsManager.Items[e.Index];
             PluginInstance instance = (PluginInstance)item.Tag;
-            if (instance.IsCore)
+            if (instance.LoadingPolicy == LoadingPolicy.Core)
                 e.NewValue = CheckState.Checked;
         }