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

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

    private string pluginDir;

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

    private List<PluginDescription> 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 DiscoverAndCheckPlugins() {
      FireAction("Initializing", "PluginInfrastructure");
      AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
      setup.PrivateBinPath = pluginDir;
      AppDomain pluginDomain = null;
      try {
        pluginDomain = AppDomain.CreateDomain("plugin domain", null, setup);
        Loader remoteLoader = (Loader)pluginDomain.CreateInstanceAndUnwrap("HeuristicLab.PluginInfraStructure.Manager", "HeuristicLab.PluginInfrastructure.Manager.Loader");
        remoteLoader.PluginDir = pluginDir;
        // forward all events from the remoteLoader to listeners
        remoteLoader.PluginLoaded += delegate(object sender, PluginInfrastructureEventArgs args) { FireAction(args.Action, args.Entity); };
        this.plugins = new List<PluginDescription>(remoteLoader.Plugins);
        this.applications = new List<ApplicationDescription>(remoteLoader.Applications);
        FireAction("Initialized", "PluginInfrastructure");
      }
      finally {
        // discard the AppDomain that was used for plugin discovery
        UnloadAppDomain(pluginDomain);
      }
    }


    /// <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

      FireAction("Starting application", appInfo.Name);
      AppDomain applicationDomain = null;
      try {
        AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
        setup.PrivateBinPath = pluginDir;
        applicationDomain = AppDomain.CreateDomain(appInfo.Name, null, setup);
        DefaultApplicationManager applicationManager =
          (DefaultApplicationManager)applicationDomain.CreateInstanceAndUnwrap("HeuristicLab.PluginInfraStructure.Manager", "HeuristicLab.PluginInfrastructure.Manager.DefaultApplicationManager");
        applicationManager.PluginLoaded += applicationManager_PluginLoaded;
        applicationManager.PrepareApplicationDomain(
          new List<IApplicationDescription>(applications.Cast<IApplicationDescription>()),
          new List<IPluginDescription>(plugins.Cast<IPluginDescription>()));
        FireAction("Started application", appInfo.Name);
        applicationManager.Run(appInfo);
      }
      finally {
        // make sure domain is unloaded in all cases
        UnloadAppDomain(applicationDomain);
      }
    }

    void applicationManager_PluginLoaded(object sender, PluginInfrastructureEventArgs e) {
      // load the matching plugin description (
      PluginDescription desc = (PluginDescription)e.Entity;
      foreach (var myDesc in plugins) {
        if (myDesc.Equals(desc)) myDesc.Load();
      }
      FireAction(e.Action, e.Entity);
    }

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

      // TODO: Update plugin descriptions in all active AppDomains

      // unload all plugins
      foreach (var pluginDescription in plugins)
        pluginDescription.Unload();
    }

    private void FireAction(string action, object entity) {
      if (Action != null) {
        Action(this, new PluginInfrastructureEventArgs(action, entity));
      }
    }
  }
}