source: branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/Loader.cs @ 2481

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.IO;
using System.Diagnostics;
using System.Linq;


namespace HeuristicLab.PluginInfrastructure.Manager {
  internal class Loader : MarshalByRefObject {
    internal event PluginManagerActionEventHandler PluginAction;

    private Dictionary<PluginDescription, List<string>> pluginDependencies;

    private List<ApplicationDescription> applications;
    internal IEnumerable<ApplicationDescription> Applications {
      get {
        return applications;
      }
    }

    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>>();
    }


    /// <summary>
    /// 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 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>
    internal void Init() {
      //AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += delegate(object sender, ResolveEventArgs args) {
      //  try {
      //    return Assembly.ReflectionOnlyLoad(args.Name);
      //  }
      //  catch (FileLoadException ex) {
      //    return null;
      //  }
      //};
      pluginDependencies.Clear();

      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<ApplicationDescription>();

      foreach (IApplication application in apps) {
        ApplicationDescription info = new ApplicationDescription();
        info.Name = application.Name;
        info.Version = application.Version;
        info.Description = application.Description;
        info.AutoRestart = application.RestartOnErrors;
        info.PluginAssembly = application.GetType().Assembly.GetName().Name;
        info.PluginType = application.GetType().Namespace + "." + application.GetType().Name;

        applications.Add(info);
      }
    }

    private IEnumerable<Assembly> ReflectionOnlyLoadDlls() {
      List<Assembly> assemblies = new List<Assembly>();
      // 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(Assembly.ReflectionOnlyLoadFrom(filename));
        }
        catch (BadImageFormatException) { } // just ignore the case that the .dll file is not actually a CLR dll
      }
      return 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 {
          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));
            }
          }
        }
        catch (FileNotFoundException ex) {
          //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) {
          //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) {
          //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>
    /// Extracts plugin information for this type.
    /// Reads plugin name, list and type of files and dependencies of the plugin. This information is necessary for
    /// plugin dependency checking before plugin activation.
    /// </summary>
    /// <param name="t"></param>
    private PluginDescription GetPluginDescription(Type pluginType) {
      // get all attributes of that type
      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 = null;
      // iterate through all custom attributes and search for attributed that we are interested in 
      foreach (CustomAttributeData attributeData in attributes) {
        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 (!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 = pluginType.Assembly.GetName().Version;
        info.AddAssemblies(pluginAssemblies);
        info.AddFiles(pluginFiles);
        info.PluginState = PluginState.Undefined;

        this.pluginDependencies[info] = pluginDependencies;
        return info;
      } else {
        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 (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);
            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(PluginDescription.Name, filename);
          //}
          return false;
        }
      }
      return true;
    }

    /// <summary>
    /// Initializes the life time service with an infinte lease time.
    /// </summary>
    /// <returns><c>null</c>.</returns>
    public override object InitializeLifetimeService() {
      return null;
    }
  }
}