Changeset 2527 for branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/Manager/PluginValidator.cs

Timestamp:

11/23/09 20:27:43 (15 years ago)

Author:

gkronber

Message:

Implemented changes as requested by swagner. #799

File:

• branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/Manager/PluginValidator.cs (modified) (7 diffs)

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/Manager/PluginValidator.cs

@@ -27 +27 @@
 using System.Diagnostics;
 using System.Linq;
+using System.Security;
 
 
@@ -86 +87 @@
       pluginDependencies.Clear();
 
-      IEnumerable<Assembly> reflectionOnlyAssemblies = ReflectionOnlyLoadDlls();
+      IEnumerable<Assembly> reflectionOnlyAssemblies = ReflectionOnlyLoadDlls(PluginDir);
       IEnumerable<PluginDescription> pluginDescriptions = GatherPluginDescriptions(reflectionOnlyAssemblies);
       CheckPluginFiles(pluginDescriptions);
+
+      CheckPluginAssemblies(pluginDescriptions);
 
       // a full list of plugin descriptions is available now we can build the dependency tree
@@ -137 +140 @@
     }
 
-    private IEnumerable<Assembly> ReflectionOnlyLoadDlls() {
+    private static IEnumerable<Assembly> ReflectionOnlyLoadDlls(string baseDir) {
       List<Assembly> assemblies = new List<Assembly>();
+      // recursively load .dll files in subdirectories
+      foreach (string dirName in Directory.GetDirectories(baseDir)) {
+        assemblies.AddRange(ReflectionOnlyLoadDlls(dirName));
+      }
       // try to load each .dll file in the plugin directory into the reflection only context
-      foreach (string filename in Directory.GetFiles(PluginDir, "*.dll")) {
+      foreach (string filename in Directory.GetFiles(baseDir, "*.dll")) {
         try {
           assemblies.Add(Assembly.ReflectionOnlyLoadFrom(filename));
         }
         catch (BadImageFormatException) { } // just ignore the case that the .dll file is not a CLR assembly (e.g. a native dll)
+        catch (FileLoadException) { }
+        catch (SecurityException) { }
       }
       return assemblies;
     }
+
+    /// <summary>
+    /// Checks if all plugin assemblies can be loaded. If an assembly can't be loaded the plugin is disabled.
+    /// </summary>
+    /// <param name="pluginDescriptions"></param>
+    private void CheckPluginAssemblies(IEnumerable<PluginDescription> pluginDescriptions) {
+      foreach (var desc in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {
+        try {
+          foreach (var asm in desc.Assemblies) {
+            Assembly.ReflectionOnlyLoadFrom(asm);
+          }
+        }
+        catch (BadImageFormatException) {
+          // disable the plugin
+          desc.Disable();
+        }
+        catch (FileNotFoundException) {
+          // disable the plugin
+          desc.Disable();
+        }
+        catch (FileLoadException) {
+          // disable the plugin
+          desc.Disable();
+        }
+        catch (ArgumentException) {
+          // disable the plugin
+          desc.Disable();
+        }
+        catch (SecurityException) {
+          // disable the plugin
+          desc.Disable();
+        }
+      }
+    }
+
 
     // find all types implementing IPlugin in the reflectionOnlyAssemblies and create a list of plugin descriptions
@@ -158 +202 @@
         // of the current assembly is missing.
         try {
-          foreach (Type t in assembly.GetExportedTypes()) {
-            // if there is a type that implements IPlugin
-            // use AssemblyQualifiedName to compare the types because we can't directly 
-            // compare ReflectionOnly types and Execution types
-            if (!t.IsAbstract &&
-                t.GetInterfaces().Any(x => x.AssemblyQualifiedName == typeof(IPlugin).AssemblyQualifiedName)) {
-              // fetch the attributes of the IPlugin type
-              pluginDescriptions.Add(GetPluginDescription(t));
-            }
-          }
+          // if there is a type that implements IPlugin
+          // use AssemblyQualifiedName to compare the types because we can't directly 
+          // compare ReflectionOnly types and execution types
+          var assemblyPluginDescriptions = from t in assembly.GetExportedTypes()
+                                           where !t.IsAbstract && t.GetInterfaces().Any(x => x.AssemblyQualifiedName == typeof(IPlugin).AssemblyQualifiedName)
+                                           select GetPluginDescription(t);
+          pluginDescriptions.AddRange(assemblyPluginDescriptions);
         }
         // ignore exceptions. Just don't yield a plugin description when an exception is thrown
@@ -206 +247 @@
           string pluginFileName = (string)attributeData.ConstructorArguments[0].Value;
           PluginFileType fileType = (PluginFileType)attributeData.ConstructorArguments[1].Value;
-          pluginFiles.Add(Path.Combine(PluginDir, pluginFileName));
+          pluginFiles.Add(Path.GetFullPath(Path.Combine(PluginDir, pluginFileName)));
           if (fileType == PluginFileType.Assembly) {
-            pluginAssemblies.Add(Path.Combine(PluginDir, pluginFileName));
+            pluginAssemblies.Add(Path.GetFullPath(Path.Combine(PluginDir, pluginFileName)));
           }
         }
@@ -302 +343 @@
 
     // checks if all declared plugin files are actually available and disables plugins with missing files
-    private static void CheckPluginFiles(IEnumerable<PluginDescription> pluginDescriptions) {
+    private void CheckPluginFiles(IEnumerable<PluginDescription> pluginDescriptions) {
       foreach (PluginDescription desc in pluginDescriptions) {
         if (!CheckPluginFiles(desc)) {
@@ -310 +351 @@
     }
 
-    private static bool CheckPluginFiles(PluginDescription pluginDescription) {
+    private bool CheckPluginFiles(PluginDescription pluginDescription) {
       foreach (string filename in pluginDescription.Files) {
-        if (!File.Exists(filename)) {
+        if (!FileLiesInDirectory(PluginDir, filename) ||
+          !File.Exists(filename)) {
           return false;
         }
       }
       return true;
+    }
+
+    private static bool FileLiesInDirectory(string dir, string fileName) {
+      var basePath = Path.GetFullPath(dir);
+      return Path.GetFullPath(fileName).StartsWith(basePath);
     }