source: branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/PluginManager.cs @ 2488

#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.Security.Policy;
using System.Reflection;
using System.Diagnostics;
using System.Security.Permissions;
using System.Security;
using System.Linq;

namespace HeuristicLab.PluginInfrastructure.Manager {

  // must extend MarshalByRefObject because of event passing between Loader and PluginManager (each in it's own AppDomain)
  /// <summary>
  /// Class to manage different plugins.
  /// </summary>
  public class PluginManager : MarshalByRefObject {
    /// <summary>
    /// Event handler for actions in the plugin manager.
    /// </summary>
    public event PluginManagerActionEventHandler Action;

    private string pluginDir;

    // singleton pattern
    public PluginManager(string pluginDir) {
      this.pluginDir = pluginDir;
    }

    ///// <summary>
    ///// Gets all installed plugins.
    ///// </summary>
    ///// <remarks>This information is provided by a <see cref="Loader"/>.</remarks>
    //public ICollection<PluginInfo> InstalledPlugins {
    //  get { return remoteLoader.InstalledPlugins; }
    //}

    ///// <summary>
    ///// Gets all disabled plugins.
    ///// </summary>
    ///// <remarks>This information is provided by a <see cref="Loader"/>.</remarks>
    //public ICollection<PluginInfo> DisabledPlugins {
    //  get { return remoteLoader.DisabledPlugins; }
    //}

    ///// <summary>
    ///// Gets all active plugins.
    ///// </summary>
    ///// <remarks>This information is provided by a <see cref="Loader"/>.</remarks>
    //public ICollection<PluginInfo> ActivePlugins {
    //  get { return remoteLoader.ActivePlugins; }
    //}

    //private ICollection<PluginInfo> loadedPlugins;
    ///// <summary>
    ///// Gets or (internally) sets the loaded plugins.
    ///// </summary>
    //public ICollection<PluginInfo> LoadedPlugins {
    //  get { return loadedPlugins; }
    //  internal set { loadedPlugins = value; }
    //}

    private List<PluginDescription> plugins;
    //public IEnumerable<PluginDescription> Plugins {
    //  get { return plugins; }
    //}

    private List<ApplicationDescription> applications;
    /// <summary>
    /// Gets all installed applications.
    /// </summary>
    public IEnumerable<ApplicationDescription> Applications {
      get { return applications; }
    }

    /// <summary>
    /// Determines installed plugins and checks if all plugins are loadable.
    /// </summary>
    public void Initialize() {
      NotifyListeners(PluginManagerAction.Initializing, "-");
      AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
      setup.PrivateBinPath = pluginDir;
      AppDomain pluginDomain = AppDomain.CreateDomain("plugin domain", null, setup);
      Loader remoteLoader = (Loader)pluginDomain.CreateInstanceAndUnwrap("HeuristicLab.PluginInfraStructure.Manager", "HeuristicLab.PluginInfrastructure.Manager.Loader");
      remoteLoader.PluginDir = pluginDir;
      remoteLoader.PluginAction += delegate(object sender, PluginManagerActionEventArgs args) { if (Action != null) Action(this, args); };
      remoteLoader.Init();
      NotifyListeners(PluginManagerAction.Initialized, "-");

      plugins = new List<PluginDescription>(remoteLoader.Plugins);
      applications = new List<ApplicationDescription>(remoteLoader.Applications);

      // discard the AppDomain that was used for plugin discovery
      UnloadAppDomain(pluginDomain);
    }

    private void UnloadAppDomain(AppDomain appDomain) {
      AppDomain.Unload(appDomain);

      // set all loaded plugins back to enabled
      foreach (var pluginDescription in plugins)
        pluginDescription.Unload();
    }


    ///// <summary>
    ///// Creates a new AppDomain with all plugins preloaded.
    ///// </summary>
    ///// <param name="friendlyName">Name of the new AppDomain</param>
    ///// <returns>the new AppDomain with all plugins preloaded.</returns>
    //public AppDomain CreateAndInitAppDomain(string friendlyName) {

    //  return applicationDomain;
    //}

    /// <summary>
    /// Creates a separate AppDomain.
    /// Loads all active plugin assemblies and starts the application in the new AppDomain via a PluginRunner instance activated in the new AppDomain
    /// </summary>
    /// <param name="appInfo">application to run</param>
    public void Run(ApplicationDescription appInfo) {
      // create a separate AppDomain for the application
      // initialize the static ApplicationManager in the AppDomain
      // and remotely tell it to start the application

      NotifyListeners(PluginManagerAction.ApplicationStart, appInfo.Name);
      AppDomain applicationDomain = null;
      try {
        AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
        setup.PrivateBinPath = pluginDir;
        applicationDomain = AppDomain.CreateDomain(appInfo.Name, null, setup);
        ApplicationManager applicationManager =
          (ApplicationManager)applicationDomain.CreateInstanceAndUnwrap("HeuristicLab.PluginInfraStructure.Manager", "HeuristicLab.PluginInfrastructure.Manager.ApplicationManager");
        //applicationManager.PluginAction += delegate(object sender, PluginManagerActionEventArgs args) { if (Action != null) Action(this, args); };
        applicationManager.PrepareApplicationDomain(
          new List<IApplicationDescription>(applications.Cast<IApplicationDescription>()),
          new List<IPluginDescription>(plugins.Cast<IPluginDescription>()));
        NotifyListeners(PluginManagerAction.Initialized, "All plugins");
        applicationManager.Run(appInfo);
      }
      finally {
        // make sure domain is unloaded in all cases
        if (applicationDomain != null) AppDomain.Unload(applicationDomain);
      }
    }

