Changeset 16984 for branches/2924_DotNetCoreMigration/HeuristicLab.PluginInfrastructure/3.3/Isolation

Timestamp:

05/24/19 12:28:29 (6 years ago)

Author:

dpiringe

Message:

#2924:

• merged projects HeuristicLab.PluginInfrastructure.Runner and HeuristicLab.PluginInfrastructure
• applied changes of code reviews (13.05.2019 and 22.05.2019) -> the old Runner is now RunnerHost and uses a Runner, which is executed on the child process
• added Type GetType(string) to IApplicationManager and implemented it for LightweightApplicationManager
• removed IActivator and IActivatorContext
• deleted unused types like PluginDescriptionIterator

Location:

branches/2924_DotNetCoreMigration/HeuristicLab.PluginInfrastructure/3.3/Isolation

Files:

• . (added)
• ApplicationRunner.cs (added)
• AssemblyInfo.cs (added)
• AssemblyLoader.cs (copied) (copied from branches/2924_DotNetCoreMigration/HeuristicLab.PluginInfrastructure.Runner/3.4/AssemblyLoader.cs) (6 diffs)
• DockerRunnerHost.cs (added)
• NativeRunnerHost.cs (added)
• PluginLoader.cs (copied) (copied from branches/2924_DotNetCoreMigration/HeuristicLab.PluginInfrastructure.Runner/3.4/PluginLoader.cs) (16 diffs)
• PluginLoaderFactory.cs (copied) (copied from branches/2924_DotNetCoreMigration/HeuristicLab.PluginInfrastructure.Runner/3.4/PluginLoaderFactory.cs) (1 diff)
• Runner.cs (added)
• RunnerHost.cs (added)
• RunnerJob.cs (added)

branches/2924_DotNetCoreMigration/HeuristicLab.PluginInfrastructure/3.3/Isolation/AssemblyLoader.cs

@@ -1 +1 @@
 using System;
-using System.Linq;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.Loader;
-using System.Runtime.Versioning;
-using System.Threading.Tasks;
 
