// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.IO;
|
using System.Reflection;
|
using System.Diagnostics;
|
using System.Collections.ObjectModel;
|
using System.Collections.Concurrent;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using Tap.Shared;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Static class that searches for and loads OpenTAP plugins.
|
/// </summary>
|
public static class PluginManager
|
{
|
private static readonly TraceSource log = Log.CreateSource("PluginManager");
|
private static ManualResetEventSlim searchTask = new ManualResetEventSlim(true);
|
private static PluginSearcher searcher;
|
static TapAssemblyResolver assemblyResolver;
|
|
/// <summary>
|
/// Specifies the directories to be searched for plugins.
|
/// Any additional directories should be added before calling <see cref="PluginManager.SearchAsync()"/>,
|
/// <see cref="GetAllPlugins"/>, <see cref="GetPlugins{BaseType}"/>, <see cref="GetPlugins(Type)"/>,
|
/// <see cref="LocateType(string)"/> or <see cref="LocateTypeData(string)"/>
|
/// </summary>
|
public static List<string> DirectoriesToSearch { get; private set; }
|
|
/// <summary>
|
/// Function signature for assembly load filters.
|
/// </summary>
|
/// <param name="assemblyName">The name of the assembly (not the full name).</param>
|
/// <param name="version">The assembly version.</param>
|
/// <returns>true if the assembly should be loaded. False if not.</returns>
|
public delegate bool AssemblyLoadFilterDelegate(string assemblyName, Version version);
|
|
/// <summary>
|
/// Adds a function that is used to filter whether an assembly should be loaded. This can be used to control which assemblies gets loaded.
|
/// This is for very advanced usage only. The filters are used in the order in which they are added.
|
/// </summary>
|
/// <param name="filter">The additional filter to use.</param>
|
static public void AddAssemblyLoadFilter(AssemblyLoadFilterDelegate filter)
|
{
|
if (filter == null)
|
throw new ArgumentNullException("filter");
|
assemblyLoadFilters.Add(filter);
|
}
|
|
static List<AssemblyLoadFilterDelegate> assemblyLoadFilters = new List<AssemblyLoadFilterDelegate> { (asm,version) => true };
|
static bool shouldLoadAssembly(string asmName, Version asmVersion)
|
{
|
foreach (var filter in assemblyLoadFilters)
|
if (!filter(asmName, asmVersion))
|
return false;
|
return true;
|
}
|
|
/// <summary>
|
/// Returns a list of types that implement a specified plugin base type.
|
/// This will load the assembly containing the type, if not already loaded.
|
/// This will search for plugins if not done already (e.g. using <see cref="PluginManager.SearchAsync()"/>)
|
/// </summary>
|
/// <param name="pluginBaseType">only looks for types descending from pluginBaseType.</param>
|
public static ReadOnlyCollection<Type> GetPlugins(Type pluginBaseType)
|
{
|
return PluginFetcher.GetPlugins(pluginBaseType);
|
}
|
|
/// <summary> Class for caching the result of GetPlugins(type).</summary>
|
static class PluginFetcher
|
{
|
public static ReadOnlyCollection<Type> GetPlugins(Type pluginBaseType)
|
{
|
// If the searcher has changed, or if a search is currently happening, invalidate plugins.
|
if (searcher != lastUsedSearcher || !searchTask.Wait(0))
|
{
|
lock (pluginsSelection)
|
{
|
lastUsedSearcher = searcher;
|
pluginsSelection.InvalidateAll();
|
}
|
}
|
return pluginsSelection.Invoke(pluginBaseType);
|
}
|
static readonly ReadOnlyCollection<Type> emptyTypes = Array.Empty<Type>().ToList().AsReadOnly();
|
static ReadOnlyCollection<Type> getPlugins(Type pluginBaseType)
|
{
|
if (pluginBaseType == null)
|
throw new ArgumentNullException("pluginBaseType");
|
|
|
PluginSearcher searcher = GetSearcher(); // Wait for the search to complete (and get the result)
|
var unloadedPlugins = PluginManager.GetPlugins(searcher, pluginBaseType.FullName);
|
if (unloadedPlugins.Count == 0)
|
return emptyTypes;
|
|
int notLoadedTypesCnt = unloadedPlugins.Count(pl => pl.Status == LoadStatus.NotLoaded);
|
if(notLoadedTypesCnt > 0)
|
{
|
var notLoadedAssembliesCnt = unloadedPlugins.Select(x => x.Assembly).Distinct().Where(asm => asm.Status == LoadStatus.NotLoaded).ToArray();
|
if (notLoadedAssembliesCnt.Length > 0)
|
{
|
notLoadedAssembliesCnt.AsParallel().ForAll(asm => asm.Load());
|
}
|
}
|
IEnumerable<TypeData> plugins = unloadedPlugins;
|
if (notLoadedTypesCnt > 8)
|
{
|
// only find types in parallel if there are sufficiently many.
|
plugins = plugins
|
.AsParallel() // This is around 50% faster when many plugins are loaded in parallel.
|
.AsOrdered(); // ensure the order is the same as before.
|
}
|
|
return plugins
|
.Select(td => td.Load())
|
.Where(x => x != null)
|
.ToList()
|
.AsReadOnly();
|
}
|
|
static PluginSearcher lastUsedSearcher = null;
|
static Memorizer<Type, ReadOnlyCollection<Type>> pluginsSelection = new Memorizer<Type, ReadOnlyCollection<Type>>(getPlugins);
|
}
|
|
static ICollection<TypeData> GetPlugins(PluginSearcher searcher, string baseTypeFullName)
|
{
|
TypeData baseType;
|
if (!searcher.AllTypes.TryGetValue(baseTypeFullName, out baseType))
|
return Array.Empty<TypeData>();
|
|
if (baseType.DerivedTypes == null)
|
return Array.Empty<TypeData>();
|
|
var specializations = new List<TypeData>();
|
|
foreach (TypeData st in baseType.DerivedTypes)
|
{
|
if (st.TypeAttributes.HasFlag(TypeAttributes.Interface) || st.TypeAttributes.HasFlag(TypeAttributes.Abstract))
|
continue;
|
if(shouldLoadAssembly(st.Assembly.Name, st.Assembly.Version))
|
specializations.Add(st);
|
}
|
return specializations;
|
}
|
static object startSearcherLock = new object();
|
/// <summary>
|
/// Returns the <see cref="PluginSearcher"/> used to search for plugins.
|
/// This will search for plugins if not done already (i.e. call and wait for <see cref="PluginManager.SearchAsync()"/>)
|
/// </summary>
|
public static PluginSearcher GetSearcher()
|
{
|
searchTask.Wait();
|
if (searcher == null)
|
{
|
// If the search task has not been started, do it now.
|
lock (startSearcherLock)
|
{
|
if(searcher == null)
|
Search();
|
}
|
}
|
return searcher; // Wait for the search to complete (and get the result)
|
}
|
|
/// <summary>
|
/// Gets all plugins. I.e. all types that descend from <see cref="ITapPlugin"/>.
|
/// Abstract types and interfaces are not included.
|
/// This does not require/cause the assembly containing the type to be loaded.
|
/// This will search for plugins if not done already (i.e. call and wait for <see cref="PluginManager.SearchAsync()"/>)
|
/// Only C#/.NET types are returned. To also get dynamic types (from custom <see cref="ITypeDataSearcher"/>s) use <see cref="TypeData.GetDerivedTypes(ITypeData)"/> instead.
|
/// </summary>
|
public static ReadOnlyCollection<TypeData> GetAllPlugins()
|
{
|
PluginSearcher searcher = GetSearcher();
|
return searcher.PluginTypes
|
.Where(st =>
|
!st.TypeAttributes.HasFlag(TypeAttributes.Interface)
|
&& !st.TypeAttributes.HasFlag(TypeAttributes.Abstract)
|
&& st.Status != LoadStatus.FailedToLoad)
|
.ToList().AsReadOnly();
|
}
|
|
/// <summary>
|
/// Returns a list of types that implement a specified plugin base type.
|
/// This will load the assembly containing the type, if not already loaded.
|
/// This will search for plugins if not done already (i.e. call and wait for <see cref="PluginManager.SearchAsync()"/>)
|
/// Only C#/.NET types are returned. To also get dynamic types (from custom <see cref="ITypeDataSearcher"/>s) use <see cref="TypeData.GetDerivedTypes(ITypeData)"/> instead.
|
/// </summary>
|
/// <remarks>
|
/// This is just to provide a more convenient syntax compared to <see cref="GetPlugins(Type)"/>. The funcionallity is identical.
|
/// </remarks>
|
/// <typeparam name="BaseType">find types that descends from this type.</typeparam>
|
/// <returns>A read-only collection of types.</returns>
|
public static ReadOnlyCollection<Type> GetPlugins<BaseType>()
|
{
|
return StaticPluginTypeCache<BaseType>.Get();
|
}
|
|
/// <summary>
|
/// Cache structure to lock-free optimize BaseType type lookups.
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
class StaticPluginTypeCache<T>
|
{
|
static ReadOnlyCollection<Type> list;
|
|
public static ReadOnlyCollection<Type> Get()
|
{
|
return list ??= GetPlugins(typeof(T));
|
|
}
|
static StaticPluginTypeCache()
|
{
|
CacheState.Updated += (s, e) => list = null;
|
}
|
|
}
|
|
/// <summary>
|
/// Gets the AssemblyData for the OpenTap.dll assembly.
|
/// This will search for plugins if not done already (i.e. call and wait for <see cref="PluginManager.SearchAsync()"/>)
|
/// </summary>
|
public static AssemblyData GetOpenTapAssembly()
|
{
|
PluginSearcher searcher = GetSearcher();
|
return searcher.PluginMarkerType.Assembly;
|
}
|
/// <summary>
|
/// Start a search task that finds plugins to the platform.
|
/// This call is not blocking, some other calls to PluginManager will automatically
|
/// wait for this task to finish (or even start it if it hasn't been already). These calls
|
/// include <see cref="GetAllPlugins"/>, <see cref="GetPlugins{BaseType}"/>,
|
/// <see cref="GetPlugins(Type)"/>, <see cref="LocateType(string)"/> and <see cref="LocateTypeData(string)"/>
|
/// </summary>
|
public static Task SearchAsync()
|
{
|
searchTask.Reset();
|
CacheState.OnUpdated();
|
return TapThread.StartAwaitable(Search);
|
}
|
|
///<summary>Searches for plugins.</summary>
|
public static void Search()
|
{
|
searchTask.Reset();
|
searcher ??= new();
|
assemblyResolver.Invalidate(DirectoriesToSearch);
|
CacheState.OnUpdated();
|
try
|
{
|
IEnumerable<string> fileNames = assemblyResolver.GetAssembliesToSearch();
|
searcher = SearchAndAddToStore(fileNames);
|
}
|
catch (Exception e)
|
{
|
log.Error("Caught exception while searching for plugins: '{0}'", e.Message);
|
log.Debug(e);
|
}
|
finally
|
{
|
searchTask.Set();
|
}
|
}
|
|
static bool isLoaded = false;
|
static object loadLock = new object();
|
/// <summary> Sets up the PluginManager assembly resolution systems. Under normal circumstances it is not needed to call this method directly.</summary>
|
internal static void Load()
|
{
|
lock (loadLock)
|
{
|
if (isLoaded) return;
|
isLoaded = true;
|
|
SessionLogs.Initialize();
|
|
string tapEnginePath = Assembly.GetExecutingAssembly().Location;
|
if(String.IsNullOrEmpty(tapEnginePath))
|
{
|
// if OpenTap.dll was loaded from memory/bytes instead of from a file, it does not have a location.
|
// This is the case if the process was launched through tap.exe.
|
// In that case just use the location of tap.exe, it is the same
|
tapEnginePath = Assembly.GetEntryAssembly().Location;
|
}
|
DirectoriesToSearch = new List<string> { Path.GetDirectoryName(tapEnginePath) };
|
assemblyResolver = new TapAssemblyResolver(DirectoriesToSearch);
|
|
// Custom Assembly resolvers.
|
AppDomain.CurrentDomain.GetAssemblies().ToList().ForEach(assemblyResolver.AddAssembly);
|
AppDomain.CurrentDomain.AssemblyLoad += (s, args) => assemblyResolver.AddAssembly(args.LoadedAssembly);
|
AppDomain.CurrentDomain.AssemblyResolve += (s, args) => assemblyResolver.Resolve(args.Name, false);
|
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += (s, args) => assemblyResolver.Resolve(args.Name, true);
|
}
|
}
|
|
/// <summary> Calls PluginManager.Load </summary>
|
static PluginManager()
|
{
|
CacheState.Updated += (s, e) =>
|
{
|
PluginsChanged?.Invoke(s, new PluginsChangedEventArgs());
|
};
|
Load();
|
|
}
|
|
/// <summary> Ensures that the plugin manager is initialized. </summary>
|
public static void Initialize()
|
{
|
// Forces the static constuctore to be called. Intentionally left empty.
|
}
|
|
/// <summary>
|
/// Searches the files in fileNames for dlls implementing <see cref="ITapPlugin"/>
|
/// and puts the implementation in the appropriate list.
|
/// </summary>
|
/// <param name="_fileNames">List of files to search.</param>
|
static PluginSearcher SearchAndAddToStore(IEnumerable<string> _fileNames)
|
{
|
var fileNames = _fileNames.ToList();
|
Stopwatch timer = Stopwatch.StartNew();
|
// Create a new searcher based on the current searcher.
|
// Loaded plugins will be 'absorbed'. This is needed in case a loaded plugin was uninstalled.
|
var newSearcher = new PluginSearcher(searcher);
|
try
|
{
|
var w2 = Stopwatch.StartNew();
|
IEnumerable<TypeData> foundPluginTypes = newSearcher.Search(fileNames);
|
IEnumerable<AssemblyData> foundAssemblies = foundPluginTypes.Select(p => p.Assembly).Distinct();
|
log.Debug(w2, "Found {0} plugin assemblies containing {1} plugin types.", foundAssemblies.Count(), foundPluginTypes.Count());
|
|
foreach (AssemblyData asm in foundAssemblies)
|
{
|
assemblyResolver.AddAssembly(asm.Name, asm.Location);
|
|
if (asm.Location.Contains(AppDomain.CurrentDomain.BaseDirectory))
|
log.Debug("Found version {0,-16} of {1}", asm.SemanticVersion?.ToString() ?? asm.Version?.ToString(), Path.GetFileName(asm.Location));
|
else
|
// log full path of assembly if it was loaded with --search from another directory.
|
log.Debug("Found version {0,-16} of {1} from {2}", asm.SemanticVersion?.ToString() ?? asm.Version?.ToString(), Path.GetFileName(asm.Location), asm.Location);
|
}
|
}
|
catch (Exception ex)
|
{
|
log.Error($"Plugin search failed: {ex.Message}");
|
log.Debug(ex);
|
}
|
|
log.Debug(timer, "Searched {0} Assemblies.", fileNames.Count);
|
|
if (GetPlugins(newSearcher, typeof(IInstrument).FullName).Count == 0)
|
log.Warning("No instruments found.");
|
if (GetPlugins(newSearcher, typeof(ITestStep).FullName).Count == 0)
|
log.Warning("No TestSteps found.");
|
return newSearcher;
|
}
|
|
private static Type locateType(string typeName)
|
{
|
PluginSearcher searcher = GetSearcher();
|
|
if (string.IsNullOrWhiteSpace(typeName))
|
return null;
|
if ((typeName.Length > 2) && (typeName[typeName.Length - 2] == '[') && (typeName[typeName.Length - 1] == ']'))
|
{
|
var elemType = LocateType(typeName.Substring(0, typeName.Length - 2));
|
if (elemType != null)
|
return elemType.MakeArrayType();
|
else return null;
|
}
|
else if (searcher.AllTypes.ContainsKey(typeName))
|
{
|
TypeData t = searcher.AllTypes[typeName];
|
var loaded = t.Load();
|
if (loaded != null)
|
return loaded;
|
}
|
|
if (typeName.Contains(","))
|
{
|
var x = locateType(typeName.Split(',')[0]);
|
if (x != null) return x;
|
}
|
|
return Type.GetType(typeName);
|
}
|
|
/// <summary>
|
/// Searches through found plugins. Returning the System.Type matching the given name if such a type is found
|
/// in any assembly in <see cref="DirectoriesToSearch"/> or mscorelib - otherwise null (e.g. for types located in the GAC)
|
/// This will load the assembly containing the type, if not already loaded.
|
/// This will search for plugins if not done already (i.e. call and wait for <see cref="PluginManager.SearchAsync()"/>)
|
/// </summary>
|
public static Type LocateType(string typeName)
|
{
|
// For compatibility with 8.x testplans in which e.g. OpenTap.BasicSteps.DelayStep was called Keysight.Tap.BasicSteps.DelayStep
|
var type = locateType(typeName);
|
if (type == null && typeName.StartsWith("Keysight.Tap."))
|
type = locateType(typeName.Replace("Keysight.Tap.", "OpenTap."));
|
return type;
|
}
|
|
/// <summary>
|
/// Searches through found plugins. Returns the <see cref="OpenTap.TypeData"/> matching the given name if such a type is found
|
/// in any assembly in <see cref="DirectoriesToSearch"/> - otherwise null (e.g. for types located in the GAC).
|
/// This does not require/cause the assembly containing the type to be loaded.
|
/// This will search for plugins if not done already (i.e. call and wait for <see cref="PluginManager.SearchAsync()"/>)
|
/// </summary>
|
[Obsolete("This only returns C#/.NET types. Use TypeData.GetDerivedTypes instead.")]
|
public static TypeData LocateTypeData(string typeName)
|
{
|
PluginSearcher searcher = GetSearcher();
|
TypeData type;
|
searcher.AllTypes.TryGetValue(typeName, out type);
|
return type;
|
}
|
|
#region Version ResultParameters
|
static Memorizer<Assembly, ResultParameter> AssemblyVersions = new Memorizer<Assembly, ResultParameter>(GetVersionResultParameter);
|
|
|
internal static readonly CacheObservable CacheState = new CacheObservable();
|
|
/// <summary> This event is invoked when the types found by the plugin manager has changed. </summary>
|
public static EventHandler<PluginsChangedEventArgs> PluginsChanged;
|
|
private static ResultParameter GetVersionResultParameter(Assembly assembly)
|
{
|
string hash = " - ";
|
|
using (var file = new FileStream(assembly.Location, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4 * 4096))
|
{
|
byte[] hashValue = BitConverter.GetBytes(MurMurHash3.Hash(file));
|
|
for (int i = 0; i < 4; i++)
|
{
|
hash += String.Format("{0:x2}", hashValue[i]);
|
}
|
}
|
|
System.Reflection.AssemblyName name = assembly.GetName();
|
return new ResultParameter("Version", name.Name, name.Version.ToString() + hash);
|
}
|
|
internal static IEnumerable<ResultParameter> GetPluginVersions(IEnumerable<object> allPluginTypes)
|
{
|
//Stopwatch timer = Stopwatch.StartNew();
|
var assemblies = allPluginTypes.Select(item => item.GetType()).Distinct().Select(type => type.Assembly).ToHashSet();
|
assemblies.Add(Assembly.GetExecutingAssembly());
|
|
List<ResultParameter> parameters = new List<ResultParameter>();
|
foreach (var asm in assemblies)
|
{
|
try
|
{
|
if (!asm.IsDynamic && !string.IsNullOrEmpty(asm.Location))
|
{
|
parameters.Add(AssemblyVersions.Invoke(asm));
|
}
|
}
|
catch
|
{
|
// Silent catch all because we don't care too much about this parameter
|
}
|
}
|
return new ResultParameters(parameters);
|
}
|
#endregion
|
}
|
|
|
class TapAssemblyResolver
|
{
|
static readonly TraceSource log = Log.CreateSource("Resolver");
|
|
private readonly AssemblyFinder FileFinder = new AssemblyFinder();
|
|
/// <summary>
|
/// Should be called before each search. Flushes the files found. Also sets up the directories to search.
|
/// </summary>
|
public void Invalidate(IEnumerable<string> directoriesToSearch)
|
{
|
FileFinder.Invalidate();
|
FileFinder.DirectoriesToSearch = directoriesToSearch;
|
lastSearchedDirs = FileFinder.DirectoriesToSearch.ToHashSet();
|
assemblyResolutionMemorizer.InvalidateWhere((k, v) => v == null);
|
}
|
|
|
|
public void AddAssembly(string name, string path)
|
{
|
asmLookup[name] = path;
|
}
|
|
public void AddAssembly(Assembly asm)
|
{
|
if (asm.IsDynamic == false)
|
{
|
var name = Path.GetFileNameWithoutExtension(asm.Location);
|
asmLookup[name] = asm.Location;
|
if (Utils.IsDebugBuild)
|
log.Debug("Loaded assembly {0} from {1}", asm.FullName, asm.Location);
|
}
|
else
|
{
|
if (Utils.IsDebugBuild)
|
log.Debug("Loaded assembly {0}", asm.FullName);
|
}
|
|
assemblyResolutionMemorizer.Add(new resolveKey { Name = asm.FullName, ReflectionOnly = asm.ReflectionOnly }, asm);
|
}
|
HashSet<string> lastSearchedDirs = new HashSet<string>();
|
|
public string[] GetAssembliesToSearch()
|
{
|
if (false == lastSearchedDirs.SetEquals(FileFinder.DirectoriesToSearch))
|
{ // If directories to search has changed.
|
lastSearchedDirs = FileFinder.DirectoriesToSearch.ToHashSet();
|
FileFinder.Invalidate();
|
assemblyResolutionMemorizer.InvalidateWhere((k, v) => v == null);
|
}
|
return FileFinder.AllAssemblies();
|
}
|
|
public Assembly Resolve(string name, bool reflectionOnly)
|
{
|
if(false == lastSearchedDirs.SetEquals(FileFinder.DirectoriesToSearch))
|
{ // If directories to search has changed.
|
lastSearchedDirs = FileFinder.DirectoriesToSearch.ToHashSet();
|
FileFinder.Invalidate();
|
assemblyResolutionMemorizer.InvalidateWhere((k,v) => v == null);
|
}
|
return assemblyResolutionMemorizer.Invoke(new resolveKey { Name = name, ReflectionOnly = reflectionOnly });
|
}
|
|
public TapAssemblyResolver(IEnumerable<string> directoriesToSearch)
|
{
|
FileFinder.DirectoriesToSearch = directoriesToSearch;
|
assemblyResolutionMemorizer = new Memorizer<resolveKey, Assembly>(key => resolveAssembly(key.Name, key.ReflectionOnly))
|
{
|
MaxNumberOfElements = 10000,
|
CylicInvokeResponse = Memorizer.CyclicInvokeMode.ReturnDefaultValue
|
};
|
}
|
|
/// <summary>
|
/// Look up for assembly locations in case Assembly.Load cannot find it. Used for resolve assembly.
|
/// </summary>
|
ConcurrentDictionary<string, string> asmLookup = new ConcurrentDictionary<string, string>();
|
|
[DebuggerDisplay("{Name} {ReflectionOnly}")]
|
struct resolveKey
|
{
|
public string Name;
|
public bool ReflectionOnly;
|
}
|
|
Memorizer<resolveKey, Assembly> assemblyResolutionMemorizer;
|
|
// returns an assembly name or null. (if native asm, etc.)
|
static AssemblyName tryGetAssemblyName(string filePath)
|
{
|
try
|
{
|
return AssemblyName.GetAssemblyName(filePath);
|
}
|
catch
|
{
|
var name = new AssemblyName();
|
name.Name = Path.GetFileNameWithoutExtension(filePath);
|
return name;
|
}
|
}
|
|
Assembly resolveAssembly(string name, bool reflectionOnly)
|
{
|
if (name.Contains(".XmlSerializers"))
|
return null;
|
if (name.Contains(".resources"))
|
return null;
|
try
|
{
|
Assembly loadFrom(string loadFilename)
|
{
|
try
|
{
|
return Assembly.LoadFrom(loadFilename);
|
}
|
catch(Exception ex)
|
{
|
log.Debug("Unable to load {0}. {1}", loadFilename, ex.Message);
|
return null;
|
}
|
}
|
|
string filename;
|
if (asmLookup.TryGetValue(name, out filename))
|
{
|
log.Debug("Found match for {0} in {1}", name , filename);
|
return loadFrom(filename);
|
}
|
var requestedAsmName = new AssemblyName(name);
|
var requestedStrongNameToken = requestedAsmName.GetPublicKeyToken();
|
var asmName = name.Split(',')[0];
|
|
var asmPaths = FileFinder.FindAssemblies(asmName);
|
|
if (asmPaths != null && asmPaths.Length > 0)
|
{
|
Assembly tryLoad(string filePath)
|
{
|
try
|
{
|
var path = Path.GetFullPath(filePath);
|
log.Debug("Found match for {0} in {1}", name, path);
|
return loadFrom(path);
|
}
|
catch (Exception)
|
{
|
//It was unable to load that specific assembly,
|
// but there might be another version that we can load.
|
return null;
|
}
|
}
|
|
var candidates = asmPaths.Select(p => new MatchingAssembly{Path = p, Name = tryGetAssemblyName(p)}).ToList();
|
if (requestedStrongNameToken != null && requestedStrongNameToken.Length == 8)
|
{
|
// the requested assembly has a strong name, only consider assemblies that has that
|
candidates.RemoveAll(c => false == requestedStrongNameToken.SequenceEqual(c.Name.GetPublicKeyToken()));
|
}
|
|
// The following logic to assembly loading is based on a significant amount of investigation, be careful when altering this.
|
// The approach is to return exact version if it exists, otherwise return the highest version available.
|
// This approach is consistent with how .NET Core resolves dependencies, if not exact version exists.
|
|
|
// Try to find/load an exact match to the requested version:
|
var matchingVersion = candidates.FirstOrDefault(c => c.Name.Version == requestedAsmName.Version);
|
if (matchingVersion.Path != null)
|
{
|
Assembly asm = tryLoad(matchingVersion.Path);
|
if (asm != null)
|
return asm;
|
candidates.Remove(matchingVersion);
|
}
|
|
|
// Try to load any remaining candidates from highest version to lowest:
|
var ordered = candidates.OrderByDescending(c => c.Name.Version);
|
foreach (var c in ordered)
|
{
|
Assembly asm = tryLoad(c.Path);
|
if (asm != null)
|
return asm;
|
}
|
}
|
else
|
{
|
if (asmLookup.TryGetValue(asmName, out filename))
|
{
|
log.Debug("Found match for {0} in {1}", name, filename);
|
var asm = loadFrom(filename);
|
if (asm != null)
|
{
|
if (requestedStrongNameToken != null && requestedStrongNameToken.Length == 8)
|
{
|
if (requestedStrongNameToken.SequenceEqual(asm.GetName().GetPublicKeyToken()) == false)
|
log.Warning("Using Assembly '{0}' as '{1}' (strong name mismatch)", name, asm.FullName);
|
if (asm.GetName().Version < requestedAsmName.Version)
|
log.Warning("Using Assembly '{0}' as '{1}' (version mismatch)", name, asm.FullName);
|
}
|
return asm;
|
}
|
}
|
}
|
}
|
catch
|
{ // unable to resolve, this is OK.
|
|
}
|
log.Debug("Unable to find match for {0}", name);
|
return null;
|
}
|
|
/// <summary>
|
/// This is used instead of a tuple in the above function. Tuples should _not_ be used in the assembly resolving process
|
/// as it sometimes requires assembly resolving to load System.ValueTyple.dll.
|
/// </summary>
|
struct MatchingAssembly
|
{
|
public string Path;
|
public AssemblyName Name;
|
}
|
}
|
|
|
|
/// <summary> This event args expresses when plugins inside PluginManager has changed. This is generally used for cache invalidation purposes.</summary>
|
public class PluginsChangedEventArgs : EventArgs
|
{
|
|
}
|
}
|
