source: trunk/sources/HeuristicLab.PluginInfrastructure/Manager/PluginManager.cs @ 2724

#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>
  internal sealed class PluginManager : MarshalByRefObject {
    /// <summary>
    /// Event handler for actions in the plugin manager.
    /// </summary>
    internal event EventHandler<PluginInfrastructureEventArgs> Action;

    private string pluginDir;

    private List<PluginDescription> plugins;
    /// <summary>
    /// Gets all installed plugins.
    /// </summary>
    internal IEnumerable<PluginDescription> Plugins {
      get { return plugins; }
    }

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

    private object locker = new object();
    private bool initialized;

    internal PluginManager(string pluginDir) {
      this.pluginDir = pluginDir;
      plugins = new List<PluginDescription>();
      applications = new List<ApplicationDescription>();
      Reset();
    }

    internal void Reset() {
      initialized = false;
      if (plugins != null && plugins.Any(x => x.PluginState == PluginState.Loaded)) throw new InvalidOperationException("Reset() is not allowed while applications are active.");
      plugins.Clear();
      applications.Clear();
    }

    /// <summary>
    /// Determines installed plugins and checks if all plugins are loadable.
    /// </summary>
    internal void DiscoverAndCheckPlugins() {
      OnAction(new PluginInfrastructureEventArgs("Initializing", "PluginInfrastructure"));
      AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
      setup.PrivateBinPath = pluginDir;
      AppDomain pluginDomain = null;
      try {
        pluginDomain = AppDomain.CreateDomain("plugin domain", null, setup);
        Type pluginValidatorType = typeof(PluginValidator);
        PluginValidator remoteValidator = (PluginValidator)pluginDomain.CreateInstanceAndUnwrap(pluginValidatorType.Assembly.FullName, pluginValidatorType.FullName, true, BindingFlags.NonPublic | BindingFlags.Instance, null, null, null, null, null);
        remoteValidator.PluginDir = pluginDir;
        // forward all events from the remoteValidator to listeners
        remoteValidator.PluginLoaded +=
          delegate(object sender, PluginInfrastructureEventArgs e) {
            OnAction(e);
          };
        // get list of plugins and applications from the validator
        plugins.Clear(); applications.Clear();
        plugins.AddRange(remoteValidator.Plugins);
        applications.AddRange(remoteValidator.Applications);
        OnAction(new PluginInfrastructureEventArgs("Initialized", "PluginInfrastructure"));
      }
      finally {
        // discard the AppDomain that was used for plugin discovery
        AppDomain.Unload(pluginDomain);
        // unload all plugins
        foreach (var pluginDescription in plugins.Where(x => x.PluginState == PluginState.Loaded))
          pluginDescription.Unload();
        initialized = true;
      }
    }


    /// <summary>
    /// Starts an application in a separate AppDomain.
    /// Loads all enabled plugins and starts the application via an ApplicationManager instance activated in the new AppDomain.
    /// </summary>
    /// <param name="appInfo">application to run</param>
    internal void Run(ApplicationDescription appInfo) {
      if (!initialized) throw new InvalidOperationException("PluginManager is not initialized. DiscoverAndCheckPlugins() must be called before Run()");
      // create a separate AppDomain for the application
      // initialize the static ApplicationManager in the AppDomain
      // and remotely tell it to start the application

      OnAction(new PluginInfrastructureEventArgs("Starting application", appInfo));
      AppDomain applicationDomain = null;
      try {
        AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
        setup.PrivateBinPath = pluginDir;
        applicationDomain = AppDomain.CreateDomain(appInfo.Name, null, setup);
        Type applicationManagerType = typeof(ApplicationManager);
        ApplicationManager applicationManager =
          (ApplicationManager)applicationDomain.CreateInstanceAndUnwrap(applicationManagerType.Assembly.FullName, applicationManagerType.FullName, true, BindingFlags.NonPublic | BindingFlags.Instance, null, null, null, null, null);
        applicationManager.PluginLoaded += applicationManager_PluginLoaded;
        applicationManager.PluginUnloaded += applicationManager_PluginUnloaded;
        applicationManager.PrepareApplicationDomain(applications, plugins);
        OnAction(new PluginInfrastructureEventArgs("Started application", appInfo));
        applicationManager.Run(appInfo);
      }
      finally {
        // make sure domain is unloaded in all cases
        AppDomain.Unload(applicationDomain);
      }
    }

    private void applicationManager_PluginUnloaded(object sender, PluginInfrastructureEventArgs e) {
      // unload the matching plugin description (
      PluginDescription desc = (PluginDescription)e.Entity;

      // access to plugin descriptions has to be synchronized because multiple applications 
      // can be started or stopped at the same time
      lock (locker) {
        plugins.First(x => x.Equals(desc)).Unload();
      }
      OnAction(new PluginInfrastructureEventArgs(e.Action, e.Entity));
    }

    private void applicationManager_PluginLoaded(object sender, PluginInfrastructureEventArgs e) {
      // load the matching plugin description (
      PluginDescription desc = (PluginDescription)e.Entity;
      // access to plugin descriptions has to be synchronized because multiple applications 
      // can be started or stopped at the same time
      lock (locker) {
        plugins.First(x => x.Equals(desc)).Load();
      }
      OnAction(new PluginInfrastructureEventArgs(e.Action, e.Entity));
    }

    private void OnAction(PluginInfrastructureEventArgs e) {
      if (Action != null) {
        Action(this, e);
      }
    }

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