-namespace HeuristicLab.PluginInfrastructure.Runner {
+namespace HeuristicLab.PluginInfrastructure {
 
+  /// <summary>
+  /// Class to load assemblies.
+  /// </summary>
   public class AssemblyLoader : IAssemblyLoader {
+    /// <summary>
+    /// Comparer for AssemblyNames.
+    /// </summary>
     private class AssemblyNameComparer : IEqualityComparer<AssemblyName> {
       private object concatProps(AssemblyName name) => name.FullName + name.Version.ToString();
@@ -17 +21 @@
     }
 
-    //https://github.com/dotnet/coreclr/blob/master/Documentation/design-docs/assemblyloadcontext.md
-    private class ALC : AssemblyLoadContext {
-      private Dictionary<AssemblyName, Assembly> loadedAssemblies = new Dictionary<AssemblyName, Assembly>(new AssemblyNameComparer());
-      private string BasePath { get; set; }
-      public ALC(string basePath) { BasePath = basePath; }
-      protected override Assembly Load(AssemblyName assemblyName) {
-        if (loadedAssemblies.ContainsKey(assemblyName)) return loadedAssemblies[assemblyName];
+    #region Vars
+    private readonly IList<Assembly> assemblies = new List<Assembly>();
+    private readonly IList<Type> types = new List<Type>();
+    #endregion
 
-        string path = $"{BasePath}{Path.DirectorySeparatorChar}{assemblyName.Name}.dll";
-        Assembly asm = null;
-        if (File.Exists(path))
-          asm = Assembly.LoadFrom(path);
-        else 
-          asm = Assembly.Load(assemblyName);
-        loadedAssemblies.Add(assemblyName, asm);
-        foreach (var a in asm.GetReferencedAssemblies())
-          Load(a);
-        return asm;
-      }
-    }
-
-    private ALC alc;
-    public string BasePath { get; set; }
-    public string AssemblyPrefix { get; set; }
-
-    //public IList<Assembly> Assemblies { private set; get; } = new List<Assembly>();
-    //public IList<Type> Types { private set; get; } = new List<Type>();
-
-    private IList<Assembly> assemblies = new List<Assembly>();
+    #region Properties
+    /// <summary>
+    /// All loaded assemblies. Contains items only after a call of LoadAssemblies.
+    /// </summary>
     public IEnumerable<Assembly> Assemblies => assemblies;
 
-    private IList<Type> types = new List<Type>();
+    /// <summary>
+    /// All types found in all assemblies.
+    /// </summary>
     public IEnumerable<Type> Types => types;
+    #endregion
 
-    public AssemblyLoader() : this(Directory.GetCurrentDirectory()) { }
-    public AssemblyLoader(string basePath) {
-      this.BasePath = basePath;
-      alc = new ALC(BasePath);
+    #region Constructors
+    public AssemblyLoader() {
+
+      #region alternative code
       /*
       ScanTypesInBasePath();
@@ -67 +54 @@
       //LoadAssemblies(asms);
       //LoadTypes(asms);
+      #endregion
+    }
+    #endregion
+
+
+    private IEnumerable<string> GetAssembliesFromBasePath(string basePath) {
+      return Directory.GetFiles(basePath, "*.dll", SearchOption.AllDirectories)
+        .Concat(Directory.GetFiles(basePath, "*.exe", SearchOption.AllDirectories));
     }
 
-    // 1.
-    private IEnumerable<string> GetAssembliesFromBasePath() {
-      return Directory.GetFiles(BasePath, $"*.dll", SearchOption.AllDirectories);
-    }
+    #region alternative code
     /*
     // 2.
@@ -126 +118 @@
     }
     */
+    #endregion
+
+
     private void LoadTypes(IEnumerable<Assembly> assemblies) {
       foreach (Assembly asm in assemblies) {
@@ -133 +128 @@
           }
         } catch (ReflectionTypeLoadException e) {
+          // ReflectionTypeLoadException gets thrown if any class in a module cannot be loaded.
           try {
-            foreach (Type t in e.Types) {
+            foreach (Type t in e.Types) { // fetch the already loaded types, be careful some of them can be null
               if (t != null) {
                 types.Add(t);
@@ -140 +136 @@
             }
           } catch (BadImageFormatException) { }
-
-        } catch (Exception e) {
-          Tracing.Logger.Error(
-            $"Exception occured while loading types of assembly {asm.FullName}! \n " +
-            $"---- Stacktrace ---- \n {e}");
+        } catch (Exception e) { // to catch every other exception
+          //Tracing.Logger.Error(
+          //  $"Exception occured while loading types of assembly {asm.FullName}! \n " +
+          //  $"---- Stacktrace ---- \n {e}");
         }
       }
     }
-    /*
-    public Type GetType(string type) {
-      foreach (Assembly asm in Assemblies) {
-        Type t = asm.GetType(type);
-        if (t != null) return t;
-      }
-      return null;
-    }
-    */
 
-    public IEnumerable<Assembly> GetReflectionOnlyAssemblies() {
-      IList<Assembly> list = new List<Assembly>();
-      foreach (string path in GetAssembliesFromBasePath()) {
-        try {
-          var asm = Assembly.LoadFrom(path);
-          if (asm != null)
-            list.Add(asm);
-          else
-            Tracing.Logger.Error($"Unnable to load assembly with path {path}!");
-        } catch (Exception e) {
-          Tracing.Logger.Error(
-            $"Exception occured while loading assembly from path {path}! \n " +
-            $"---- Stacktrace ---- \n {e}");
-        }
-      }
-      return list;
-    }
-
-    public IEnumerable<Assembly> LoadAssemblies(IEnumerable<AssemblyName> assemblyNames) {
-      foreach (AssemblyName asm in assemblyNames) {
-        try {
-          this.assemblies.Add(alc.LoadFromAssemblyName(asm));
-        } catch (Exception e) {
-          Tracing.Logger.Error(
-            $"Exception occured while loading assembly: {asm.FullName}! \n " +
-            $"---- Stacktrace ---- \n {e}");
-        }
-      }
+    public IEnumerable<Assembly> LoadAssemblies(string basePath) {
+      foreach (string path in GetAssembliesFromBasePath(basePath))
+        LoadAssemblyFromPath(path);
+      
       LoadTypes(this.Assemblies);
       return this.Assemblies;
     }
+
+    public IEnumerable<Assembly> LoadAssemblies(IEnumerable<AssemblyInfo> assemblyInfos) {
+      foreach (var info in assemblyInfos)
+        LoadAssemblyFromPath(info.Path.ToString());
+      
+      LoadTypes(this.Assemblies);
+      return this.Assemblies;
+    }
+
+    private void LoadAssemblyFromPath(string path) {
+      try {
+        var asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(path); // loads assembly into default context
+        if (asm != null) {
+          assemblies.Add(asm);
+        } // else
+          //Tracing.Logger.Error($"Unnable to load assembly with path {path}!");
+      } catch (Exception e) { // to catch every exception occured by assembly loading.
+        //Tracing.Logger.Error(
+        //  $"Exception occured while loading assembly from path {path}! \n " +
+        //  $"---- Stacktrace ---- \n {e}");
+      }
+    }
   }
 }

branches/2924_DotNetCoreMigration/HeuristicLab.PluginInfrastructure/3.3/Isolation/PluginLoader.cs

@@ -1 +1 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Linq;
-using System.Collections.Generic;
+using System.Reflection;
+using System.Security;
 using System.Text;
-using HeuristicLab.PluginInfrastructure;
-using System.Reflection;
-using System.IO;
-using System.Security;
-
-namespace HeuristicLab.PluginInfrastructure.Runner {
-  internal class PluginLoader : IPluginLoader {
-
+
+namespace HeuristicLab.PluginInfrastructure {
+  public class PluginLoader : IPluginLoader {
+
+    /// <summary>
+    /// Helper class for depedency metadata.
+    /// </summary>
     private class PluginDependency {
       public string Name { get; private set; }
       public Version Version { get; private set; }
-
       public PluginDependency(string name, Version version) {
         this.Name = name;
@@ -21 +22 @@
     }
 
-    private IList<IPlugin> plugins = null;
-    public IList<IPlugin> Plugins {
-      private set => plugins = value;
-      get {
-        if (plugins == null) {
-          Plugins = new List<IPlugin>();
-          DiscoverPlugins();
-        }
-        return plugins;
-      }
-    }
-
-    private IList<IApplication> applications = null;
-    public IList<IApplication> Applications {
-      private set => applications = value;
-      get {
-        if (applications == null) {
-          Applications = new List<IApplication>();
-          DiscoverApplications();
-        }
-        return applications;
-      }
-    }
-
-    private IList<IActivator> activators = null;
-    public IList<IActivator> Activators {
-      private set => activators = value; 
-      get {
-        if (activators == null) {
-          activators = new List<IActivator>();
-          DiscoverActivators();
-        }
-        return activators;
-      }
-    }
-
-
-    #region oldCode
+    #region Vars
+    private IList<IPlugin> plugins = new List<IPlugin>();
+    private IList<IApplication> applications = new List<IApplication>();
+    private IAssemblyLoader assemblyLoader = null;
     private Dictionary<PluginDescription, IEnumerable<PluginDependency>> pluginDependencies = new Dictionary<PluginDescription, IEnumerable<PluginDependency>>();
     #endregion
-    private IEnumerable<Assembly> reflectionOnlyAssemblies;
-    private IAssemblyLoader asmLoader;
-    private string BasePath { get; set; }
-
-    public PluginLoader(string basePath, IAssemblyLoader assemblyLoader) {
-      asmLoader = assemblyLoader;
-      this.BasePath = basePath;
-      Init();
-    }
-
-    private void Init() {
-      reflectionOnlyAssemblies = asmLoader.GetReflectionOnlyAssemblies();
-
-      IEnumerable<PluginDescription> pluginDescriptions = GatherPluginDescriptions(reflectionOnlyAssemblies);
-
-
-      CheckPluginFiles(pluginDescriptions);
+
+    #region Properties
+    public IEnumerable<IPlugin> Plugins => plugins;
+
+    public IEnumerable<IApplication> Applications => applications;
+    #endregion
+
+    #region Constructors
+    public PluginLoader(IAssemblyLoader assemblyLoader) {
+      this.assemblyLoader = assemblyLoader;
+    }
+    #endregion
+
+    #region Discover Methods
+    public void LoadPlugins(IEnumerable<AssemblyInfo> assemblyInfos) {
+      assemblyLoader.LoadAssemblies(assemblyInfos);
+      DiscoverPlugins();
+      DiscoverApplications();
+    }
+    /// <summary>
+    /// Discovers all types of IPlugin of all loaded assemblies. Saves the found plugins in a list.
+    /// </summary>
+    private void DiscoverPlugins() {
+      // search plugins out of all types
+      string curDir = Directory.GetCurrentDirectory(); // save current working directory
+      foreach (var type in assemblyLoader.Types) {
+        if (typeof(IPlugin).IsAssignableFrom(type) && !type.IsAbstract && !type.IsInterface && !type.HasElementType) {
+          // to set the working directory to the assembly location, this is necessary for assemblies which load data in the OnLoad method by their own.
+          // example: HeuristicLabMathJaxPlugin
+          Directory.SetCurrentDirectory(type.Assembly.Location.Replace(Path.GetFileName(type.Assembly.Location), ""));
+          IPlugin p = (IPlugin)Activator.CreateInstance(type);
+          p.OnLoad();
+          plugins.Add(p);
+        }
+      }
+      Directory.SetCurrentDirectory(curDir); // set working directory to its base value
+    }
+
+    /// <summary>
+    /// Discovers all types of IApplication of all loaded assemblies. Saves the found applications in a list.
+    /// </summary>
+    private void DiscoverApplications() {
+      foreach (Type type in assemblyLoader.Types) {
+        if (typeof(IApplication).IsAssignableFrom(type) && !type.IsAbstract && !type.IsInterface && !type.HasElementType) {
+          IApplication app = (IApplication)Activator.CreateInstance(type);
+          applications.Add(app);
+        }
+      }
+    }
+    #endregion
+       
+    public IEnumerable<AssemblyInfo> Validate(string basePath) {
+      IEnumerable<Assembly> assemblies = assemblyLoader.LoadAssemblies(basePath);
+
+      IList<PluginDescription> pluginDescriptions = GatherPluginDescriptions(assemblies, basePath);
+      CheckPluginFiles(pluginDescriptions, basePath);
 
       // check if all plugin assemblies can be loaded
-      CheckPluginAssemblies(pluginDescriptions);
+      CheckPluginAssemblies(assemblies, pluginDescriptions);
 
       // a full list of plugin descriptions is available now we can build the dependency tree
@@ -93 +99 @@
       // in the next step
       CheckPluginDependencies(pluginDescriptions);
-      // load assemblies
-      IEnumerable<Assembly> assemblies = asmLoader.LoadAssemblies(
-        pluginDescriptions
-        .Where(x => x.PluginState != PluginState.Disabled)
-        .SelectMany(
-          x => x.AssemblyLocations
-          .SelectMany(loc =>
-            reflectionOnlyAssemblies
-            .Where(asm => string.Equals(Path.GetFullPath(asm.Location), Path.GetFullPath(loc), StringComparison.CurrentCultureIgnoreCase))
-            .Select(asm => asm.GetName())
-          )
-        )
-      );
-    }
-
-    private void DiscoverPlugins() {
-      // search plugins out of all types
-      foreach (var type in asmLoader.Types) {
-        if (typeof(IPlugin).IsAssignableFrom(type) && !type.IsAbstract && !type.IsInterface && !type.HasElementType) {
-          IPlugin p = (IPlugin)Activator.CreateInstance(type);
-          //p.OnLoad();
-          Plugins.Add(p);
-        }
-      }
-
-      #region oldCode
-      /*
-      IEnumerable<PluginDescription> pluginDescriptions = GatherPluginDescriptions(asmLoader.Assemblies);
-      
-      CheckPluginFiles(pluginDescriptions);
-      //--> checken ob alle assemblies physisch vorliegen die benötigt werden (depedency)
-
-      // check if all plugin assemblies can be loaded
-      CheckPluginAssemblies(pluginDescriptions); //--> ob sie auch geladen werden können
-      //--> 1. und 2. könnte man zusammenfassen, da eh schon assemblies gescannt und geladen wurden ... checken ob diese vorliegen -> asmLoader.Assemblies
-
-      // a full list of plugin descriptions is available now we can build the dependency tree
-      BuildDependencyTree(pluginDescriptions); //--> gleich auf assembly basis?!
-
-      // check for dependency cycles
-      CheckPluginDependencyCycles(pluginDescriptions);
-
-      // 1st time recursively check if all necessary plugins are available and not disabled
-      // disable plugins with missing or disabled dependencies 
-      // to prevent that plugins with missing dependencies are loaded into the execution context
-      // in the next step
-      CheckPluginDependencies(pluginDescriptions); //--> "disabled" assemblies merken (evtl. mit Dictionary) 
-
-      // test full loading (in contrast to reflection only loading) of plugins
-      // disables plugins that are not loaded correctly
-      CheckExecutionContextLoad(pluginDescriptions);
-
-      // 2nd time recursively check if all necessary plugins have been loaded successfully and not disabled
-      // disable plugins with for which dependencies could not be loaded successfully
-      CheckPluginDependencies(pluginDescriptions);
-      
-      foreach (var desc in pluginDescriptions)
-        if (desc.PluginState != PluginState.Disabled)
-          desc.Enable();
-
-      // load the enabled plugins
-      LoadPlugins(pluginDescriptions);
-      */
-      #endregion
-    }
-
-    private void DiscoverApplications() {
-      foreach (Type type in asmLoader.Types) {
-        if (typeof(IApplication).IsAssignableFrom(type) && !type.IsAbstract && !type.IsInterface && !type.HasElementType) {
-          IApplication app = (IApplication)Activator.CreateInstance(type);
-          Applications.Add(app);
-        }
-      }
-    }
-
-    private void DiscoverActivators() {
-      foreach (Type type in asmLoader.Types) {
-        if (typeof(IActivator).IsAssignableFrom(type) && !type.IsAbstract && !type.IsInterface && !type.HasElementType) {
-          IActivator act = (IActivator)Activator.CreateInstance(type);
-          Activators.Add(act);
-        }
-      }
+
+      // build assemblyInfo list: 
+      // 1.) iterate through pluginDescriptions and pick all not disabled plugins
+      // 2.) iterate through the assemblyLocations, saved in a description
+      // 3.) iterate thorugh all loaded assemblies 
+      // 4.) if the location of an assemblies and a pluginDescriptions match -> create new AssemblyInfo and add it to a list
+      IList<AssemblyInfo> list = new List<AssemblyInfo>();
+      foreach (var desc in pluginDescriptions) {
+        if (desc.PluginState != PluginState.Disabled) {
+          foreach (var loc in desc.AssemblyLocations) {
+            foreach (var asm in assemblies) {
+              if (string.Equals(Path.GetFullPath(asm.Location), Path.GetFullPath(loc), StringComparison.CurrentCultureIgnoreCase))
+                list.Add(new AssemblyInfo() { Path = new UniPath(asm.Location), Name = asm.FullName });
+            }
+          }
+        }
+      }
+
+      return list;
     }
 
@@ -182 +125 @@
     /// </summary>
     /// <param name="pluginDescriptions"></param>
-    private void CheckPluginAssemblies(IEnumerable<PluginDescription> pluginDescriptions) {
+    private void CheckPluginAssemblies(IEnumerable<Assembly> assemblies, IEnumerable<PluginDescription> pluginDescriptions) {
       foreach (var desc in pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled)) {
         try {
@@ -190 +133 @@
             // so we simply determine the name of the assembly and try to find it in the cache of loaded assemblies
             var asmName = AssemblyName.GetAssemblyName(asmLocation);
-            if (!reflectionOnlyAssemblies.Select(x => x.GetName().FullName).Contains(asmName.FullName)) {
+            if (!assemblies.Select(x => x.GetName().FullName).Contains(asmName.FullName)) {
               missingAssemblies.Add(asmName.FullName);
             }
@@ -225 +168 @@
     // the dependencies in the plugin descriptions are not yet set correctly because we need to create
     // the full list of all plugin descriptions first
-    private IEnumerable<PluginDescription> GatherPluginDescriptions(IEnumerable<Assembly> assemblies) {
+    private IList<PluginDescription> GatherPluginDescriptions(IEnumerable<Assembly> assemblies, string basePath) {
       List<PluginDescription> pluginDescriptions = new List<PluginDescription>();
       foreach (Assembly assembly in assemblies) {
@@ -234 +177 @@
           // use AssemblyQualifiedName to compare the types because we can't directly 
           // compare ReflectionOnly types and execution types
+
           var assemblyPluginDescriptions = from t in assembly.GetExportedTypes()
                                            where !t.IsAbstract && t.GetInterfaces()
                                            .Any(x => x.AssemblyQualifiedName == typeof(IPlugin).AssemblyQualifiedName)
-                                           select GetPluginDescription(t);
+                                           select GetPluginDescription(t, basePath);
           pluginDescriptions.AddRange(assemblyPluginDescriptions);
         }
@@ -252 +196 @@
 
     // checks if all declared plugin files are actually available and disables plugins with missing files
-    private void CheckPluginFiles(IEnumerable<PluginDescription> pluginDescriptions) {
+    private void CheckPluginFiles(IEnumerable<PluginDescription> pluginDescriptions, string basePath) {
       foreach (PluginDescription desc in pluginDescriptions) {
         IEnumerable<string> missingFiles;
-        if (ArePluginFilesMissing(desc, out missingFiles)) {
+        if (ArePluginFilesMissing(desc, basePath, out missingFiles)) {
           StringBuilder errorStrBuilder = new StringBuilder();
           errorStrBuilder.AppendLine("Missing files:");
@@ -266 +210 @@
     }
 
-    private bool ArePluginFilesMissing(PluginDescription pluginDescription, out IEnumerable<string> missingFiles) {
+    private bool ArePluginFilesMissing(PluginDescription pluginDescription, string basePath, out IEnumerable<string> missingFiles) {
       List<string> missing = new List<string>();
       foreach (string filename in pluginDescription.Files.Select(x => x.Name)) {
-        if (!FileLiesInDirectory(BasePath, filename) ||
+        if (!FileLiesInDirectory(basePath, filename) ||
           !File.Exists(filename)) {
           missing.Add(filename);
@@ -289 +233 @@
     /// </summary>
     /// <param name="pluginType"></param>
-    private PluginDescription GetPluginDescription(Type pluginType) {
+    private PluginDescription GetPluginDescription(Type pluginType, string basePath) {
 
       string pluginName, pluginDescription, pluginVersion;
@@ -295 +239 @@
       GetPluginMetaData(pluginType, out pluginName, out pluginDescription, out pluginVersion);
       GetPluginContactMetaData(pluginType, out contactName, out contactAddress);
-      var pluginFiles = GetPluginFilesMetaData(pluginType);
+      var pluginFiles = GetPluginFilesMetaData(pluginType, basePath);
       var pluginDependencies = GetPluginDependencyMetaData(pluginType);
 
@@ -373 +317 @@
 
     // not static because we need the BasePath property
-    private IEnumerable<PluginFile> GetPluginFilesMetaData(Type pluginType) {
+    private IEnumerable<PluginFile> GetPluginFilesMetaData(Type pluginType, string basePath) {
       // get all attributes of type PluginFileAttribute
       var pluginFileAttributes = from attr in CustomAttributeData.GetCustomAttributes(pluginType)
@@ -381 +325 @@
         string pluginFileName = (string)pluginFileAttribute.ConstructorArguments[0].Value;
         PluginFileType fileType = (PluginFileType)pluginFileAttribute.ConstructorArguments[1].Value;
-        yield return new PluginFile(Path.GetFullPath(Path.Combine(BasePath, pluginFileName)), fileType);
+        yield return new PluginFile(Path.GetFullPath(Path.Combine(basePath, pluginFileName)), fileType);
       }
     }
@@ -405 +349 @@
       }
     }
+
 
     private static bool IsAttributeDataForType(CustomAttributeData attributeData, Type attributeType) {
@@ -496 +441 @@
     }
 
-
     private bool IsAnyDependencyDisabled(PluginDescription descr, List<PluginDescription> disabledPlugins) {
       if (descr.PluginState == PluginState.Disabled) {
@@ -507 +451 @@
       return disabledPlugins.Count > 0;
     }
-
-    // tries to load all plugin assemblies into the execution context
-    // if an assembly of a plugin cannot be loaded the plugin is disabled
-    private void CheckExecutionContextLoad(IEnumerable<PluginDescription> pluginDescriptions) {
-      // load all loadable plugins (all dependencies available) into the execution context
-      foreach (var desc in PluginDescriptionIterator.IterateDependenciesBottomUp(pluginDescriptions
-                                                                                .Where(x => x.PluginState != PluginState.Disabled))) {
-        // store the assembly names so that we can later retrieve the assemblies loaded in the appdomain by name
-        var assemblyNames = new List<string>();
-        foreach (string assemblyLocation in desc.AssemblyLocations) {
-          if (desc.PluginState != PluginState.Disabled) {
-            try {
-              string assemblyName = (from assembly in asmLoader.Assemblies//AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies()
-                                     where string.Equals(Path.GetFullPath(assembly.Location), Path.GetFullPath(assemblyLocation), StringComparison.CurrentCultureIgnoreCase)
-                                     select assembly.FullName).Single();
-              // now load the assemblies into the execution context  
-              // this can still lead to an exception
-              // even when the assemby was successfully loaded into the reflection only context before 
-              // when loading the assembly using it's assemblyName it can be loaded from a different location than before (e.g. the GAC)
-              //Assembly.Load(assemblyName);
-              assemblyNames.Add(assemblyName);
-            } catch (BadImageFormatException) {
-              desc.Disable(Path.GetFileName(assemblyLocation) + " is not a valid assembly.");
-            } catch (FileLoadException) {
-              desc.Disable("Can't load file " + Path.GetFileName(assemblyLocation));
-            } catch (FileNotFoundException) {
-              desc.Disable("File " + Path.GetFileName(assemblyLocation) + " is missing.");
-            } catch (SecurityException) {
-              desc.Disable("File " + Path.GetFileName(assemblyLocation) + " can't be loaded because of security constraints.");
-            } catch (NotSupportedException ex) {
-              // disable the plugin
-              desc.Disable("Problem while loading plugin assemblies:" + Environment.NewLine + "NotSupportedException: " + ex.Message);
-            }
-          }
-        }
-        desc.AssemblyNames = assemblyNames;
-      }
-    }
-
-    // assumes that all plugin assemblies have been loaded into the execution context via CheckExecutionContextLoad
-    // for each enabled plugin:
-    // calls OnLoad method of the plugin 
-    // and raises the PluginLoaded event
-    private void LoadPlugins(IEnumerable<PluginDescription> pluginDescriptions) {
-      List<Assembly> assemblies = new List<Assembly>(asmLoader.Assemblies);
-      plugins = new List<IPlugin>();
-      foreach (var desc in pluginDescriptions) {
-        if (desc.PluginState == PluginState.Enabled) {
-          // cannot use ApplicationManager to retrieve types because it is not yet instantiated
-          foreach (string assemblyName in desc.AssemblyNames) {
-            var asm = (from assembly in assemblies
-                       where assembly.FullName == assemblyName
-                       select assembly)
-                      .SingleOrDefault();
-            if (asm == null) throw new InvalidPluginException("Could not load assembly " + assemblyName + " for plugin " + desc.Name);
-            foreach (Type pluginType in asm.GetExportedTypes()) {
-              if (typeof(IPlugin).IsAssignableFrom(pluginType) && !pluginType.IsAbstract && !pluginType.IsInterface && !pluginType.HasElementType) {
-                IPlugin plugin = (IPlugin)Activator.CreateInstance(pluginType);
-                plugin.OnLoad();
-                plugins.Add(plugin);
-                //OnPluginLoaded(new PluginInfrastructureEventArgs(desc));
-              }
-            }
-          } // end foreach assembly in plugin
-          desc.Load();
-        }
-      } // end foreach plugin description
-    }
   }
   #endregion

branches/2924_DotNetCoreMigration/HeuristicLab.PluginInfrastructure/3.3/Isolation/PluginLoaderFactory.cs

@@ -4 +4 @@
 using System.Text;
 
-namespace HeuristicLab.PluginInfrastructure.Runner {
-  public class PluginLoaderFactory {
+namespace HeuristicLab.PluginInfrastructure {
+  /// <summary>
+  /// Factory to create an instance of a plugin loader. 
+  /// </summary>
+  public static class PluginLoaderFactory {
+    /// <summary>
+    /// Creates a new instance of a plugin loader.
+    /// </summary>
     public static IPluginLoader Create() {
-      return Create(Directory.GetCurrentDirectory());
-    }
-
-    internal static IPluginLoader Create(string basePath) {
-      return new PluginLoader(basePath, new AssemblyLoader(basePath));
+      return new PluginLoader(new AssemblyLoader());
     }
   }