Changeset 2779

Timestamp:

02/11/10 13:41:52 (15 years ago)

Author:

gkronber

Message:

Added a way to store information why a plugin is disabled in plugin descriptions as suggested by abeham after code review. #863.

Location:

trunk/sources/HeuristicLab.PluginInfrastructure

Files:

• Advanced/InstallationManager.cs (modified) (1 diff)
• Manager/PluginDescription.cs (modified) (3 diffs)
• Manager/PluginValidator.cs (modified) (6 diffs)

trunk/sources/HeuristicLab.PluginInfrastructure/Advanced/InstallationManager.cs

@@ -105 +105 @@
       StringBuilder builder = new StringBuilder();
       builder.AppendLine("Problem report:");
-      var missingFiles = from x in desc.Files
-                         where !File.Exists(x.Name)
-                         select x.Name;
-      if (missingFiles.Count() > 0) {
-        foreach (string fileName in from file in desc.Files select file.Name) {
-          if (!File.Exists(fileName)) builder.Append("Missing file: ").AppendLine(fileName);
-        }
-        return builder.ToString();
-      } else {
-        // or any dependency is disabled
-        var disabledDependencies = from x in desc.Dependencies
-                                   where x.PluginState == PluginState.Disabled
-                                   select x;
-        if (disabledDependencies.Count() > 0) {
-          foreach (var dependency in disabledDependencies) {
-            builder.Append(dependency.Name).AppendLine(" is disabled.").AppendLine(DetermineProblem(dependency));
-          }
-          return builder.ToString();
-        } else {
-          // or any dependency is missing / not installed
-          var declaredDependencies = GetDeclaredDependencies(desc);
-          if (declaredDependencies.Count() != desc.Dependencies.Count()) {
-            var missingDependencies = from x in declaredDependencies
-                                      where !desc.Dependencies.Any(dep => dep.Name == x)
-                                      select x;
-            builder.AppendLine("Necessary dependencies are missing:");
-            foreach (string missingDependency in missingDependencies) {
-              builder.AppendLine(missingDependency);
-            }
-          } else {
-            // or there was a problem loading the assemblies
-            builder.AppendLine("There was a problem while loading assemblies: ");
-            foreach (string assemblyLocation in desc.AssemblyLocations) {
-              builder.AppendLine(assemblyLocation + ": " + AssemblyName.GetAssemblyName(assemblyLocation).FullName);
-            }
-            return builder.ToString();
-          }
-        }
-      }
-      return "There is an unknown problem with plugin: " + desc.Name;
+      builder.AppendLine(desc.LoadingErrorInformation);
+      return builder.ToString();
     }
 

trunk/sources/HeuristicLab.PluginInfrastructure/Manager/PluginDescription.cs

@@ -97 +97 @@
     }
 
+    private string loadingErrorInformation;
+    /// <summary>
+    /// Gets the error message why this plugin has been disabled.
+    /// </summary>
+    internal string LoadingErrorInformation {
+      get {
+        return loadingErrorInformation;
+      }
+    }
 
     private List<PluginFile> files = new List<PluginFile>();
@@ -126 +135 @@
     }
 
-    
+
     /// <summary>
     /// Gets the locations (file names) of the assemblies that belong to this plugin.
@@ -138 +147 @@
     }
 
-    internal void Disable() {
+    internal void Disable(string loadingErrorInformation) {
       if (pluginState != PluginState.Undefined)
         throw new InvalidOperationException("Can't disabled a plugin in state " + pluginState);
       pluginState = PluginState.Disabled;
+      this.loadingErrorInformation = loadingErrorInformation;
     }
 

trunk/sources/HeuristicLab.PluginInfrastructure/Manager/PluginValidator.cs

@@ -190 +190 @@
       foreach (var desc in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {
         try {
+          var missingAssemblies = new List<string>();
           foreach (var asmLocation in desc.AssemblyLocations) {
             // the assembly must have been loaded in ReflectionOnlyDlls
             // so we simply determine the name of the assembly and try to find it in the cache of loaded assemblies
             var asmName = AssemblyName.GetAssemblyName(asmLocation);
-
             if (!reflectionOnlyAssemblies.ContainsKey(asmName.FullName)) {
-              desc.Disable();
-              break; // as soon as one assembly is not available disable the plugin and check the next plugin description
+              missingAssemblies.Add(asmName.FullName);
             }
           }
-        }
-        catch (BadImageFormatException) {
+          if (missingAssemblies.Count > 0) {
+            StringBuilder errorStrBuiler = new StringBuilder();
+            errorStrBuiler.AppendLine("Missing assemblies:");
+            foreach (string missingAsm in missingAssemblies) {
+              errorStrBuiler.AppendLine(missingAsm);
+            }
+            desc.Disable(errorStrBuiler.ToString());
+          }
+        }
+        catch (BadImageFormatException ex) {
           // disable the plugin
-          desc.Disable();
-        }
-        catch (FileNotFoundException) {
+          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "BadImageFormatException: " + ex.Message);
+        }
+        catch (FileNotFoundException ex) {
           // disable the plugin
-          desc.Disable();
-        }
-        catch (FileLoadException) {
+          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "FileNotFoundException: " + ex.Message);
+        }
+        catch (FileLoadException ex) {
           // disable the plugin
-          desc.Disable();
-        }
-        catch (ArgumentException) {
+          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "FileLoadException: " + ex.Message);
+        }
+        catch (ArgumentException ex) {
           // disable the plugin
-          desc.Disable();
-        }
-        catch (SecurityException) {
+          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "ArgumentException: " + ex.Message);
+        }
+        catch (SecurityException ex) {
           // disable the plugin
-          desc.Disable();
+          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "SecurityException: " + ex.Message);
         }
       }
