source: trunk/sources/HeuristicLab.PluginInfrastructure/PluginManager.cs @ 1655

Last change on this file since 1655 was 1655, checked in by kgrading, 12 years ago

added proper exception handling (#601)

File size: 13.2 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Security.Policy;
25using System.Reflection;
26using System.Diagnostics;
27using System.Security.Permissions;
28using System.Security;
29
30namespace HeuristicLab.PluginInfrastructure {
31
32  // must extend MarshalByRefObject because of event passing between Loader and PluginManager (each in it's own AppDomain)
33  /// <summary>
34  /// Class to manage different plugins.
35  /// </summary>
36  public class PluginManager : MarshalByRefObject {
37
38    // singleton: only one manager allowed in each AppDomain
39    private static PluginManager manager = new PluginManager();
40    /// <summary>
41    /// Gets the plugin manager (is a singleton).
42    /// </summary>
43    public static PluginManager Manager {
44      get { return manager; }
45    }
46
47    // singleton: only one control manager allowed in each applicatoin (i.e. AppDomain)
48    private static IControlManager controlManager;
49    /// <summary>
50    /// Gets or sets the control manager (is a singleton).
51    /// </summary>
52    public static IControlManager ControlManager {
53      get { return controlManager; }
54      set { controlManager = value; }
55    }
56
57    /// <summary>
58    /// Event handler for actions in the plugin manager.
59    /// </summary>
60    public event PluginManagerActionEventHandler Action;
61
62    // holds a proxy for the loader in the special AppDomain for PluginManagament
63    private Loader remoteLoader;
64    private AppDomain pluginDomain;
65    private string pluginDir;
66
67    // singleton pattern
68    private PluginManager() {
69      this.pluginDir = HeuristicLab.PluginInfrastructure.Properties.Settings.Default.PluginDir;
70    }
71
72    /// <summary>
73    /// Gets all installed plugins.
74    /// </summary>
75    /// <remarks>This information is provided by a <see cref="Loader"/>.</remarks>
76    public ICollection<PluginInfo> InstalledPlugins {
77      get { return remoteLoader.InstalledPlugins; }
78    }
79
80    /// <summary>
81    /// Gets all disabled plugins.
82    /// </summary>
83    /// <remarks>This information is provided by a <see cref="Loader"/>.</remarks>
84    public ICollection<PluginInfo> DisabledPlugins {
85      get { return remoteLoader.DisabledPlugins; }
86    }
87
88    /// <summary>
89    /// Gets all active plugins.
90    /// </summary>
91    /// <remarks>This information is provided by a <see cref="Loader"/>.</remarks>
92    public ICollection<PluginInfo> ActivePlugins {
93      get { return remoteLoader.ActivePlugins; }
94    }
95
96    /// <summary>
97    /// Gets all installed applications.
98    /// </summary>
99    /// <remarks>This information is provided by a <see cref="Loader"/>.</remarks>
100    public ICollection<ApplicationInfo> InstalledApplications {
101      get { return remoteLoader.InstalledApplications; }
102    }
103
104    private ICollection<PluginInfo> loadedPlugins;
105    /// <summary>
106    /// Gets or (internally) sets the loaded plugins.
107    /// </summary>
108    public ICollection<PluginInfo> LoadedPlugins {
109      get { return loadedPlugins; }
110      internal set { loadedPlugins = value; }
111    }
112
113    /// <summary>
114    /// Creates a dedicated AppDomain for loading all plugins and checking dependencies.
115    /// </summary>
116    public void Initialize() {
117      NotifyListeners(PluginManagerAction.Initializing, "-");
118      AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
119      setup.PrivateBinPath = pluginDir;
120      pluginDomain = AppDomain.CreateDomain("plugin domain", null, setup);
121      remoteLoader = (Loader)pluginDomain.CreateInstanceAndUnwrap("HeuristicLab.PluginInfraStructure", "HeuristicLab.PluginInfrastructure.Loader");
122      remoteLoader.PluginAction += delegate(object sender, PluginManagerActionEventArgs args) { if (Action != null) Action(this, args); };
123      remoteLoader.Init();
124      NotifyListeners(PluginManagerAction.Initialized, "-");
125    }
126
127    /// <summary>
128    /// Creates a separate AppDomain.
129    /// Loads all active plugin assemblies and starts the application in the new AppDomain via a PluginRunner instance activated in the new AppDomain
130    /// </summary>
131    /// <param name="appInfo">application to run</param>
132    public void Run(ApplicationInfo appInfo) {
133      // create a separate AppDomain for the application
134      // activate a PluginRunner instance in the application
135      // and remotely tell it to start the application
136
137      NotifyListeners(PluginManagerAction.Starting, appInfo.Name);
138      AppDomain applicationDomain = null;
139      try {
140        applicationDomain = CreateAndInitAppDomain(appInfo.Name);
141        Runner remoteRunner = (Runner)applicationDomain.CreateInstanceAndUnwrap(typeof(Runner).Assembly.GetName().Name, typeof(Runner).FullName);
142        remoteRunner.Run(appInfo);
143      }
144      finally {
145        // make sure domain is unloaded in all cases
146        if (applicationDomain != null) AppDomain.Unload(applicationDomain);
147      }
148    }
149
150    /// <summary>
151    /// Creates a new AppDomain with all plugins preloaded.
152    /// </summary>
153    /// <param name="friendlyName">Name of the new AppDomain</param>
154    /// <returns>the new AppDomain with all plugins preloaded.</returns>
155    public AppDomain CreateAndInitAppDomain(string friendlyName) {
156      AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
157      setup.PrivateBinPath = pluginDir;
158      AppDomain applicationDomain = AppDomain.CreateDomain(friendlyName, null, setup);
159      Runner remoteRunner = (Runner)applicationDomain.CreateInstanceAndUnwrap(typeof(Runner).Assembly.GetName().Name, typeof(Runner).FullName);
160      NotifyListeners(PluginManagerAction.Initializing, "All plugins");
161      if (remoteLoader != null) {
162        remoteRunner.LoadPlugins(remoteLoader.ActivePlugins);
163      } else if (LoadedPlugins != null && LoadedPlugins.Count > 0) {
164        remoteRunner.LoadPlugins(LoadedPlugins);
165      }
166      NotifyListeners(PluginManagerAction.Initialized, "All plugins");
167      return applicationDomain;
168    }
169
170    /// <summary>
171    /// Creates a new AppDomain with all plugins preloaded and Sandboxing capability.
172    /// </summary>
173    /// <param name="assembly">Assembly reference</param>
174    /// <returns>the strongname of the assembly</returns>
175    private StrongName CreateStrongName(Assembly assembly) {
176      if (assembly == null)
177        throw new ArgumentNullException("assembly");
178
179      AssemblyName assemblyName = assembly.GetName();
180      Debug.Assert(assemblyName != null, "Could not get assembly name");
181
182      // get the public key blob
183      byte[] publicKey = assemblyName.GetPublicKey();
184      if (publicKey == null || publicKey.Length == 0)
185        throw new InvalidOperationException("Assembly is not strongly named");
186
187      StrongNamePublicKeyBlob keyBlob = new StrongNamePublicKeyBlob(publicKey);
188
189      // and create the StrongName
190      return new StrongName(keyBlob, assemblyName.Name, assemblyName.Version);
191    }
192
193    public AppDomain CreateAndInitAppDomainWithSandbox(string friendlyName, bool sandboxed, Type jobType, ICollection<byte[]> assemblyFiles) {
194      PermissionSet pset;
195
196     
197
198      DiscoveryService dService = new DiscoveryService();
199      //get the declaring plugin of the job
200      PluginInfo jobPlugin = dService.GetDeclaringPlugin(jobType);
201
202      //get all the plugins that have dependencies with the jobplugin
203      List<PluginInfo> depPlugins = GetDependentPluginsRec(jobPlugin);
204      //insert all jobs into one list
205      depPlugins.Add(jobPlugin);
206     
207      if (sandboxed) {
208        pset = new PermissionSet(PermissionState.None);
209        pset.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
210        pset.AddPermission(new ReflectionPermission(PermissionState.Unrestricted));
211        FileIOPermission fPerm = new FileIOPermission(PermissionState.None);
212             
213        foreach (PluginInfo plugin in depPlugins) {
214            foreach(String assemblies in plugin.Assemblies)
215              fPerm.AddPathList(FileIOPermissionAccess.AllAccess, assemblies);
216        }
217       
218        pset.AddPermission(fPerm);
219
220      } else {
221        pset = new PermissionSet(PermissionState.Unrestricted);
222      }
223      AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
224      setup.PrivateBinPath = pluginDir;
225      setup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;     
226      AppDomain applicationDomain = AppDomain.CreateDomain(friendlyName, AppDomain.CurrentDomain.Evidence, setup, pset, CreateStrongName(Assembly.GetExecutingAssembly()));
227                     
228      Runner remoteRunner = (Runner)applicationDomain.CreateInstanceAndUnwrap(typeof(Runner).Assembly.GetName().Name, typeof(Runner).FullName);
229      NotifyListeners(PluginManagerAction.Initializing, "All plugins");
230
231      //if (assemblyFiles != null && assemblyFiles.Count > 0)
232      //  remoteRunner.LoadPlugins(assemblyFiles);
233     
234      if (depPlugins != null && depPlugins.Count > 0) {       
235        remoteRunner.LoadPlugins(depPlugins);
236      }
237      NotifyListeners(PluginManagerAction.Initialized, "All plugins");
238      return applicationDomain;
239    }
240
241    /// <summary>
242    /// Calculates a set of plugins that directly or transitively depend on the plugin given in the argument.
243    /// </summary>
244    /// <param name="pluginInfo">The plugin the other depend on.</param>
245    /// <returns>a list of plugins that are directly of transitively dependent.</returns>
246    public List<PluginInfo> GetDependentPlugins(PluginInfo pluginInfo) {
247      List<PluginInfo> mergedList = new List<PluginInfo>();
248      foreach (PluginInfo plugin in InstalledPlugins) {
249        if (plugin.Dependencies.Contains(pluginInfo)) {
250          if (!mergedList.Contains(plugin)) {
251            mergedList.Add(plugin);
252          }
253          // for each of the dependent plugins add the list of transitively dependent plugins
254          // make sure that only one entry for each plugin is added to the merged list
255          GetDependentPlugins(plugin).ForEach(delegate(PluginInfo dependentPlugin) {
256            if (!mergedList.Contains(dependentPlugin)) {
257              mergedList.Add(dependentPlugin);
258            }
259          });
260        }
261      }
262      return mergedList;
263    }
264
265
266    /// <summary>
267    /// Calculates a set of plugins that directly or transitively depend on the plugin given in the argument.
268    /// </summary>
269    /// <param name="pluginInfo">The plugin the other depend on.</param>
270    /// <returns>a list of plugins that are directly of transitively dependent.</returns>
271    public List<PluginInfo> GetDependentPluginsRec(PluginInfo pluginInfo) {
272      List<PluginInfo> mergedList = new List<PluginInfo>();
273      //Bugfix the hell out of this...
274      //Bugfixed the hell out of this...
275      foreach (PluginInfo info in pluginInfo.Dependencies) {
276        if (!mergedList.Contains(info)) {
277          mergedList.Add(info);
278          AddDependenciesRecursive(info, mergedList);       
279        }       
280      }
281      return mergedList;
282    }
283
284    private void AddDependenciesRecursive(PluginInfo info, List<PluginInfo> mergedList) {
285      //if we've already processed this element => STOP IT!
286      if(!mergedList.Contains(info)) {
287        mergedList.Add(info);
288        return;
289      }
290      foreach (PluginInfo depinfo in info.Dependencies)
291        AddDependenciesRecursive(depinfo, mergedList);       
292    }
293
294    /// <summary>
295    /// Unloads all plugins.
296    /// </summary>
297    public void UnloadAllPlugins() {
298      AppDomain.Unload(pluginDomain);
299    }
300
301    /// <summary>
302    /// Loads all plugins.
303    /// </summary>
304    public void LoadAllPlugins() {
305      Initialize();
306    }
307
308    /// <inheritdoc cref="Loader.OnDelete"/>
309    public void OnDelete(PluginInfo pluginInfo) {
310      remoteLoader.OnDelete(pluginInfo);
311    }
312
313    /// <inheritdoc cref="Loader.OnInstall"/>
314    public void OnInstall(PluginInfo pluginInfo) {
315      remoteLoader.OnInstall(pluginInfo);
316    }
317
318    /// <inheritdoc cref="Loader.OnPreUpdate"/>
319    public void OnPreUpdate(PluginInfo pluginInfo) {
320      remoteLoader.OnPreUpdate(pluginInfo);
321    }
322
323    /// <inheritdoc cref="Loader.OnPostUpdate"/>
324    public void OnPostUpdate(PluginInfo pluginInfo) {
325      remoteLoader.OnPostUpdate(pluginInfo);
326    }
327
328    private void NotifyListeners(PluginManagerAction action, string text) {
329      if (Action != null) {
330        Action(this, new PluginManagerActionEventArgs(text, action));
331      }
332    }
333  }
334}
Note: See TracBrowser for help on using the repository browser.