Changeset 2536 for branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/Manager

Timestamp:

11/27/09 14:45:01 (15 years ago)

Author:

gkronber

Message:

Implemented cycle detection of plugin dependencies. #799

File:

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

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

@@ -77 +77 @@
     /// 1. All assemblies in the plugins directory are loaded into the reflection only context.
     /// 2. The validator checks if all necessary files for each plugin are available.
-    /// 3. The validator builds the tree of plugin descriptions (dependencies)
-    /// 4. The validator checks if all dependencies for each plugin are ok.
-    /// 5. All plugins for which there are no dependencies missing are loaded into the execution context.
-    /// 6. Each loaded plugin (all assemblies) is searched for a types that implement IPlugin
+    /// 3. The validator checks if all declared plugin assemblies can be loaded.
+    /// 4. The validator builds the tree of plugin descriptions (dependencies)
+    /// 5. The validator checks if there are any cycles in the plugin dependency graph and disables plugin with circular dependencies
+    /// 6. The validator checks for each plugin if any dependency is disabled.
+    /// 7. All plugins that are not disabled are loaded into the execution context.
+    /// 8. Each loaded plugin (all assemblies) is searched for a types that implement IPlugin
     ///    then one instance of each IPlugin type is activated and the OnLoad hook is called.
-    /// 7. All types implementing IApplication are discovered
+    /// 9. All types implementing IApplication are discovered
     /// </summary>
     internal void DiscoverAndCheckPlugins() {
@@ -91 +93 @@
       CheckPluginFiles(pluginDescriptions);
 
+      // check if all plugin assemblies can be loaded
       CheckPluginAssemblies(pluginDescriptions);
 
       // a full list of plugin descriptions is available now we can build the dependency tree
       BuildDependencyTree(pluginDescriptions);
+
+      // check for dependency cycles
+      CheckPluginDependencyCycles(pluginDescriptions);
 
       // recursively check if all necessary plugins are available and not disabled
@@ -100 +106 @@
       CheckPluginDependencies(pluginDescriptions);
 
-      // mark all plugins as enabled that were not disabled in CheckPluginFiles or CheckPluginDependencies
+      // mark all plugins as enabled that were not disabled in CheckPluginFiles, CheckPluginAssemblies, 
+      // CheckCircularDependencies, or CheckPluginDependencies
       foreach (var desc in pluginDescriptions)
         if (desc.PluginState != PluginState.Disabled)
@@ -300 +307 @@
     }
 
+    private void CheckPluginDependencyCycles(IEnumerable<PluginDescription> pluginDescriptions) {
+      foreach (var plugin in pluginDescriptions) {
+        // if the plugin is not disabled anyway check if there are cycles
+        if (plugin.PluginState != PluginState.Disabled && HasCycleInDependencies(plugin, plugin.Dependencies)) {
+          plugin.Disable();
+        }
+      }
+    }
+
+    private bool HasCycleInDependencies(PluginDescription plugin, IEnumerable<PluginDescription> pluginDependencies) {
+      foreach (var dep in pluginDependencies) {
+        // if one of the dependencies is the original plugin we found a cycle and can return
+        // if the dependency is already disabled we can ignore the cycle detection because we will disable the plugin anyway
+        // if following one of the dependencies recursively leads to a cycle then we also return
+        if (dep == plugin || dep.PluginState == PluginState.Disabled || HasCycleInDependencies(plugin, dep.Dependencies)) return true;
+      }
+      // no cycle found and none of the direct and indirect dependencies is disabled
+      return false;
+    }
+
     private void CheckPluginDependencies(IEnumerable<PluginDescription> pluginDescriptions) {
       foreach (PluginDescription pluginDescription in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {