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

#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 EventHandler<PluginInfrastructureEventArgs> PluginLoaded;

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

      AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += ReflectionOnlyAssemblyResolveEventHandler;
    }

    private Assembly ReflectionOnlyAssemblyResolveEventHandler(object sender, ResolveEventArgs args) {
      //try {
      return Assembly.ReflectionOnlyLoad(args.Name);
      //}
      //catch (FileLoadException ex) {
      //  return null;
      //}
    }


    /// <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() {
      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);

      // mark all plugins as enabled that were not disabled in CheckPluginFiles or CheckPluginDependencies
      foreach (var desc in pluginDescriptions)
        if (desc.PluginState != PluginState.Disabled)
          desc.Enable();

      // 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() {
      applications = new List<ApplicationDescription>();

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

        applications.Add(info);
      }
    }

    private IEnumerable<IApplication> GetApplications() {
      return from asm in AppDomain.CurrentDomain.GetAssemblies()
             from t in asm.GetTypes()
             where typeof(IApplication).IsAssignableFrom(t) &&
               !t.IsAbstract && !t.IsInterface && !t.HasElementType
             select (IApplication)Activator.CreateInstance(t);
    }

    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) {
        }
        catch (FileLoadException) {
        }
        catch (InvalidPluginException) {
        }
      }
      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(PluginAttribute))) {
          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);

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


    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 (var desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions
                                                                                .Cast<IPluginDescription>()
                                                                                .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();
            FirePluginLoaded(plugin.Name);
          }
        }
        desc.Load();
      }
    }

    // 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)) {
          desc.Disable();
        }
      }
    }

    private bool CheckPluginFiles(PluginDescription PluginDescription) {
      foreach (string filename in PluginDescription.Files) {
        if (!File.Exists(filename)) {
          return false;
        }
      }
      return true;
    }

    private void FirePluginLoaded(string pluginName) {
      if (PluginLoaded != null)
        PluginLoaded(this, new PluginInfrastructureEventArgs("Plugin loaded", pluginName));
    }

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