Context Navigation

-                      r2475
+                      r2481
 using System.IO;
 using System.Diagnostics;
+using System.Windows.Forms;
+namespace HeuristicLab.PluginInfrastructure {
+using System.Linq;
+namespace HeuristicLab.PluginInfrastructure.Manager {
   internal class Loader : MarshalByRefObject {
-    /// <summary>
-    /// Event handler for loaded plugins.
-    /// </summary>
-    /// <param name="pluginName">The plugin that has been loaded.</param>
-    public delegate void PluginLoadedEventHandler(string pluginName);
-    public delegate void PluginLoadFailedEventHandler(string pluginName, string args);
-    private Dictionary<PluginInfo, List<string>> pluginDependencies = new Dictionary<PluginInfo, List<string>>();
-    private List<PluginInfo> preloadedPluginInfos = new List<PluginInfo>();
-    private Dictionary<IPlugin, PluginInfo> pluginInfos = new Dictionary<IPlugin, PluginInfo>();
-    private Dictionary<PluginInfo, IPlugin> allPlugins = new Dictionary<PluginInfo, IPlugin>();
-    private List<PluginInfo> disabledPlugins = new List<PluginInfo>();
-    private string pluginDir = Application.StartupPath + "/" + HeuristicLab.PluginInfrastructure.Properties.Settings.Default.PluginDir;
-    internal event PluginLoadFailedEventHandler MissingPluginFile;
     internal event PluginManagerActionEventHandler PluginAction;
+    internal ICollection<PluginInfo> ActivePlugins {
+      get {
+        List<PluginInfo> list = new List<PluginInfo>();
+        foreach (PluginInfo info in allPlugins.Keys) {
+          if (!disabledPlugins.Exists(delegate(PluginInfo disabledInfo) { return info.Name == disabledInfo.Name; })) {
+            list.Add(info);
+          }
+        }
+        return list;
+      }
+    }
+    internal ICollection<PluginInfo> InstalledPlugins {
+      get {
+        return new List<PluginInfo>(allPlugins.Keys);
+      }
+    }
+    internal ICollection<PluginInfo> DisabledPlugins {
+      get {
+        return disabledPlugins;
+      }
+    }
+    private ICollection<ApplicationInfo> applications;
+    internal ICollection<ApplicationInfo> InstalledApplications {
+    private Dictionary<PluginDescription, List<string>> pluginDependencies;
+    private List<ApplicationDescription> applications;
+    internal IEnumerable<ApplicationDescription> Applications {
       get {
         return applications;
 …
+    }
+    private IPlugin FindPlugin(PluginInfo plugin) {
+      if (allPlugins.ContainsKey(plugin)) {
+        return allPlugins[plugin];
+      } else return null;
+    private IEnumerable<PluginDescription> plugins;
+    internal IEnumerable<PluginDescription> Plugins {
+      get {
+        return plugins;
+      }
+    }
+    public string PluginDir { get; set; }
+    public Loader() {
+      this.applications = new List<ApplicationDescription>();
+      this.plugins = new List<PluginDescription>();
+      this.pluginDependencies = new Dictionary<PluginDescription, List<string>>();
+    }
 …
     /// Init first clears all internal datastructures (including plugin lists)
     /// 1. All assemblies in the plugins directory are loaded into the reflection only context.
+    /// 2. The loader checks if all dependencies for each assembly are available.
+    /// 3. All assemblies for which there are no dependencies missing are loaded into the execution context.
+    /// 4. Each loaded assembly is searched for a type that implements IPlugin, then one instance of each IPlugin type is activated
+    /// 5. The loader checks if all necessary files for each plugin are available.
+    /// 6. The loader builds an acyclic graph of PluginDescriptions (childs are dependencies of a plugin) based on the
+    /// list of assemblies of an plugin and the list of dependencies for each of those assemblies
+    /// 2. The loader checks if all necessary files for each plugin are available.
+    /// 3. The loaded builds the tree of plugin descriptions (dependencies)
+    /// 4. The loader 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
+    ///    then one instance of each IPlugin type is activated and the OnLoad hook is called.
+    /// 7. All types implementing IApplication are discovered
     /// </summary>
-    /// <exception cref="FileLoadException">Thrown when the file could not be loaded.</exception>
     internal void Init() {
+      AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += delegate(object sender, ResolveEventArgs args) {
+        try {
+          return Assembly.ReflectionOnlyLoad(args.Name);
+        }
+        catch (FileLoadException ex) {
+          return null;
+        }
+      };
+      allPlugins.Clear();
+      disabledPlugins.Clear();
+      pluginInfos.Clear();
+      pluginsByName.Clear();
+      //AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += delegate(object sender, ResolveEventArgs args) {
+      //  try {
+      //    return Assembly.ReflectionOnlyLoad(args.Name);
+      //  }
+      //  catch (FileLoadException ex) {
+      //    return null;
+      //  }
+      //};
       pluginDependencies.Clear();
+      List<Assembly> assemblies = ReflectionOnlyLoadDlls();
+      CheckAssemblyDependencies(assemblies);
+      CheckPluginFiles();
+      CheckPluginDependencies();
+      LoadPlugins();
+      IEnumerable<Assembly> reflectionOnlyAssemblies = ReflectionOnlyLoadDlls();
+      IEnumerable<PluginDescription> pluginDescriptions = GatherPluginDescriptions(reflectionOnlyAssemblies);
+      CheckPluginFiles(pluginDescriptions);
+      // a full list of plugin descriptions is available now we can build the dependency tree
+      BuildDependencyTree(pluginDescriptions);
+      // recursively check if all necessary plugins are available and not disabled
+      // disable plugins with missing or disabled dependencies
+      CheckPluginDependencies(pluginDescriptions);
+      // test full loading (in contrast to reflection only loading) of plugins
+      // disables plugins that are not loaded correctly
+      LoadPlugins(pluginDescriptions);
+      plugins = pluginDescriptions;
+      DiscoverApplications();
+    }
+    private void DiscoverApplications() {
       DiscoveryService service = new DiscoveryService();
       IApplication[] apps = service.GetInstances<IApplication>();
       applications = new List<ApplicationInfo>();
+      applications = new List<ApplicationDescription>();
       foreach (IApplication application in apps) {
         ApplicationInfo info = new ApplicationInfo();
+        ApplicationDescription info = new ApplicationDescription();
         info.Name = application.Name;
         info.Version = application.Version;
 …
+    }
     private List<Assembly> ReflectionOnlyLoadDlls() {
+    private IEnumerable<Assembly> ReflectionOnlyLoadDlls() {
       List<Assembly> assemblies = new List<Assembly>();
       // load all installed plugins into the reflection only context
       foreach (String filename in Directory.GetFiles(pluginDir, "*.dll")) {
+      // try to load each .dll file in the plugin directory into the reflection only context
+      foreach (string filename in Directory.GetFiles(PluginDir, "*.dll")) {
         try {
           assemblies.Add(ReflectionOnlyLoadDll(filename));
+          assemblies.Add(Assembly.ReflectionOnlyLoadFrom(filename));
+        }
         catch (BadImageFormatException) { } // just ignore the case that the .dll file is not actually a CLR dll
 …
+    }
     private Assembly ReflectionOnlyLoadDll(string filename) {
       return Assembly.ReflectionOnlyLoadFrom(filename);
+    }
     private void CheckAssemblyDependencies(List<Assembly> assemblies) {
+    // find all types implementing IPlugin in the reflectionOnlyAssemblies and create a list of plugin descriptions
+    // the dependencies in the plugin descriptions are not yet set correctly because we need to create
+    // the full list of all plugin descriptions first
+    private IEnumerable<PluginDescription> GatherPluginDescriptions(IEnumerable<Assembly> assemblies) {
+      List<PluginDescription> pluginDescriptions = new List<PluginDescription>();
       foreach (Assembly assembly in assemblies) {
         // GetExportedTypes throws FileNotFoundException when a referenced assembly
         // of the current assembly is missing.
         try {
+          Type[] exported = assembly.GetExportedTypes();
+          foreach (Type t in exported) {
+          foreach (Type t in assembly.GetExportedTypes()) {
             // if there is a type that implements IPlugin
+            if (! t.IsAbstract && Array.Exists<Type>(t.GetInterfaces(), delegate(Type iface) {
+              // use AssemblyQualifiedName to compare the types because we can't directly
+              // compare ReflectionOnly types and Execution types
+              return iface.AssemblyQualifiedName == typeof(IPlugin).AssemblyQualifiedName;
+            })) {
+            // 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
               GetPluginAttributeData(t);
+              pluginDescriptions.Add(GetPluginDescription(t));
+            }
+          }
+        }
         catch (FileNotFoundException ex) {
           PluginInfo info = new PluginInfo();
           AssemblyName name = assembly.GetName();
           info.Name = name.Name;
           info.Version = name.Version;
           info.Assemblies.Add(assembly.FullName);
           info.Files.Add(assembly.Location);
           info.Message = "File not found: " + ex.FileName;
           disabledPlugins.Add(info);
+          //PluginDescription info = new PluginDescription();
+          //AssemblyName name = assembly.GetName();
+          //info.Name = name.Name;
+          //info.Version = name.Version;
+          //info.Assemblies.Add(assembly.FullName);
+          //info.Files.Add(assembly.Location);
+          //info.Message = "File not found: " + ex.FileName;
+          //disabledPlugins.Add(info);
+        }
         catch (FileLoadException ex) {
           PluginInfo info = new PluginInfo();
           AssemblyName name = assembly.GetName();
           info.Name = name.Name;
           info.Version = name.Version;
           info.Files.Add(assembly.Location);
           info.Assemblies.Add(assembly.FullName);
           info.Message = "Couldn't load file: " + ex.FileName;
           disabledPlugins.Add(info);
+          //PluginDescription info = new PluginDescription();
+          //AssemblyName name = assembly.GetName();
+          //info.Name = name.Name;
+          //info.Version = name.Version;
+          //info.Files.Add(assembly.Location);
+          //info.Assemblies.Add(assembly.FullName);
+          //info.Message = "Couldn't load file: " + ex.FileName;
+          //disabledPlugins.Add(info);
+        }
         catch (InvalidPluginException ex) {
+          PluginInfo info = new PluginInfo();
+          AssemblyName name = assembly.GetName();
+          info.Name = name.Name;
+          info.Version = name.Version;
+          info.Files.Add(assembly.Location);
+          info.Assemblies.Add(assembly.FullName);
+          info.Message = "Couldn't load plugin class from assembly: " + assembly.GetName().Name+". Necessary plugin attributes are missing.";
+          disabledPlugins.Add(info);
+        }
+      }
+          //PluginDescription info = new PluginDescription();
+          //AssemblyName name = assembly.GetName();
+          //info.Name = name.Name;
+          //info.Version = name.Version;
+          //info.Files.Add(assembly.Location);
+          //info.Assemblies.Add(assembly.FullName);
+          //info.Message = "Couldn't load plugin class from assembly: " + assembly.GetName().Name + ". Necessary plugin attributes are missing.";
+          //disabledPlugins.Add(info);
+        }
+      }
+      return pluginDescriptions;
+    }
 …
     /// </summary>
     /// <param name="t"></param>
     private void GetPluginAttributeData(Type t) {
+    private PluginDescription GetPluginDescription(Type pluginType) {
       // get all attributes of that type
       IList<CustomAttributeData> attributes = CustomAttributeData.GetCustomAttributes(t);
+      IList<CustomAttributeData> attributes = CustomAttributeData.GetCustomAttributes(pluginType);
       List<string> pluginAssemblies = new List<string>();
       List<string> pluginDependencies = new List<string>();
       List<string> pluginFiles = new List<string>();
       string pluginName = "";
       // iterate through all custom attributes and search for named arguments that we are interested in
+      string pluginName = null;
+      // iterate through all custom attributes and search for attributed that we are interested in
       foreach (CustomAttributeData attributeData in attributes) {
+        List<CustomAttributeNamedArgument> namedArguments = new List<CustomAttributeNamedArgument>(attributeData.NamedArguments);
+        // if the current attribute contains a named argument with the name "Name" then extract the plugin name
+        CustomAttributeNamedArgument pluginNameArgument = namedArguments.Find(delegate(CustomAttributeNamedArgument arg) {
+          return arg.MemberInfo.Name == "Name";
+        });
+        if (pluginNameArgument.MemberInfo != null) {
+          pluginName = (string)pluginNameArgument.TypedValue.Value;
+        }
+        // if the current attribute contains a named argument with the name "Dependency" then extract the dependency
+        // and store it in the list of all dependencies
+        CustomAttributeNamedArgument dependencyNameArgument = namedArguments.Find(delegate(CustomAttributeNamedArgument arg) {
+          return arg.MemberInfo.Name == "Dependency";
+        });
+        if (dependencyNameArgument.MemberInfo != null) {
+          pluginDependencies.Add((string)dependencyNameArgument.TypedValue.Value);
+        }
+        // if the current attribute has a named argument "Filename" then find if the argument "Filetype" is also supplied
+        // and if the filetype is Assembly then store the name of the assembly in the list of assemblies
+        CustomAttributeNamedArgument filenameArg = namedArguments.Find(delegate(CustomAttributeNamedArgument arg) {
+          return arg.MemberInfo.Name == "Filename";
+        });
+        CustomAttributeNamedArgument filetypeArg = namedArguments.Find(delegate(CustomAttributeNamedArgument arg) {
+          return arg.MemberInfo.Name == "Filetype";
+        });
+        if (filenameArg.MemberInfo != null && filetypeArg.MemberInfo != null) {
+          pluginFiles.Add(pluginDir + "/" + (string)filenameArg.TypedValue.Value);
+          if ((PluginFileType)filetypeArg.TypedValue.Value == PluginFileType.Assembly) {
+            pluginAssemblies.Add(pluginDir + "/" + (string)filenameArg.TypedValue.Value);
+        if (IsAttributeDataForType(attributeData, typeof(PluginDescriptionAttribute))) {
+          pluginName = (string)attributeData.ConstructorArguments[0].Value;
+        } else if (IsAttributeDataForType(attributeData, typeof(PluginDependencyAttribute))) {
+          pluginDependencies.Add((string)attributeData.ConstructorArguments[0].Value);
+        } else if (IsAttributeDataForType(attributeData, typeof(PluginFileAttribute))) {
+          string pluginFileName = (string)attributeData.ConstructorArguments[0].Value;
+          PluginFileType fileType = (PluginFileType)attributeData.ConstructorArguments[1].Value;
+          pluginFiles.Add(PluginDir + "/" + pluginFileName);
+          if (fileType == PluginFileType.Assembly) {
+            pluginAssemblies.Add(PluginDir + "/" + pluginFileName);
+          }
+        }
 …
       // minimal sanity check of the attribute values
+      if (pluginName != "" && pluginAssemblies.Count > 0) {
+        // create a temporary PluginInfo that contains the attribute values
+        PluginInfo info = new PluginInfo();
+      if (!string.IsNullOrEmpty(pluginName) &&
+          pluginFiles.Count > 0 &&
+          pluginAssemblies.Count > 0) {
+        // create a temporary PluginDescription that contains the attribute values
+        PluginDescription info = new PluginDescription();
         info.Name = pluginName;
+        info.Version = t.Assembly.GetName().Version;
+        info.Assemblies = pluginAssemblies;
+        info.Files.AddRange(pluginFiles);
+        info.Version = pluginType.Assembly.GetName().Version;
+        info.AddAssemblies(pluginAssemblies);
+        info.AddFiles(pluginFiles);
+        info.PluginState = PluginState.Undefined;
         this.pluginDependencies[info] = pluginDependencies;
         preloadedPluginInfos.Add(info);
+        return info;
       } else {
+        throw new InvalidPluginException();
+      }
+    }
+    private void CheckPluginDependencies() {
+      foreach (PluginInfo pluginInfo in preloadedPluginInfos) {
+        // don't need to check plugins that are already disabled
+        if (disabledPlugins.Contains(pluginInfo)) {
+          continue;
+        }
+        visitedDependencies.Clear();
+        if (!CheckPluginDependencies(pluginInfo.Name)) {
+          PluginInfo matchingInfo = preloadedPluginInfos.Find(delegate(PluginInfo info) { return info.Name == pluginInfo.Name; });
+          if (matchingInfo == null) throw new InvalidProgramException(); // shouldn't happen
+          foreach (string dependency in pluginDependencies[matchingInfo]) {
+            PluginInfo dependencyInfo = new PluginInfo();
+            dependencyInfo.Name = dependency;
+            pluginInfo.Dependencies.Add(dependencyInfo);
+          }
+          pluginInfo.Message = "Disabled: missing plugin dependency.";
+          disabledPlugins.Add(pluginInfo);
+        }
+      }
+    }
+    private List<string> visitedDependencies = new List<string>();
+    private bool CheckPluginDependencies(string pluginName) {
+      if (!preloadedPluginInfos.Exists(delegate(PluginInfo info) { return pluginName == info.Name; }) ||
+        disabledPlugins.Exists(delegate(PluginInfo info) { return pluginName == info.Name; }) ||
+        visitedDependencies.Contains(pluginName)) {
+        // when the plugin is not available return false;
+        return false;
+      } else {
+        // otherwise check if all dependencies of the plugin are OK
+        // if yes then this plugin is also ok and we store it in the list of loadable plugins
+        PluginInfo matchingInfo = preloadedPluginInfos.Find(delegate(PluginInfo info) { return info.Name == pluginName; });
+        if (matchingInfo == null) throw new InvalidProgramException(); // shouldn't happen
+        foreach (string dependency in pluginDependencies[matchingInfo]) {
+          visitedDependencies.Add(pluginName);
+          if (CheckPluginDependencies(dependency) == false) {
+            // if only one dependency is not available that means that the current plugin also is unloadable
+            return false;
+          }
+          visitedDependencies.Remove(pluginName);
+        }
+        // all dependencies OK
+        return true;
+      }
+    }
+    private Dictionary<string, IPlugin> pluginsByName = new Dictionary<string, IPlugin>();
+    private void LoadPlugins() {
+        throw new InvalidPluginException("Invalid metadata in plugin " + pluginType.ToString());
+      }
+    }
+    private bool IsAttributeDataForType(CustomAttributeData attributeData, Type attributeType) {
+      return attributeData.Constructor.DeclaringType.AssemblyQualifiedName == attributeType.AssemblyQualifiedName;
+    }
+    // builds a dependency tree of all plugin descriptions
+    // searches matching plugin descriptions based on the list of dependency names for each plugin
+    // and sets the dependencies in the plugin descriptions
+    private void BuildDependencyTree(IEnumerable<PluginDescription> pluginDescriptions) {
+      foreach (var desc in pluginDescriptions) {
+        foreach (string pluginName in pluginDependencies[desc]) {
+          var matchingDescriptions = pluginDescriptions.Where(x => x.Name == pluginName);
+          if (matchingDescriptions.Count() > 0) {
+            desc.AddDependency(matchingDescriptions.First());
+          } else {
+            // no plugin description that matches the dependency name is available => plugin is disabled
+            desc.PluginState = PluginState.Disabled;
+            break; // stop processing more dependencies
+          }
+        }
+      }
+    }
+    private void CheckPluginDependencies(IEnumerable<PluginDescription> pluginDescriptions) {
+      foreach (PluginDescription pluginDescription in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {
+        if (IsAnyDependencyDisabled(pluginDescription)) {
+          // PluginDescription.Message = "Disabled: missing plugin dependency.";
+          pluginDescription.PluginState = PluginState.Disabled;
+        }
+      }
+    }
+    private bool IsAnyDependencyDisabled(PluginDescription descr) {
+      if (descr.PluginState == PluginState.Disabled) return true;
+      foreach (PluginDescription dependency in descr.Dependencies) {
+        if (IsAnyDependencyDisabled(dependency)) return true;
+      }
+      return false;
+    }
+    private void LoadPlugins(IEnumerable<PluginDescription> pluginDescriptions) {
       // load all loadable plugins (all dependencies available) into the execution context
+      foreach (PluginInfo pluginInfo in preloadedPluginInfos) {
+        if (!disabledPlugins.Contains(pluginInfo)) {
+          foreach (string assembly in pluginInfo.Assemblies) {
+            Assembly.LoadFrom(assembly);
+          }
+        }
+      }
+      Queue<IPlugin> pluginsToLoad = new Queue<IPlugin>();
+      DiscoveryService service = new DiscoveryService();
+      // now search and instantiate an IPlugin type in each loaded assembly
+      // and prepare the queue to load all plugins
+      foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) {
+        // don't search for plugins in the PluginInfrastructure
+        if (assembly == this.GetType().Assembly)
+          continue;
+        Type[] availablePluginTypes = service.GetTypes(typeof(IPlugin), assembly);
+        foreach (Type pluginType in availablePluginTypes) {
+      foreach (PluginDescription desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled))) {
+        List<Type> types = new List<Type>();
+        foreach (string assembly in desc.Assemblies) {
+          var asm = Assembly.LoadFrom(assembly);
+          foreach (Type t in asm.GetTypes()) {
+            if (typeof(IPlugin).IsAssignableFrom(t)) {
+              types.Add(t);
+            }
+          }
+        }
+        foreach (Type pluginType in types) {
           if (!pluginType.IsAbstract && !pluginType.IsInterface && !pluginType.HasElementType) {
             IPlugin plugin = (IPlugin)Activator.CreateInstance(pluginType);
+            pluginsToLoad.Enqueue(plugin);
+            pluginsByName.Add(plugin.Name, plugin);
+          }
+        }
+      }
+      // load all plugins respecting their dependencies
+      while (pluginsToLoad.Count > 0) {
+        IPlugin plugin = pluginsToLoad.Dequeue();
+        PluginInfo pluginInfo = GetPluginInfo(plugin);
+        bool canLoad = true;
+        foreach (PluginInfo dependency in pluginInfo.Dependencies) {
+          if (!allPlugins.ContainsKey(dependency)) {
+            canLoad = false;
+            break;
+          }
+        }
+        if (canLoad) {
+          PluginAction(this, new PluginManagerActionEventArgs(plugin.Name, PluginManagerAction.InitializingPlugin));
+          plugin.OnLoad();
+          allPlugins.Add(pluginInfo, plugin);
+          PluginAction(this, new PluginManagerActionEventArgs(plugin.Name, PluginManagerAction.InitializedPlugin));
+        } else {
+          pluginsToLoad.Enqueue(plugin);
+        }
+      }
+    }
+    private PluginInfo GetPluginInfo(IPlugin plugin) {
+      if (pluginInfos.ContainsKey(plugin)) {
+        return pluginInfos[plugin];
+      }
+      // store the data of the plugin in a description file which can be used without loading the plugin assemblies
+      PluginInfo pluginInfo = new PluginInfo();
+      pluginInfo.Name = plugin.Name;
+      pluginInfo.Version = plugin.Version;
+      object[] customAttributes = plugin.GetType().Assembly.GetCustomAttributes(typeof(AssemblyBuildDateAttribute), false);
+      if (customAttributes.Length > 0) {
+        pluginInfo.BuildDate = ((AssemblyBuildDateAttribute)customAttributes[0]).BuildDate;
+      }
+      string baseDir = AppDomain.CurrentDomain.BaseDirectory;
+      Array.ForEach<string>(plugin.FileNames, delegate(string file) {
+        string filename = pluginDir + "/" + file;
+        // always use \ as the directory separator
+        pluginInfo.Files.Add(filename.Replace('/', '\\'));
+      });
+      PluginInfo preloadedInfo = preloadedPluginInfos.Find(delegate(PluginInfo info) { return info.Name == plugin.Name; });
+      foreach (string assembly in preloadedInfo.Assemblies) {
+        // always use \ as directory separator (this is necessary for discovery of types in
+        // plugins see DiscoveryService.GetTypes()
+        pluginInfo.Assemblies.Add(assembly.Replace('/', '\\'));
+      }
+      foreach (string dependency in pluginDependencies[preloadedInfo]) {
+        // accumulate the dependencies of each assembly into the dependencies of the whole plugin
+        PluginInfo dependencyInfo = GetPluginInfo(pluginsByName[dependency]);
+        pluginInfo.Dependencies.Add(dependencyInfo);
+      }
+      pluginInfos[plugin] = pluginInfo;
+      return pluginInfo;
+    }
+    private void CheckPluginFiles() {
+      foreach (PluginInfo plugin in preloadedPluginInfos) {
+        if (!CheckPluginFiles(plugin)) {
+          plugin.Message = "Disabled: missing plugin file.";
+          disabledPlugins.Add(plugin);
+        }
+      }
+    }
+    private bool CheckPluginFiles(PluginInfo pluginInfo) {
+      foreach (string filename in pluginInfo.Files) {
+            plugin.OnLoad();
+            PluginAction(this, new PluginManagerActionEventArgs(plugin.Name, PluginManagerAction.PluginLoaded));
+          }
+        }
+      }
+    }
+    //private PluginDescription GetPluginDescription(IPlugin plugin) {
+    //  if (PluginDescriptions.ContainsKey(plugin)) {
+    //    return PluginDescriptions[plugin];
+    //  }
+    //  // store the data of the plugin in a description file which can be used without loading the plugin assemblies
+    //  PluginDescription PluginDescription = new PluginDescription();
+    //  PluginDescription.Name = plugin.Name;
+    //  PluginDescription.Version = plugin.Version;
+    //  object[] customAttributes = plugin.GetType().Assembly.GetCustomAttributes(typeof(AssemblyBuildDateAttribute), false);
+    //  if (customAttributes.Length > 0) {
+    //    PluginDescription.BuildDate = ((AssemblyBuildDateAttribute)customAttributes[0]).BuildDate;
+    //  }
+    //  string baseDir = AppDomain.CurrentDomain.BaseDirectory;
+    //  Array.ForEach<string>(plugin.FileNames, delegate(string file) {
+    //    string filename = pluginDir + "/" + file;
+    //    // always use \ as the directory separator
+    //    PluginDescription.Files.Add(filename.Replace('/', '\\'));
+    //  });
+    //  PluginDescription preloadedInfo = preloadedPluginDescriptions.Find(delegate(PluginDescription info) { return info.Name == plugin.Name; });
+    //  foreach (string assembly in preloadedInfo.Assemblies) {
+    //    // always use \ as directory separator (this is necessary for discovery of types in
+    //    // plugins see DiscoveryService.GetTypes()
+    //    PluginDescription.Assemblies.Add(assembly.Replace('/', '\\'));
+    //  }
+    //  foreach (string dependency in pluginDependencies[preloadedInfo]) {
+    //    // accumulate the dependencies of each assembly into the dependencies of the whole plugin
+    //    PluginDescription dependencyInfo = GetPluginDescription(pluginsByName[dependency]);
+    //    PluginDescription.Dependencies.Add(dependencyInfo);
+    //  }
+    //  PluginDescriptions[plugin] = PluginDescription;
+    //  return PluginDescription;
+    //}
+    // checks if all declared plugin files are actually available and disables plugins with missing files
+    private void CheckPluginFiles(IEnumerable<PluginDescription> pluginDescriptions) {
+      foreach (PluginDescription desc in pluginDescriptions) {
+        if (!CheckPluginFiles(desc)) {
+          //plugin.Message = "Disabled: missing plugin file.";
+          desc.PluginState = PluginState.Disabled;
+        }
+      }
+    }
+    private bool CheckPluginFiles(PluginDescription PluginDescription) {
+      foreach (string filename in PluginDescription.Files) {
         if (!File.Exists(filename)) {
           if (MissingPluginFile != null) {
             MissingPluginFile(pluginInfo.Name, filename);
+          }
+          //if (MissingPluginFile != null) {
+          //  MissingPluginFile(PluginDescription.Name, filename);
+          //}
           return false;
+        }
 …
       return null;
+    }
-    internal void OnDelete(PluginInfo pluginInfo) {
-      IPlugin plugin = FindPlugin(pluginInfo);
-      if (plugin != null) plugin.OnDelete();
+    }
-    internal void OnInstall(PluginInfo pluginInfo) {
-      IPlugin plugin = FindPlugin(pluginInfo);
-      if (plugin != null) plugin.OnInstall();
+    }
-    internal void OnPreUpdate(PluginInfo pluginInfo) {
-      IPlugin plugin = FindPlugin(pluginInfo);
-      if (plugin != null) plugin.OnPreUpdate();
+    }
-    internal void OnPostUpdate(PluginInfo pluginInfo) {
-      IPlugin plugin = FindPlugin(pluginInfo);
-      if (plugin != null) plugin.OnPostUpdate();
+    }
+  }
+}

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

Context Navigation

Changeset 2481 for branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/Loader.cs

Legend:

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager

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

Download in other formats: