Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.PluginInfrastructure/3.3/Manager/PluginValidator.cs @ 10771

Last change on this file since 10771 was 9456, checked in by swagner, 12 years ago

Updated copyright year and added some missing license headers (#1889)

File size: 31.6 KB
RevLine 
[2]1#region License Information
2/* HeuristicLab
[9456]3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[2]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.IO;
[2481]25using System.Linq;
[4068]26using System.Reflection;
[2527]27using System.Security;
[4068]28using System.Text;
[2]29
[2481]30
31namespace HeuristicLab.PluginInfrastructure.Manager {
[2503]32  /// <summary>
33  /// Discovers all installed plugins in the plugin directory. Checks correctness of plugin meta-data and if
34  /// all plugin files are available and checks plugin dependencies.
35  /// </summary>
36  internal sealed class PluginValidator : MarshalByRefObject {
[2750]37    // private class to store plugin dependency declarations while reflecting over plugins
38    private class PluginDependency {
39      public string Name { get; private set; }
40      public Version Version { get; private set; }
41
42      public PluginDependency(string name, Version version) {
43        this.Name = name;
44        this.Version = version;
45      }
46    }
47
48
[2489]49    internal event EventHandler<PluginInfrastructureEventArgs> PluginLoaded;
[2]50
[2750]51    private Dictionary<PluginDescription, IEnumerable<PluginDependency>> pluginDependencies;
[2]52
[2481]53    private List<ApplicationDescription> applications;
54    internal IEnumerable<ApplicationDescription> Applications {
[2]55      get {
[2503]56        if (string.IsNullOrEmpty(PluginDir)) throw new InvalidOperationException("PluginDir is not set.");
[2497]57        if (applications == null) DiscoverAndCheckPlugins();
[2481]58        return applications;
[2]59      }
60    }
61
[2481]62    private IEnumerable<PluginDescription> plugins;
63    internal IEnumerable<PluginDescription> Plugins {
[2]64      get {
[2503]65        if (string.IsNullOrEmpty(PluginDir)) throw new InvalidOperationException("PluginDir is not set.");
[2497]66        if (plugins == null) DiscoverAndCheckPlugins();
[2481]67        return plugins;
[29]68      }
69    }
70
[2504]71    internal string PluginDir { get; set; }
[2]72
[2504]73    internal PluginValidator() {
[2750]74      this.pluginDependencies = new Dictionary<PluginDescription, IEnumerable<PluginDependency>>();
[2488]75
[2497]76      // ReflectionOnlyAssemblyResolveEvent must be handled because we load assemblies from the plugin path
77      // (which is not listed in the default assembly lookup locations)
[2488]78      AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += ReflectionOnlyAssemblyResolveEventHandler;
[2]79    }
80
[2690]81    private Dictionary<string, Assembly> reflectionOnlyAssemblies = new Dictionary<string, Assembly>();
[2488]82    private Assembly ReflectionOnlyAssemblyResolveEventHandler(object sender, ResolveEventArgs args) {
[2690]83      if (reflectionOnlyAssemblies.ContainsKey(args.Name))
84        return reflectionOnlyAssemblies[args.Name];
85      else
86        return Assembly.ReflectionOnlyLoad(args.Name);
[2488]87    }
[2]88
[2488]89
[2]90    /// <summary>
91    /// Init first clears all internal datastructures (including plugin lists)
92    /// 1. All assemblies in the plugins directory are loaded into the reflection only context.
[2503]93    /// 2. The validator checks if all necessary files for each plugin are available.
[2536]94    /// 3. The validator checks if all declared plugin assemblies can be loaded.
95    /// 4. The validator builds the tree of plugin descriptions (dependencies)
96    /// 5. The validator checks if there are any cycles in the plugin dependency graph and disables plugin with circular dependencies
97    /// 6. The validator checks for each plugin if any dependency is disabled.
98    /// 7. All plugins that are not disabled are loaded into the execution context.
99    /// 8. Each loaded plugin (all assemblies) is searched for a types that implement IPlugin
[2481]100    ///    then one instance of each IPlugin type is activated and the OnLoad hook is called.
[2536]101    /// 9. All types implementing IApplication are discovered
[2]102    /// </summary>
[2503]103    internal void DiscoverAndCheckPlugins() {
[2]104      pluginDependencies.Clear();
105
[2527]106      IEnumerable<Assembly> reflectionOnlyAssemblies = ReflectionOnlyLoadDlls(PluginDir);
[2481]107      IEnumerable<PluginDescription> pluginDescriptions = GatherPluginDescriptions(reflectionOnlyAssemblies);
108      CheckPluginFiles(pluginDescriptions);
[2]109
[2536]110      // check if all plugin assemblies can be loaded
[2527]111      CheckPluginAssemblies(pluginDescriptions);
112
[2481]113      // a full list of plugin descriptions is available now we can build the dependency tree
114      BuildDependencyTree(pluginDescriptions);
115
[2536]116      // check for dependency cycles
117      CheckPluginDependencyCycles(pluginDescriptions);
118
[5628]119      // 1st time recursively check if all necessary plugins are available and not disabled
120      // disable plugins with missing or disabled dependencies
121      // to prevent that plugins with missing dependencies are loaded into the execution context
122      // in the next step
[2481]123      CheckPluginDependencies(pluginDescriptions);
124
[4534]125      // test full loading (in contrast to reflection only loading) of plugins
126      // disables plugins that are not loaded correctly
127      CheckExecutionContextLoad(pluginDescriptions);
128
[5628]129      // 2nd time recursively check if all necessary plugins have been loaded successfully and not disabled
130      // disable plugins with for which dependencies could not be loaded successfully
131      CheckPluginDependencies(pluginDescriptions);
132
[2536]133      // mark all plugins as enabled that were not disabled in CheckPluginFiles, CheckPluginAssemblies,
[4534]134      // CheckCircularDependencies, CheckPluginDependencies and CheckExecutionContextLoad
[2488]135      foreach (var desc in pluginDescriptions)
136        if (desc.PluginState != PluginState.Disabled)
137          desc.Enable();
138
[4534]139      // load the enabled plugins
[2481]140      LoadPlugins(pluginDescriptions);
141
142      plugins = pluginDescriptions;
[5631]143      DiscoverApplications(pluginDescriptions);
[2481]144    }
145
[5631]146    private void DiscoverApplications(IEnumerable<PluginDescription> pluginDescriptions) {
[2481]147      applications = new List<ApplicationDescription>();
[5631]148      foreach (IApplication application in GetApplications(pluginDescriptions)) {
[2504]149        Type appType = application.GetType();
150        ApplicationAttribute attr = (from x in appType.GetCustomAttributes(typeof(ApplicationAttribute), false)
151                                     select (ApplicationAttribute)x).Single();
[2481]152        ApplicationDescription info = new ApplicationDescription();
[5631]153        PluginDescription declaringPlugin = GetDeclaringPlugin(appType, pluginDescriptions);
[2]154        info.Name = application.Name;
[3178]155        info.Version = declaringPlugin.Version;
[2]156        info.Description = application.Description;
[2504]157        info.AutoRestart = attr.RestartOnErrors;
158        info.DeclaringAssemblyName = appType.Assembly.GetName().Name;
159        info.DeclaringTypeName = appType.Namespace + "." + application.GetType().Name;
[2]160
[29]161        applications.Add(info);
[2]162      }
163    }
164
[5631]165    private static IEnumerable<IApplication> GetApplications(IEnumerable<PluginDescription> pluginDescriptions) {
[2488]166      return from asm in AppDomain.CurrentDomain.GetAssemblies()
167             from t in asm.GetTypes()
168             where typeof(IApplication).IsAssignableFrom(t) &&
169               !t.IsAbstract && !t.IsInterface && !t.HasElementType
[5631]170             where GetDeclaringPlugin(t, pluginDescriptions).PluginState != PluginState.Disabled
[2488]171             select (IApplication)Activator.CreateInstance(t);
172    }
173
[2690]174    private IEnumerable<Assembly> ReflectionOnlyLoadDlls(string baseDir) {
[2]175      List<Assembly> assemblies = new List<Assembly>();
[2527]176      // recursively load .dll files in subdirectories
177      foreach (string dirName in Directory.GetDirectories(baseDir)) {
178        assemblies.AddRange(ReflectionOnlyLoadDlls(dirName));
179      }
[2481]180      // try to load each .dll file in the plugin directory into the reflection only context
[5652]181      foreach (string filename in Directory.GetFiles(baseDir, "*.dll").Union(Directory.GetFiles(baseDir, "*.exe"))) {
[535]182        try {
[2690]183          Assembly asm = Assembly.ReflectionOnlyLoadFrom(filename);
184          RegisterLoadedAssembly(asm);
185          assemblies.Add(asm);
[1229]186        }
[2503]187        catch (BadImageFormatException) { } // just ignore the case that the .dll file is not a CLR assembly (e.g. a native dll)
[2527]188        catch (FileLoadException) { }
189        catch (SecurityException) { }
[3081]190        catch (ReflectionTypeLoadException) { } // referenced assemblies are missing
[2]191      }
192      return assemblies;
193    }
194
[2527]195    /// <summary>
196    /// Checks if all plugin assemblies can be loaded. If an assembly can't be loaded the plugin is disabled.
197    /// </summary>
198    /// <param name="pluginDescriptions"></param>
199    private void CheckPluginAssemblies(IEnumerable<PluginDescription> pluginDescriptions) {
200      foreach (var desc in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {
201        try {
[2779]202          var missingAssemblies = new List<string>();
[2690]203          foreach (var asmLocation in desc.AssemblyLocations) {
204            // the assembly must have been loaded in ReflectionOnlyDlls
205            // so we simply determine the name of the assembly and try to find it in the cache of loaded assemblies
206            var asmName = AssemblyName.GetAssemblyName(asmLocation);
207            if (!reflectionOnlyAssemblies.ContainsKey(asmName.FullName)) {
[2779]208              missingAssemblies.Add(asmName.FullName);
[2690]209            }
[2527]210          }
[2779]211          if (missingAssemblies.Count > 0) {
212            StringBuilder errorStrBuiler = new StringBuilder();
213            errorStrBuiler.AppendLine("Missing assemblies:");
214            foreach (string missingAsm in missingAssemblies) {
215              errorStrBuiler.AppendLine(missingAsm);
216            }
217            desc.Disable(errorStrBuiler.ToString());
218          }
[2527]219        }
[2779]220        catch (BadImageFormatException ex) {
[2527]221          // disable the plugin
[2779]222          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "BadImageFormatException: " + ex.Message);
[2527]223        }
[2779]224        catch (FileNotFoundException ex) {
[2527]225          // disable the plugin
[2779]226          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "FileNotFoundException: " + ex.Message);
[2527]227        }
[2779]228        catch (FileLoadException ex) {
[2527]229          // disable the plugin
[2779]230          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "FileLoadException: " + ex.Message);
[2527]231        }
[2779]232        catch (ArgumentException ex) {
[2527]233          // disable the plugin
[2779]234          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "ArgumentException: " + ex.Message);
[2527]235        }
[2779]236        catch (SecurityException ex) {
[2527]237          // disable the plugin
[2779]238          desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "SecurityException: " + ex.Message);
[2527]239        }
240      }
241    }
242
243
[2481]244    // find all types implementing IPlugin in the reflectionOnlyAssemblies and create a list of plugin descriptions
245    // the dependencies in the plugin descriptions are not yet set correctly because we need to create
246    // the full list of all plugin descriptions first
247    private IEnumerable<PluginDescription> GatherPluginDescriptions(IEnumerable<Assembly> assemblies) {
248      List<PluginDescription> pluginDescriptions = new List<PluginDescription>();
[1229]249      foreach (Assembly assembly in assemblies) {
[2]250        // GetExportedTypes throws FileNotFoundException when a referenced assembly
251        // of the current assembly is missing.
252        try {
[2527]253          // if there is a type that implements IPlugin
254          // use AssemblyQualifiedName to compare the types because we can't directly
255          // compare ReflectionOnly types and execution types
256          var assemblyPluginDescriptions = from t in assembly.GetExportedTypes()
257                                           where !t.IsAbstract && t.GetInterfaces().Any(x => x.AssemblyQualifiedName == typeof(IPlugin).AssemblyQualifiedName)
258                                           select GetPluginDescription(t);
259          pluginDescriptions.AddRange(assemblyPluginDescriptions);
[1229]260        }
[2497]261        // ignore exceptions. Just don't yield a plugin description when an exception is thrown
[2489]262        catch (FileNotFoundException) {
[1229]263        }
[2489]264        catch (FileLoadException) {
[2]265        }
[2489]266        catch (InvalidPluginException) {
[1395]267        }
[3508]268        catch (TypeLoadException) {
269        }
[3547]270        catch (MissingMemberException) {
271        }
[2]272      }
[2481]273      return pluginDescriptions;
[2]274    }
275
276    /// <summary>
277    /// Extracts plugin information for this type.
278    /// Reads plugin name, list and type of files and dependencies of the plugin. This information is necessary for
279    /// plugin dependency checking before plugin activation.
280    /// </summary>
[3046]281    /// <param name="pluginType"></param>
[2481]282    private PluginDescription GetPluginDescription(Type pluginType) {
[2]283
[2763]284      string pluginName, pluginDescription, pluginVersion;
[2778]285      string contactName, contactAddress;
[2763]286      GetPluginMetaData(pluginType, out pluginName, out pluginDescription, out pluginVersion);
[2778]287      GetPluginContactMetaData(pluginType, out contactName, out contactAddress);
[2763]288      var pluginFiles = GetPluginFilesMetaData(pluginType);
289      var pluginDependencies = GetPluginDependencyMetaData(pluginType);
290
[29]291      // minimal sanity check of the attribute values
[2517]292      if (!string.IsNullOrEmpty(pluginName) &&
[2778]293          pluginFiles.Count() > 0 &&                                 // at least one file
294          pluginFiles.Any(f => f.Type == PluginFileType.Assembly)) { // at least one assembly
[2481]295        // create a temporary PluginDescription that contains the attribute values
296        PluginDescription info = new PluginDescription();
[29]297        info.Name = pluginName;
[2513]298        info.Description = pluginDescription;
[2750]299        info.Version = new Version(pluginVersion);
[2778]300        info.ContactName = contactName;
301        info.ContactEmail = contactAddress;
[2815]302        info.LicenseText = ReadLicenseFiles(pluginFiles);
[2481]303        info.AddFiles(pluginFiles);
304
[29]305        this.pluginDependencies[info] = pluginDependencies;
[2481]306        return info;
[2]307      } else {
[2481]308        throw new InvalidPluginException("Invalid metadata in plugin " + pluginType.ToString());
[2]309      }
310    }
311
[4482]312    private static string ReadLicenseFiles(IEnumerable<PluginFile> pluginFiles) {
[2815]313      // combine the contents of all plugin files
314      var licenseFiles = from file in pluginFiles
315                         where file.Type == PluginFileType.License
316                         select file;
317      if (licenseFiles.Count() == 0) return string.Empty;
318      StringBuilder licenseTextBuilder = new StringBuilder();
319      licenseTextBuilder.AppendLine(File.ReadAllText(licenseFiles.First().Name));
320      foreach (var licenseFile in licenseFiles.Skip(1)) {
321        licenseTextBuilder.AppendLine().AppendLine(); // leave some empty space between multiple license files
322        licenseTextBuilder.AppendLine(File.ReadAllText(licenseFile.Name));
323      }
324      return licenseTextBuilder.ToString();
325    }
326
[2763]327    private static IEnumerable<PluginDependency> GetPluginDependencyMetaData(Type pluginType) {
328      // get all attributes of type PluginDependency
329      var dependencyAttributes = from attr in CustomAttributeData.GetCustomAttributes(pluginType)
330                                 where IsAttributeDataForType(attr, typeof(PluginDependencyAttribute))
331                                 select attr;
332
333      foreach (var dependencyAttr in dependencyAttributes) {
334        string name = (string)dependencyAttr.ConstructorArguments[0].Value;
335        Version version = new Version("0.0.0.0"); // default version
336        // check if version is given for now
337        // later when the constructor of PluginDependencyAttribute with only one argument has been removed
338        // this conditional can be removed as well
339        if (dependencyAttr.ConstructorArguments.Count > 1) {
340          try {
341            version = new Version((string)dependencyAttr.ConstructorArguments[1].Value); // might throw FormatException
342          }
343          catch (FormatException ex) {
344            throw new InvalidPluginException("Invalid version format of dependency " + name + " in plugin " + pluginType.ToString(), ex);
345          }
346        }
347        yield return new PluginDependency(name, version);
348      }
349    }
350
[2778]351    private static void GetPluginContactMetaData(Type pluginType, out string contactName, out string contactAddress) {
352      // get attribute of type ContactInformation if there is any
353      var contactInfoAttribute = (from attr in CustomAttributeData.GetCustomAttributes(pluginType)
354                                  where IsAttributeDataForType(attr, typeof(ContactInformationAttribute))
355                                  select attr).SingleOrDefault();
356
357      if (contactInfoAttribute != null) {
358        contactName = (string)contactInfoAttribute.ConstructorArguments[0].Value;
359        contactAddress = (string)contactInfoAttribute.ConstructorArguments[1].Value;
360      } else {
361        contactName = string.Empty;
362        contactAddress = string.Empty;
363      }
364    }
365
[2763]366    // not static because we need the PluginDir property
367    private IEnumerable<PluginFile> GetPluginFilesMetaData(Type pluginType) {
368      // get all attributes of type PluginFileAttribute
369      var pluginFileAttributes = from attr in CustomAttributeData.GetCustomAttributes(pluginType)
370                                 where IsAttributeDataForType(attr, typeof(PluginFileAttribute))
371                                 select attr;
372      foreach (var pluginFileAttribute in pluginFileAttributes) {
373        string pluginFileName = (string)pluginFileAttribute.ConstructorArguments[0].Value;
374        PluginFileType fileType = (PluginFileType)pluginFileAttribute.ConstructorArguments[1].Value;
375        yield return new PluginFile(Path.GetFullPath(Path.Combine(PluginDir, pluginFileName)), fileType);
376      }
377    }
378
379    private static void GetPluginMetaData(Type pluginType, out string pluginName, out string pluginDescription, out string pluginVersion) {
380      // there must be a single attribute of type PluginAttribute
381      var pluginMetaDataAttr = (from attr in CustomAttributeData.GetCustomAttributes(pluginType)
382                                where IsAttributeDataForType(attr, typeof(PluginAttribute))
383                                select attr).Single();
384
385      pluginName = (string)pluginMetaDataAttr.ConstructorArguments[0].Value;
386
387      // default description and version
388      pluginVersion = "0.0.0.0";
[3573]389      pluginDescription = string.Empty;
[2763]390      if (pluginMetaDataAttr.ConstructorArguments.Count() == 2) {
391        // if two arguments are given the second argument is the version
392        pluginVersion = (string)pluginMetaDataAttr.ConstructorArguments[1].Value;
393      } else if (pluginMetaDataAttr.ConstructorArguments.Count() == 3) {
394        // if three arguments are given the second argument is the description and the third is the version
395        pluginDescription = (string)pluginMetaDataAttr.ConstructorArguments[1].Value;
396        pluginVersion = (string)pluginMetaDataAttr.ConstructorArguments[2].Value;
397      }
398    }
399
[2504]400    private static bool IsAttributeDataForType(CustomAttributeData attributeData, Type attributeType) {
[2481]401      return attributeData.Constructor.DeclaringType.AssemblyQualifiedName == attributeType.AssemblyQualifiedName;
402    }
403
404    // builds a dependency tree of all plugin descriptions
405    // searches matching plugin descriptions based on the list of dependency names for each plugin
406    // and sets the dependencies in the plugin descriptions
407    private void BuildDependencyTree(IEnumerable<PluginDescription> pluginDescriptions) {
[6298]408      foreach (var desc in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {
[2779]409        var missingDependencies = new List<PluginDependency>();
[2750]410        foreach (var dependency in pluginDependencies[desc]) {
411          var matchingDescriptions = from availablePlugin in pluginDescriptions
[6298]412                                     where availablePlugin.PluginState != PluginState.Disabled
[2750]413                                     where availablePlugin.Name == dependency.Name
414                                     where IsCompatiblePluginVersion(availablePlugin.Version, dependency.Version)
415                                     select availablePlugin;
[2481]416          if (matchingDescriptions.Count() > 0) {
[2517]417            desc.AddDependency(matchingDescriptions.Single());
[2481]418          } else {
[2779]419            missingDependencies.Add(dependency);
[2481]420          }
[29]421        }
[2779]422        // no plugin description that matches the dependencies are available => plugin is disabled
423        if (missingDependencies.Count > 0) {
424          StringBuilder errorStrBuilder = new StringBuilder();
425          errorStrBuilder.AppendLine("Missing dependencies:");
426          foreach (var missingDep in missingDependencies) {
427            errorStrBuilder.AppendLine(missingDep.Name + " " + missingDep.Version);
428          }
429          desc.Disable(errorStrBuilder.ToString());
430        }
[2481]431      }
432    }
[37]433
[2750]434    /// <summary>
435    /// Checks if version <paramref name="available"/> is compatible to version <paramref name="requested"/>.
436    /// Note: the compatibility relation is not bijective.
437    /// Compatibility rules:
438    ///  * major and minor number must be the same
439    ///  * build and revision number of <paramref name="available"/> must be larger or equal to <paramref name="requested"/>.
440    /// </summary>
441    /// <param name="available">The available version which should be compared to <paramref name="requested"/>.</param>
442    /// <param name="requested">The requested version that must be matched.</param>
443    /// <returns></returns>
[4482]444    private static bool IsCompatiblePluginVersion(Version available, Version requested) {
[2750]445      // this condition must be removed after all plugins have been updated to declare plugin and dependency versions
446      if (
447        (requested.Major == 0 && requested.Minor == 0) ||
448        (available.Major == 0 && available.Minor == 0)) return true;
449      return
450        available.Major == requested.Major &&
451        available.Minor == requested.Minor &&
452        available.Build >= requested.Build &&
453        available.Revision >= requested.Revision;
454    }
455
[2536]456    private void CheckPluginDependencyCycles(IEnumerable<PluginDescription> pluginDescriptions) {
457      foreach (var plugin in pluginDescriptions) {
[2779]458        // if the plugin is not disabled check if there are cycles
[2536]459        if (plugin.PluginState != PluginState.Disabled && HasCycleInDependencies(plugin, plugin.Dependencies)) {
[2779]460          plugin.Disable("Dependency graph has a cycle.");
[2536]461        }
462      }
463    }
464
465    private bool HasCycleInDependencies(PluginDescription plugin, IEnumerable<PluginDescription> pluginDependencies) {
466      foreach (var dep in pluginDependencies) {
467        // if one of the dependencies is the original plugin we found a cycle and can return
468        // if the dependency is already disabled we can ignore the cycle detection because we will disable the plugin anyway
469        // if following one of the dependencies recursively leads to a cycle then we also return
470        if (dep == plugin || dep.PluginState == PluginState.Disabled || HasCycleInDependencies(plugin, dep.Dependencies)) return true;
471      }
472      // no cycle found and none of the direct and indirect dependencies is disabled
473      return false;
474    }
475
[2481]476    private void CheckPluginDependencies(IEnumerable<PluginDescription> pluginDescriptions) {
477      foreach (PluginDescription pluginDescription in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {
[2779]478        List<PluginDescription> disabledPlugins = new List<PluginDescription>();
479        if (IsAnyDependencyDisabled(pluginDescription, disabledPlugins)) {
480          StringBuilder errorStrBuilder = new StringBuilder();
481          errorStrBuilder.AppendLine("Dependencies are disabled:");
482          foreach (var disabledPlugin in disabledPlugins) {
483            errorStrBuilder.AppendLine(disabledPlugin.Name + " " + disabledPlugin.Version);
484          }
485          pluginDescription.Disable(errorStrBuilder.ToString());
[29]486        }
487      }
488    }
489
490
[2779]491    private bool IsAnyDependencyDisabled(PluginDescription descr, List<PluginDescription> disabledPlugins) {
492      if (descr.PluginState == PluginState.Disabled) {
493        disabledPlugins.Add(descr);
494        return true;
495      }
[2481]496      foreach (PluginDescription dependency in descr.Dependencies) {
[2779]497        IsAnyDependencyDisabled(dependency, disabledPlugins);
[2]498      }
[2779]499      return disabledPlugins.Count > 0;
[2]500    }
501
[4534]502    // tries to load all plugin assemblies into the execution context
503    // if an assembly of a plugin cannot be loaded the plugin is disabled
504    private void CheckExecutionContextLoad(IEnumerable<PluginDescription> pluginDescriptions) {
[2]505      // load all loadable plugins (all dependencies available) into the execution context
[2517]506      foreach (var desc in PluginDescriptionIterator.IterateDependenciesBottomUp(pluginDescriptions
[2488]507                                                                                .Where(x => x.PluginState != PluginState.Disabled))) {
[8193]508        // store the assembly names so that we can later retrieve the assemblies loaded in the appdomain by name
509        var assemblyNames = new List<string>();
[2690]510        foreach (string assemblyLocation in desc.AssemblyLocations) {
[5628]511          if (desc.PluginState != PluginState.Disabled) {
512            try {
[5629]513              string assemblyName = (from assembly in AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies()
514                                     where string.Equals(Path.GetFullPath(assembly.Location), Path.GetFullPath(assemblyLocation), StringComparison.CurrentCultureIgnoreCase)
515                                     select assembly.FullName).Single();
[5628]516              // now load the assemblies into the execution context 
517              // this can still lead to an exception
[5629]518              // even when the assemby was successfully loaded into the reflection only context before
[8193]519              // when loading the assembly using it's assemblyName it can be loaded from a different location than before (e.g. the GAC)
520              Assembly.Load(assemblyName);
521              assemblyNames.Add(assemblyName);
[5628]522            }
523            catch (BadImageFormatException) {
524              desc.Disable(Path.GetFileName(assemblyLocation) + " is not a valid assembly.");
525            }
526            catch (FileLoadException) {
527              desc.Disable("Can't load file " + Path.GetFileName(assemblyLocation));
528            }
529            catch (FileNotFoundException) {
530              desc.Disable("File " + Path.GetFileName(assemblyLocation) + " is missing.");
531            }
532            catch (SecurityException) {
533              desc.Disable("File " + Path.GetFileName(assemblyLocation) + " can't be loaded because of security constraints.");
534            }
[5629]535            catch (NotSupportedException ex) {
536              // disable the plugin
537              desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "NotSupportedException: " + ex.Message);
538            }
[2]539          }
540        }
[8193]541        desc.AssemblyNames = assemblyNames;
[2]542      }
543    }
[91]544
[4534]545    // assumes that all plugin assemblies have been loaded into the execution context via CheckExecutionContextLoad
546    // for each enabled plugin:
547    // calls OnLoad method of the plugin
548    // and raises the PluginLoaded event
549    private void LoadPlugins(IEnumerable<PluginDescription> pluginDescriptions) {
550      List<Assembly> assemblies = new List<Assembly>(AppDomain.CurrentDomain.GetAssemblies());
551      foreach (var desc in pluginDescriptions) {
552        if (desc.PluginState == PluginState.Enabled) {
553          // cannot use ApplicationManager to retrieve types because it is not yet instantiated
[8193]554          foreach (string assemblyName in desc.AssemblyNames) {
[4534]555            var asm = (from assembly in assemblies
[8193]556                       where assembly.FullName == assemblyName
[5628]557                       select assembly)
[8178]558                      .SingleOrDefault();
[8200]559            if (asm == null) throw new InvalidPluginException("Could not load assembly " + assemblyName + " for plugin " + desc.Name);
[4534]560            foreach (Type pluginType in asm.GetTypes()) {
561              if (typeof(IPlugin).IsAssignableFrom(pluginType) && !pluginType.IsAbstract && !pluginType.IsInterface && !pluginType.HasElementType) {
562                IPlugin plugin = (IPlugin)Activator.CreateInstance(pluginType);
563                plugin.OnLoad();
564                OnPluginLoaded(new PluginInfrastructureEventArgs(desc));
565              }
566            }
567          } // end foreach assembly in plugin
568          desc.Load();
569        }
570      } // end foreach plugin description
571    }
572
[2481]573    // checks if all declared plugin files are actually available and disables plugins with missing files
[2527]574    private void CheckPluginFiles(IEnumerable<PluginDescription> pluginDescriptions) {
[2481]575      foreach (PluginDescription desc in pluginDescriptions) {
[2779]576        IEnumerable<string> missingFiles;
577        if (ArePluginFilesMissing(desc, out missingFiles)) {
578          StringBuilder errorStrBuilder = new StringBuilder();
579          errorStrBuilder.AppendLine("Missing files:");
580          foreach (string fileName in missingFiles) {
581            errorStrBuilder.AppendLine(fileName);
582          }
583          desc.Disable(errorStrBuilder.ToString());
[29]584        }
[2]585      }
586    }
587
[2779]588    private bool ArePluginFilesMissing(PluginDescription pluginDescription, out IEnumerable<string> missingFiles) {
589      List<string> missing = new List<string>();
[2688]590      foreach (string filename in pluginDescription.Files.Select(x => x.Name)) {
[2527]591        if (!FileLiesInDirectory(PluginDir, filename) ||
592          !File.Exists(filename)) {
[2779]593          missing.Add(filename);
[2]594        }
595      }
[2779]596      missingFiles = missing;
597      return missing.Count > 0;
[2]598    }
599
[2527]600    private static bool FileLiesInDirectory(string dir, string fileName) {
601      var basePath = Path.GetFullPath(dir);
602      return Path.GetFullPath(fileName).StartsWith(basePath);
603    }
604
[5631]605    private static PluginDescription GetDeclaringPlugin(Type appType, IEnumerable<PluginDescription> plugins) {
[3178]606      return (from p in plugins
607              from asmLocation in p.AssemblyLocations
608              where Path.GetFullPath(asmLocation).Equals(Path.GetFullPath(appType.Assembly.Location), StringComparison.CurrentCultureIgnoreCase)
609              select p).Single();
610    }
611
[2690]612    // register assembly in the assembly cache for the ReflectionOnlyAssemblyResolveEvent
613    private void RegisterLoadedAssembly(Assembly asm) {
[6021]614      if (reflectionOnlyAssemblies.ContainsKey(asm.FullName) || reflectionOnlyAssemblies.ContainsKey(asm.GetName().Name)) {
615        throw new ArgumentException("An assembly with the name " + asm.GetName().Name + " has been registered already.", "asm");
616      }
[2690]617      reflectionOnlyAssemblies.Add(asm.FullName, asm);
618      reflectionOnlyAssemblies.Add(asm.GetName().Name, asm); // add short name
619    }
620
[2763]621    private void OnPluginLoaded(PluginInfrastructureEventArgs e) {
[2489]622      if (PluginLoaded != null)
[2503]623        PluginLoaded(this, e);
[2489]624    }
625
[1189]626    /// <summary>
[2497]627    /// Initializes the life time service with an infinite lease time.
[1189]628    /// </summary>
629    /// <returns><c>null</c>.</returns>
[2]630    public override object InitializeLifetimeService() {
631      return null;
632    }
633  }
634}
Note: See TracBrowser for help on using the repository browser.