    ///// <summary>
    ///// Creates a new AppDomain with all plugins preloaded and Sandboxing capability.
    ///// </summary>
    ///// <param name="assembly">Assembly reference</param>
    ///// <returns>the strongname of the assembly</returns>
    //private StrongName CreateStrongName(Assembly assembly) {
    //  if (assembly == null)
    //    throw new ArgumentNullException("assembly");

    //  AssemblyName assemblyName = assembly.GetName();
    //  Debug.Assert(assemblyName != null, "Could not get assembly name");

    //  // get the public key blob
    //  byte[] publicKey = assemblyName.GetPublicKey();
    //  if (publicKey == null || publicKey.Length == 0)
    //    throw new InvalidOperationException("Assembly is not strongly named");

    //  StrongNamePublicKeyBlob keyBlob = new StrongNamePublicKeyBlob(publicKey);

    //  // and create the StrongName
    //  return new StrongName(keyBlob, assemblyName.Name, assemblyName.Version);
    //}

    //public AppDomain CreateAndInitAppDomainWithSandbox(string friendlyName, bool sandboxed, Type jobType, ICollection<byte[]> assemblyFiles) {
    //  PermissionSet pset;



    //  //DiscoveryService dService = new DiscoveryService();
    //  //get the declaring plugin of the job
    //  //PluginInfo jobPlugin = dService.GetDeclaringPlugin(jobType);

    //  //get all the plugins that have dependencies with the jobplugin
    //  //List<PluginInfo> depPlugins = GetDependentPluginsRec(jobPlugin);
    //  //insert all jobs into one list
    //  //depPlugins.Add(jobPlugin);

    //  if (sandboxed) {
    //    pset = new PermissionSet(PermissionState.None);
    //    pset.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
    //    pset.AddPermission(new ReflectionPermission(PermissionState.Unrestricted));
    //    FileIOPermission fPerm = new FileIOPermission(PermissionState.None);

    //    /*foreach (PluginInfo plugin in depPlugins) {
    //        foreach(String assemblies in plugin.Assemblies)
    //          fPerm.AddPathList(FileIOPermissionAccess.AllAccess, assemblies);
    //    }

    //    pset.AddPermission(fPerm);*/

    //  } else {
    //    pset = new PermissionSet(PermissionState.Unrestricted);
    //  }
    //  AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
    //  setup.PrivateBinPath = pluginDir;
    //  setup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
    //  AppDomain applicationDomain = AppDomain.CreateDomain(friendlyName, AppDomain.CurrentDomain.Evidence, setup, pset, CreateStrongName(Assembly.GetExecutingAssembly()));
    //  Runner remoteRunner = (Runner)applicationDomain.CreateInstanceAndUnwrap(typeof(Runner).Assembly.GetName().Name, typeof(Runner).FullName);
    //  NotifyListeners("Initializing", "All plugins");

    //  if (assemblyFiles != null && assemblyFiles.Count > 0)
    //    remoteRunner.LoadAssemblies(assemblyFiles);

    //  //if (depPlugins != null && depPlugins.Count > 0) {        
    //  //remoteRunner.LoadPlugins(ActivePlugins);
    //  //}
    //  NotifyListeners("Initialized", "All plugins");
    //  return applicationDomain;
    //}

    ///// <summary>
    ///// Calculates a set of plugins that directly or transitively depend on the plugin given in the argument.
    ///// </summary>
    ///// <param name="pluginInfo">The plugin the other depend on.</param>
    ///// <returns>a list of plugins that are directly of transitively dependent.</returns>
    //public List<PluginDescription> GetDependentPlugins(PluginDescription pluginInfo) {
    //  List<PluginDescription> mergedList = new List<PluginDescription>();
    //  foreach (PluginDescription plugin in Plugins) {
    //    if (plugin.Dependencies.Contains(pluginInfo)) {
    //      if (!mergedList.Contains(plugin)) {
    //        mergedList.Add(plugin);
    //      }
    //      // for each of the dependent plugins add the list of transitively dependent plugins
    //      // make sure that only one entry for each plugin is added to the merged list
    //      foreach (PluginDescription dependentPlugin in GetDependentPlugins(plugin)) {
    //        if (!mergedList.Contains(dependentPlugin)) {
    //          mergedList.Add(dependentPlugin);
    //        }
    //      }
    //    }
    //  }
    //  return mergedList;
    //}

    private void NotifyListeners(PluginManagerAction action, string text) {
      if (Action != null) {
        Action(this, new PluginManagerActionEventArgs(text, action));
      }
    }
  }
}