@@ -370 +377 @@
     private void BuildDependencyTree(IEnumerable<PluginDescription> pluginDescriptions) {
       foreach (var desc in pluginDescriptions) {
+        var missingDependencies = new List<PluginDependency>();
         foreach (var dependency in pluginDependencies[desc]) {
           var matchingDescriptions = from availablePlugin in pluginDescriptions
@@ -378 +386 @@
             desc.AddDependency(matchingDescriptions.Single());
           } else {
-            // no plugin description that matches the dependency name is available => plugin is disabled
-            desc.Disable(); break;
-          }
+            missingDependencies.Add(dependency);
+          }
+        }
+        // no plugin description that matches the dependencies are available => plugin is disabled
+        if (missingDependencies.Count > 0) {
+          StringBuilder errorStrBuilder = new StringBuilder();
+          errorStrBuilder.AppendLine("Missing dependencies:");
+          foreach (var missingDep in missingDependencies) {
+            errorStrBuilder.AppendLine(missingDep.Name + " " + missingDep.Version);
+          }
+          desc.Disable(errorStrBuilder.ToString());
         }
       }
@@ -409 +425 @@
     private void CheckPluginDependencyCycles(IEnumerable<PluginDescription> pluginDescriptions) {
       foreach (var plugin in pluginDescriptions) {
-        // if the plugin is not disabled anyway check if there are cycles
+        // if the plugin is not disabled check if there are cycles
         if (plugin.PluginState != PluginState.Disabled && HasCycleInDependencies(plugin, plugin.Dependencies)) {
-          plugin.Disable();
+          plugin.Disable("Dependency graph has a cycle.");
         }
       }
@@ -429 +445 @@
     private void CheckPluginDependencies(IEnumerable<PluginDescription> pluginDescriptions) {
       foreach (PluginDescription pluginDescription in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {
-        if (IsAnyDependencyDisabled(pluginDescription)) {
-          pluginDescription.Disable();
-        }
-      }
-    }
-
-
-    private bool IsAnyDependencyDisabled(PluginDescription descr) {
-      if (descr.PluginState == PluginState.Disabled) return true;
+        List<PluginDescription> disabledPlugins = new List<PluginDescription>();
+        if (IsAnyDependencyDisabled(pluginDescription, disabledPlugins)) {
+          StringBuilder errorStrBuilder = new StringBuilder();
+          errorStrBuilder.AppendLine("Dependencies are disabled:");
+          foreach (var disabledPlugin in disabledPlugins) {
+            errorStrBuilder.AppendLine(disabledPlugin.Name + " " + disabledPlugin.Version);
+          }
+          pluginDescription.Disable(errorStrBuilder.ToString());
+        }
+      }
+    }
+
+
+    private bool IsAnyDependencyDisabled(PluginDescription descr, List<PluginDescription> disabledPlugins) {
+      if (descr.PluginState == PluginState.Disabled) {
+        disabledPlugins.Add(descr);
+        return true;
+      }
       foreach (PluginDescription dependency in descr.Dependencies) {
-        if (IsAnyDependencyDisabled(dependency)) return true;
-      }
-      return false;
+        IsAnyDependencyDisabled(dependency, disabledPlugins);
+      }
+      return disabledPlugins.Count > 0;
     }
 
@@ -473 +498 @@
     private void CheckPluginFiles(IEnumerable<PluginDescription> pluginDescriptions) {
       foreach (PluginDescription desc in pluginDescriptions) {
-        if (!CheckPluginFiles(desc)) {
-          desc.Disable();
-        }
-      }
-    }
-
-    private bool CheckPluginFiles(PluginDescription pluginDescription) {
+        IEnumerable<string> missingFiles;
+        if (ArePluginFilesMissing(desc, out missingFiles)) {
+          StringBuilder errorStrBuilder = new StringBuilder();
+          errorStrBuilder.AppendLine("Missing files:");
+          foreach (string fileName in missingFiles) {
+            errorStrBuilder.AppendLine(fileName);
+          }
+          desc.Disable(errorStrBuilder.ToString());
+        }
+      }
+    }
+
+    private bool ArePluginFilesMissing(PluginDescription pluginDescription, out IEnumerable<string> missingFiles) {
+      List<string> missing = new List<string>();
       foreach (string filename in pluginDescription.Files.Select(x => x.Name)) {
         if (!FileLiesInDirectory(PluginDir, filename) ||
           !File.Exists(filename)) {
-          return false;
-        }
-      }
-      return true;
+          missing.Add(filename);
+        }
+      }
+      missingFiles = missing;
+      return missing.Count > 0;
     }