// 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.Concurrent;
|
using System.Collections.Generic;
|
using System.Collections.Immutable;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
using System.Reflection;
|
using System.Reflection.Metadata;
|
using System.Reflection.PortableExecutable;
|
using Tap.Shared;
|
|
[assembly: OpenTap.PluginAssembly(true)]
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Marks an assembly as one containing OpenTAP plugins.
|
/// </summary>
|
[AttributeUsage(AttributeTargets.Assembly)]
|
public class PluginAssemblyAttribute : Attribute
|
{
|
/// <summary>
|
/// Ask the <see cref="PluginSearcher"/> to also look for plugins among the internal types in this assembly (default is to only search in public types).
|
/// </summary>
|
public bool SearchInternalTypes { get; }
|
/// <summary>
|
/// (Optional) Full name of Plugin Init method that gets run before any other code in the plugin. Will only run once.
|
/// Requirement: Must be parameterless public static method returning void inside public static class
|
/// Important note: If init method fails (throws an <see cref="Exception"/>), then NONE of the <see cref="ITapPlugin"/> types will load
|
/// </summary>
|
public string PluginInitMethod { get; }
|
/// <summary>
|
/// Marks an assembly as one containing OpenTAP plugins.
|
/// </summary>
|
/// <param name="SearchInternalTypes">True to ask the <see cref="PluginSearcher"/> to also look for plugins among the internal types in this assembly (default is to only search in public types).</param>
|
public PluginAssemblyAttribute(bool SearchInternalTypes)
|
{
|
this.SearchInternalTypes = SearchInternalTypes;
|
}
|
/// <summary>
|
/// Marks an assembly as one containing OpenTAP plugins.
|
/// </summary>
|
/// <param name="SearchInternalTypes">True to ask the <see cref="PluginSearcher"/> to also look for plugins among the internal types in this assembly (default is to only search in public types).</param>
|
/// <param name="PluginInitMethod">Full name of Plugin Init method (<see cref="PluginInitMethod"/>)</param>
|
public PluginAssemblyAttribute(bool SearchInternalTypes, string PluginInitMethod)
|
{
|
this.SearchInternalTypes = SearchInternalTypes;
|
this.PluginInitMethod = PluginInitMethod;
|
}
|
}
|
|
|
/// <summary>
|
/// Searches assemblies for classes implementing ITapPlugin.
|
/// </summary>
|
public class PluginSearcher
|
{
|
private Options Option { get; set; }
|
|
/// <summary>
|
/// Options for Plugin Searcher.
|
/// </summary>
|
[Flags]
|
public enum Options
|
{
|
/// <summary> No options </summary>
|
None = 0,
|
/// <summary> Allow multiple assemblies with the same name </summary>
|
IncludeSameAssemblies = 1
|
}
|
|
/// <summary>
|
/// Searches assemblies for classes implementing ITapPlugin.
|
/// </summary>
|
public PluginSearcher() { }
|
|
internal PluginSearcher(PluginSearcher copy)
|
{
|
AbsorbLoadedPlugins(copy);
|
if (AllTypes.TryGetValue(PluginMarkerType.Name, out var marker)) PluginMarkerType = marker;
|
}
|
|
/// <summary>
|
/// Searches assemblies for classes implementing ITapPlugin.
|
/// </summary>
|
/// <param name="opts">Option setting for Plugin Searcher.</param>
|
public PluginSearcher(Options opts = Options.None)
|
{
|
Option = opts;
|
}
|
|
private class AssemblyRef
|
{
|
public string Name;
|
public Version Version;
|
|
public AssemblyRef(string name, Version version)
|
{
|
Name = name;
|
Version = version;
|
}
|
|
public override int GetHashCode()
|
{
|
return Name.GetHashCode() * 17 + Version.GetHashCode();
|
}
|
|
public override bool Equals(object obj)
|
{
|
if (obj is AssemblyRef)
|
{
|
var o = obj as AssemblyRef;
|
return (Name==o.Name) && (Version==o.Version);
|
}
|
return base.Equals(obj);
|
}
|
}
|
|
private static readonly TraceSource log = Log.CreateSource("Searcher");
|
class AssemblyDependencyGraph
|
{
|
private Options Option { get; set; }
|
|
public AssemblyDependencyGraph(Options opt)
|
{
|
nameToAsmMap = new Dictionary<AssemblyRef, AssemblyData>();
|
|
nameToAsmMap2 = new Dictionary<string, AssemblyRef>();
|
asmNameToAsmData = new Dictionary<string, AssemblyData>();
|
Assemblies = new List<AssemblyData>();
|
UnfoundAssemblies = new HashSet<AssemblyRef>();
|
|
Option = opt;
|
}
|
|
static string VersionFromFileVersion(FileVersionInfo v)
|
{
|
return $"{v.FileMajorPart}.{v.FileMinorPart}.{v.FileBuildPart}";
|
}
|
|
/// <summary>
|
/// Returns a list of assemblies and their dependencies/references.
|
/// The list is sorted such that a dependency is before the assembly/assemblies that depend on it.
|
/// </summary>
|
public List<AssemblyData> Generate(IEnumerable<string> files)
|
{
|
if (nameToFileMap == null)
|
nameToFileMap = files.ToLookup(Path.GetFileNameWithoutExtension);
|
else
|
{
|
var existingFiles = nameToFileMap.SelectMany(g => g.Select(s => s));
|
nameToFileMap = existingFiles.Concat(files).Distinct().ToLookup(Path.GetFileNameWithoutExtension);
|
}
|
|
// print a warning if the same assembly is loaded more than once.
|
foreach (var entry in nameToFileMap)
|
{
|
var count = entry.Count();
|
if (count == 1) continue;
|
if (entry.Key.EndsWith(".resources") && entry.Key.StartsWith("Microsoft.CodeAnalysis"))
|
continue; // This improves the performance in debug builds, where lots of locale resource files are present.
|
|
var versions = new HashSet<string>();
|
bool allInDependencies = true;
|
foreach (var file in entry)
|
{
|
try
|
{
|
if ((Path.GetDirectoryName(file)?.Contains("Dependencies") ?? false) == false)
|
allInDependencies = false;
|
var fileVersion = FileVersionInfo.GetVersionInfo(file);
|
|
// According to docs fileVersion is never null. Could be set to 0.0.0 though, but this is fine.
|
versions.Add(VersionFromFileVersion(fileVersion));
|
}
|
catch
|
{
|
// Accept errors here, this code is only used to print warnings.
|
}
|
}
|
|
if (allInDependencies) continue; // these were only inside the dependencies folder.
|
if (versions.Count == 1) continue;
|
|
log.Warning("Multiple assemblies of different versions named {0} exists ", entry.Key);
|
|
int i = 0;
|
foreach (var file in entry)
|
{
|
string ver = "unknown";
|
try
|
{
|
ver = VersionFromFileVersion(FileVersionInfo.GetVersionInfo(file));
|
}
|
catch (Exception)
|
{
|
log.Debug("Unable to get version of {0}.", file);
|
}
|
|
log.Debug("Assembly {2}: {0} version: {1}", file, ver, 1 + i++);
|
}
|
}
|
foreach (string file in files)
|
AddAssemblyInfo(file);
|
|
return Assemblies;
|
}
|
|
private List<AssemblyData> Assemblies;
|
private Dictionary<AssemblyRef, AssemblyData> nameToAsmMap;
|
private Dictionary<string, AssemblyRef> nameToAsmMap2;
|
private readonly Dictionary<string, AssemblyData> asmNameToAsmData;
|
private ILookup<string, string> nameToFileMap;
|
HashSet<AssemblyRef> UnfoundAssemblies; // for assemblies that are not in the files.
|
|
ImmutableDictionary<Assembly, AssemblyData> assemblyToAssemblyDataLookup = ImmutableDictionary<Assembly, AssemblyData>.Empty;
|
|
/// <summary>
|
/// Find the AssemblyData for a specific loaded Assembly. If not found, it will analyze it and cache it.
|
/// </summary>
|
internal AssemblyData FindAssemblyData(Assembly asm)
|
{
|
if (!assemblyToAssemblyDataLookup.TryGetValue(asm, out var asmData))
|
{
|
var name = asm.FullName;
|
if (asmNameToAsmData.TryGetValue(name, out var asmData2))
|
{
|
asmData = asmData2;
|
}else if (nameToAsmMap2.TryGetValue(asm.Location?.ToUpper() ?? "", out var asmRef) && nameToAsmMap.TryGetValue(asmRef, out var asmData3))
|
{
|
asmData = asmData3;
|
}
|
|
if (asmData == null)
|
{
|
foreach (var assembly in Assemblies)
|
{
|
if (assembly.GetCached() == asm)
|
{
|
asmData = assembly;
|
break;
|
}
|
}
|
}
|
if (asmData == null)
|
{
|
asmData = AddAssemblyInfo(asm.Location, asm);
|
}
|
assemblyToAssemblyDataLookup = assemblyToAssemblyDataLookup.Add(asm, asmData);
|
}
|
|
return asmData;
|
}
|
|
/// <summary> Manually analyze and add an assembly file. </summary>
|
internal AssemblyData AddAssemblyInfo(string file, Assembly loadedAssembly = null)
|
{
|
var normalizedFile = PathUtils.NormalizePath(file);
|
if (nameToAsmMap2.TryGetValue(normalizedFile, out AssemblyRef asmRef2))
|
{
|
return nameToAsmMap[asmRef2];
|
}
|
try
|
{
|
// This can happen if the plugin was uninstalled.
|
// If the plugin was loaded, it was most likely also searched if we reached this point.
|
if (!File.Exists(file)) return null;
|
if (file.Contains(".resources.dll"))
|
return null;
|
var thisAssembly = new AssemblyData(file, loadedAssembly);
|
|
List<AssemblyRef> refNames = new List<AssemblyRef>();
|
using (FileStream str = new FileStream(file, FileMode.Open, FileAccess.Read))
|
{
|
if(str.Length > int.MaxValue)
|
return null; // otherwise PEReader() will throw.
|
if(str.Length < 50)
|
return null; // Don't consider super small assemblies.
|
using (PEReader header = new PEReader(str, PEStreamOptions.LeaveOpen))
|
{
|
if (!header.HasMetadata)
|
return null;
|
|
MetadataReader metadata = header.GetMetadataReader();
|
AssemblyDefinition def = metadata.GetAssemblyDefinition();
|
|
// if we were asked to only provide distinct assembly names and
|
// this assembly name has already been encountered, just return that.
|
var fileIdentifier = Option.HasFlag(Options.IncludeSameAssemblies) ? file : def.GetAssemblyName().FullName;
|
if (asmNameToAsmData.TryGetValue(fileIdentifier, out AssemblyData data))
|
return data;
|
|
thisAssembly.Name = metadata.GetString(def.Name);
|
|
if (string.Compare(thisAssembly.Name, Path.GetFileNameWithoutExtension(file), true) != 0)
|
throw new Exception("Assembly name does not match the file name.");
|
var thisRef = new AssemblyRef(thisAssembly.Name, def.Version);
|
|
var prov = new CustomAttributeTypeProvider();
|
foreach (CustomAttributeHandle attrHandle in def.GetCustomAttributes())
|
{
|
CustomAttribute attr = metadata.GetCustomAttribute(attrHandle);
|
|
if (attr.Constructor.Kind == HandleKind.MemberReference)
|
{
|
var ctor = metadata.GetMemberReference((MemberReferenceHandle)attr.Constructor);
|
string attributeFullName = GetFullName(metadata, ctor.Parent);
|
if (attributeFullName == typeof(AssemblyInformationalVersionAttribute).FullName)
|
{
|
var valueString = attr.DecodeValue(prov).FixedArguments[0].Value?.ToString();
|
if (SemanticVersion.TryParse(valueString, out _))
|
thisAssembly.RawVersion = valueString;
|
break;
|
}
|
}
|
}
|
|
// If the semantic version was not set, fall back to using the version
|
// from the AssemblyDefinition
|
if (string.IsNullOrWhiteSpace(thisAssembly.RawVersion))
|
{
|
thisAssembly.RawVersion = def.Version.ToString();
|
}
|
|
thisAssembly.Version = def.Version;
|
|
if (!nameToAsmMap.ContainsKey(thisRef))
|
{
|
nameToAsmMap.Add(thisRef, thisAssembly);
|
nameToAsmMap2[PathUtils.NormalizePath(thisAssembly.Location)] = thisRef;
|
}
|
|
asmNameToAsmData[fileIdentifier] = thisAssembly;
|
|
foreach (var asmRefHandle in metadata.AssemblyReferences)
|
{
|
var asmRef = metadata.GetAssemblyReference(asmRefHandle);
|
var name = metadata.GetString(asmRef.Name);
|
var newRef = new AssemblyRef(name, asmRef.Version);
|
if (UnfoundAssemblies.Contains(newRef))
|
{
|
continue;
|
}
|
refNames.Add(new AssemblyRef(name, asmRef.Version));
|
}
|
}
|
|
List<AssemblyData> refList = null;
|
foreach (var refName in refNames)
|
{
|
if (nameToAsmMap.TryGetValue(refName, out AssemblyData asmData2))
|
{
|
if (refList == null) refList = new List<AssemblyData>();
|
refList.Add(asmData2);
|
}
|
else
|
{
|
if (nameToFileMap.Contains(refName.Name))
|
{
|
AssemblyData asm = null;
|
foreach (string file2 in nameToFileMap[refName.Name])
|
{
|
var data = AddAssemblyInfo(file2);
|
if (data == null) continue;
|
if (data.Version == refName.Version)
|
{
|
asm = data;
|
break;
|
}
|
else if (Utils.Compatible(data.Version, refName.Version))
|
{
|
asm = data;
|
}
|
}
|
if (asm != null)
|
{
|
if (refList == null) refList = new List<AssemblyData>();
|
refList.Add(asm);
|
}
|
else
|
{
|
UnfoundAssemblies.Add(refName);
|
}
|
}
|
else
|
{
|
UnfoundAssemblies.Add(refName);
|
}
|
}
|
}
|
thisAssembly.References = (IEnumerable<AssemblyData>) refList ?? Array.Empty<AssemblyData>();
|
Assemblies.Add(thisAssembly);
|
return thisAssembly;
|
}
|
}
|
catch (Exception ex)
|
{
|
// there was an error loading the file. Ignore that file.
|
log.Warning("Skipping assembly '{0}'. {1}", Path.GetFileName(file), ex.Message);
|
log.Debug(ex);
|
return null;
|
}
|
}
|
}
|
|
/// <summary>
|
/// The assemblies found by Search. Ordered such that referenced assemblies come before assemblies that reference them.
|
/// </summary>
|
public IEnumerable<AssemblyData> Assemblies;
|
|
AssemblyDependencyGraph graph = null;
|
|
/// <summary>
|
/// Searches assembly files and returns all the plugin types found in those.
|
/// The search will also populate a complete list of types searched in the AllTypes property
|
/// and all Assemblies found in the Assemblies property.
|
/// Subsequent calls to this method will add to those properties.
|
/// </summary>
|
public IEnumerable<TypeData> Search(string dir)
|
{
|
var finder = new AssemblyFinder() { Quiet = true, IncludeDependencies = true, DirectoriesToSearch = new[] { dir } };
|
IEnumerable<string> files = finder.AllAssemblies();
|
|
return Search(files);
|
}
|
|
|
private readonly object AddAssemblyLock = new();
|
/// <summary> Adds an assembly outside the 'search' context. </summary>
|
internal AssemblyData AddAssembly(string path, Assembly loadedAssembly)
|
{
|
// This fixes a race condition when TypeData.FromType() is called in parallel.
|
lock (AddAssemblyLock)
|
{
|
var asm = graph.AddAssemblyInfo(path, loadedAssembly);
|
PluginsInAssemblyRecursive(asm);
|
return asm;
|
}
|
}
|
|
private TypeData PluginFromPluginRecursive(TypeData type)
|
{
|
if (AllTypes.TryGetValue(type.Name, out var plugin)) return plugin;
|
plugin = type.Clone();
|
|
AllTypes.Add(plugin.Name, plugin);
|
foreach (var oldBaseType in type.BaseTypes ?? [])
|
{
|
var basetype = PluginFromPluginRecursive(oldBaseType);
|
if (basetype != null)
|
{
|
basetype.AddDerivedType(plugin);
|
plugin.AddBaseType(basetype);
|
plugin.AddPluginTypes(basetype.PluginTypes);
|
}
|
}
|
|
foreach (var oldInterfaceType in type.PluginTypes ?? [])
|
{
|
var @interface = PluginFromPluginRecursive(oldInterfaceType);
|
if (@interface != null)
|
{
|
plugin.AddPluginType(@interface);
|
}
|
}
|
|
plugin.FinalizeCreation();
|
|
if (plugin.PluginTypes != null)
|
{
|
PluginTypes.Add(plugin);
|
}
|
|
return plugin;
|
}
|
|
private void AbsorbLoadedPlugins(PluginSearcher searcher)
|
{
|
// The searcher we are currently absorbing can be mutated by calls to e.g. TypeData.FromType()
|
// We need to guard against access to searcher.AllTypes while we are absorbing it.
|
lock (searcher.AddAssemblyLock)
|
{
|
// Create new instances of all the plugins which were already loaded.
|
// This solves problems related to scanning new plugin versions after a package upgrade.
|
// The current process should keep displaying information about the loaded plugin instead of whatever is on disk.
|
TypeData[] alreadyLoaded = [.. searcher.AllTypes.Values.Where(x => x.IsAssemblyLoaded())];
|
foreach (var m in alreadyLoaded)
|
{
|
PluginFromPluginRecursive(m);
|
}
|
}
|
}
|
|
/// <summary>
|
/// Searches assembly files and returns all the plugin types found in those.
|
/// The search will also populate a complete list of types searched in the AllTypes property
|
/// and all Assemblies found in the Assemblies property.
|
/// Subsequent calls to this method will add to those properties.
|
/// </summary>
|
public IEnumerable<TypeData> Search(IEnumerable<string> files)
|
{
|
Stopwatch timer = Stopwatch.StartNew();
|
graph ??= new AssemblyDependencyGraph(Option);
|
Assemblies = graph.Generate(files);
|
log.Debug(timer, "Ordered {0} assemblies according to references.", Assemblies.Count());
|
|
foreach (AssemblyData asm in Assemblies)
|
{
|
PluginsInAssemblyRecursive(asm);
|
}
|
|
return PluginTypes;
|
}
|
|
internal readonly TypeData PluginMarkerType = new TypeData(typeof(ITapPlugin).FullName);
|
|
private void PluginsInAssemblyRecursive(AssemblyData asm)
|
{
|
// This is possible if the package containing the file was uninstalled
|
if (!File.Exists(asm.Location))
|
return;
|
CurrentAsm = asm;
|
ReadPrivateTypesInCurrentAsm = false;
|
TypesInCurrentAsm = new Dictionary<TypeDefinitionHandle, TypeData>();
|
using (FileStream file = new FileStream(asm.Location, FileMode.Open, FileAccess.Read))
|
using (PEReader header = new PEReader(file, PEStreamOptions.LeaveOpen))
|
{
|
CurrentReader = header.GetMetadataReader();
|
|
foreach (CustomAttributeHandle attrHandle in CurrentReader.CustomAttributes)
|
{
|
CustomAttribute attr = CurrentReader.GetCustomAttribute(attrHandle);
|
|
bool isPluginAssemblyAttribute = false;
|
if (attr.Constructor.Kind == HandleKind.MethodDefinition)
|
{
|
MethodDefinition ctor = CurrentReader.GetMethodDefinition((MethodDefinitionHandle)attr.Constructor);
|
isPluginAssemblyAttribute = MatchFullName(CurrentReader, ctor.GetDeclaringType(), "OpenTap", nameof(PluginAssemblyAttribute));
|
}
|
else if (attr.Constructor.Kind == HandleKind.MemberReference)
|
{
|
var ctor = CurrentReader.GetMemberReference((MemberReferenceHandle)attr.Constructor);
|
isPluginAssemblyAttribute = MatchFullName(CurrentReader, ctor.Parent, "OpenTap", nameof(PluginAssemblyAttribute));
|
}
|
if(isPluginAssemblyAttribute)
|
{
|
var valueString = attr.DecodeValue(new CustomAttributeTypeProvider());
|
ReadPrivateTypesInCurrentAsm = (bool)valueString.FixedArguments[0].Value;
|
if (valueString.FixedArguments.Count() > 1)
|
{
|
string initMethodName = valueString.FixedArguments.ElementAt(1).Value.ToString();
|
asm.PluginAssemblyAttribute = new PluginAssemblyAttribute(ReadPrivateTypesInCurrentAsm, initMethodName);
|
}
|
else
|
asm.PluginAssemblyAttribute = new PluginAssemblyAttribute(ReadPrivateTypesInCurrentAsm);
|
break;
|
}
|
}
|
|
foreach (var typeDefHandle in CurrentReader.TypeDefinitions)
|
{
|
try
|
{
|
PluginFromTypeDefRecursive(typeDefHandle);
|
}
|
catch
|
{
|
// fixes an issue in the plugin searcher if it tries to scan an assembly with native types in it.
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// All types found by the search indexed by their SearchAssembly.FullName.
|
/// Null if PluginSearcher.Search has not been called.
|
/// </summary>
|
internal readonly Dictionary<string, TypeData> AllTypes = [];
|
|
/// <summary>
|
/// Types found by the search that implement ITapPlugin.
|
/// Null if PluginSearcher.Search has not been called.
|
/// </summary>
|
internal readonly HashSet<TypeData> PluginTypes = [];
|
|
private AssemblyData CurrentAsm;
|
private bool ReadPrivateTypesInCurrentAsm = false;
|
private Dictionary<TypeDefinitionHandle, TypeData> TypesInCurrentAsm;
|
private MetadataReader CurrentReader;
|
|
|
private TypeData PluginFromEntityRecursive(EntityHandle handle)
|
{
|
switch (handle.Kind)
|
{
|
case HandleKind.TypeReference:
|
return PluginFromTypeRef((TypeReferenceHandle)handle);
|
case HandleKind.TypeDefinition:
|
return PluginFromTypeDefRecursive((TypeDefinitionHandle)handle);
|
case HandleKind.TypeSpecification:
|
var baseSpec = CurrentReader.GetTypeSpecification((TypeSpecificationHandle)handle);
|
try
|
{
|
return baseSpec.DecodeSignature(new SignatureTypeProvider(this), AllTypes);
|
}
|
catch
|
{
|
return null;
|
}
|
default:
|
return null;
|
}
|
}
|
|
private TypeData PluginFromTypeRef(TypeReferenceHandle handle)
|
{
|
string ifaceFullName = GetFullName(CurrentReader,handle);
|
if (AllTypes.TryGetValue(ifaceFullName, out var tp))
|
return tp;
|
return null; // This is not a type that we care about (not defined in any of the files the searcher is given)
|
}
|
|
private static string valueTypeName = typeof(ValueType).FullName;
|
private static readonly ConcurrentDictionary<string, bool> ValueTypeMap = new ConcurrentDictionary<string, bool>();
|
private bool IsValueType(TypeDefinition typeDef, string typeName = null)
|
{
|
|
bool helper(string s)
|
{
|
try
|
{
|
if (s == valueTypeName) return true;
|
|
var baseType = typeDef.BaseType;
|
switch (baseType.Kind)
|
{
|
case HandleKind.TypeReference:
|
var tr = (TypeReferenceHandle)baseType;
|
var r = CurrentReader.GetTypeReference(tr);
|
return CurrentReader.GetString(r.Name) == "ValueType";
|
case HandleKind.TypeDefinition:
|
var td = (TypeDefinitionHandle)baseType;
|
if (td.IsNil) return false;
|
var d = CurrentReader.GetTypeDefinition(td);
|
return IsValueType(d);
|
default:
|
return false;
|
}
|
}
|
catch
|
{
|
// This should be rare, and if the reader can't resolve some base type we can't do anything about it.
|
// Just assume it isn't a valuetype and move on.
|
return false;
|
}
|
}
|
|
typeName ??= GetTypeName(typeDef);
|
return ValueTypeMap.GetOrAdd(typeName, helper);
|
}
|
|
private string GetTypeName(TypeDefinition td)
|
{
|
string typeName;
|
|
TypeDefinitionHandle declaringTypeHandle = td.GetDeclaringType();
|
if (declaringTypeHandle.IsNil)
|
{
|
typeName = string.Format("{0}.{1}", CurrentReader.GetString(td.Namespace),
|
CurrentReader.GetString(td.Name));
|
}
|
else
|
{
|
// This is a nested type
|
TypeData declaringType = PluginFromTypeDefRecursive(declaringTypeHandle);
|
if (declaringType == null)
|
return null;
|
typeName = string.Format("{0}+{1}", declaringType.Name, CurrentReader.GetString(td.Name));
|
}
|
|
return typeName;
|
}
|
|
private static HashSet<string> warnOnceLookup = new HashSet<string>();
|
private TypeData PluginFromTypeDefRecursive(TypeDefinitionHandle handle)
|
{
|
if (TypesInCurrentAsm.TryGetValue(handle, out var result))
|
return result;
|
TypeDefinition typeDef = CurrentReader.GetTypeDefinition(handle);
|
var typeAttributes = typeDef.Attributes;
|
if (ReadPrivateTypesInCurrentAsm)
|
{
|
if ((typeAttributes & TypeAttributes.VisibilityMask) != TypeAttributes.NotPublic &&
|
(typeAttributes & TypeAttributes.VisibilityMask) != TypeAttributes.Public &&
|
(typeAttributes & TypeAttributes.VisibilityMask) != TypeAttributes.NestedPrivate &&
|
(typeAttributes & TypeAttributes.VisibilityMask) != TypeAttributes.NestedPublic)
|
return null;
|
}
|
else
|
{
|
if ((typeAttributes & TypeAttributes.VisibilityMask) != TypeAttributes.Public &&
|
(typeAttributes & TypeAttributes.VisibilityMask) != TypeAttributes.NestedPublic)
|
return null;
|
}
|
|
var typeName = GetTypeName(typeDef);
|
if (typeName == null) return null;
|
if (AllTypes.TryGetValue(typeName, out var existingPlugin))
|
{
|
if (existingPlugin.Assembly.Name == CurrentAsm.Name)
|
{
|
// we assume this is the same plugin, just in another copy of the dll
|
|
// This can happen if you are creating a package with file in a subfoler.
|
// That file will get copied, and we end up with it twice in the installation dir
|
// in that case it is important for the logic in EnumeratePlugins that this assembly also has the plugin types listed.
|
if (existingPlugin.PluginTypes != null &&
|
(CurrentAsm.PluginTypes == null || !CurrentAsm.PluginTypes.Any(t => t.Name == existingPlugin.Name)))
|
{
|
CurrentAsm.AddPluginType(existingPlugin);
|
}
|
}
|
else
|
{
|
// DescendsTo will try to load the plugin. Manually walk the basetypes instead.
|
var basetypes = new Queue<TypeData>();
|
basetypes.Enqueue(existingPlugin);
|
bool isPlugin = false;
|
while (basetypes.Any())
|
{
|
var t = basetypes.Dequeue();
|
if (PluginMarkerType.Equals(t))
|
{
|
isPlugin = true;
|
break;
|
}
|
if (t.BaseTypes != null)
|
{
|
foreach (var bt in t.BaseTypes)
|
{
|
basetypes.Enqueue(bt);
|
}
|
}
|
}
|
if (isPlugin && existingPlugin.IsBrowsable)
|
{
|
var key = $"{typeName}-{existingPlugin.Assembly.Name}-{CurrentAsm.Name}";
|
if (warnOnceLookup.Add(key))
|
{
|
log.Warning($"Plugin with duplicate type name {typeName} defined in '{existingPlugin.Assembly.Name}' and '{CurrentAsm.Name}'");
|
}
|
}
|
}
|
return existingPlugin;
|
}
|
TypeData plugin = new TypeData(typeName);
|
if (plugin.Name == PluginMarkerType.Name)
|
{
|
PluginMarkerType.Assembly = CurrentAsm;
|
PluginMarkerType.TypeAttributes = typeDef.Attributes;
|
AllTypes.Add(PluginMarkerType.Name, PluginMarkerType);
|
TypesInCurrentAsm.Add(handle, PluginMarkerType);
|
CurrentAsm.AddPluginType(PluginMarkerType);
|
return PluginMarkerType;
|
}
|
plugin.TypeAttributes = typeDef.Attributes;
|
plugin.Assembly = CurrentAsm;
|
|
List<string> supportedPlatforms = null;
|
foreach (CustomAttributeHandle attrHandle in typeDef.GetCustomAttributes())
|
{
|
CustomAttribute attr = CurrentReader.GetCustomAttribute(attrHandle);
|
string attributeFullName = "";
|
if (attr.Constructor.Kind == HandleKind.MethodDefinition)
|
{
|
MethodDefinition ctor =
|
CurrentReader.GetMethodDefinition((MethodDefinitionHandle) attr.Constructor);
|
attributeFullName = GetFullName(CurrentReader, ctor.GetDeclaringType());
|
|
}
|
else if (attr.Constructor.Kind == HandleKind.MemberReference)
|
{
|
var ctor = CurrentReader.GetMemberReference((MemberReferenceHandle) attr.Constructor);
|
attributeFullName = GetFullName(CurrentReader, ctor.Parent);
|
}
|
|
switch (attributeFullName)
|
{
|
case "System.Runtime.Versioning.SupportedOSPlatformAttribute":
|
{
|
var valueString = attr.DecodeValue(new CustomAttributeTypeProvider(AllTypes));
|
if (valueString.FixedArguments.Length == 1 && valueString.FixedArguments[0].Value is string platform)
|
{
|
supportedPlatforms ??= [];
|
supportedPlatforms.Add(platform);
|
}
|
}
|
break;
|
case "OpenTap.DisplayAttribute":
|
{
|
var valueString = attr.DecodeValue(new CustomAttributeTypeProvider(AllTypes));
|
string displayName =
|
GetStringIfNotNull(valueString.FixedArguments[0]
|
.Value); // the first argument to the DisplayAttribute constructor is the display name
|
string displayDescription = GetStringIfNotNull(valueString.FixedArguments[1].Value);
|
string displayGroup = GetStringIfNotNull(valueString.FixedArguments[2].Value);
|
double displayOrder = (double)valueString.FixedArguments[3].Value;
|
bool displayCollapsed = bool.Parse(GetStringIfNotNull(valueString.FixedArguments[4].Value));
|
string[] displayGroups = GetStringArrayIfNotNull(valueString.FixedArguments[5].Value);
|
DisplayAttribute attrInstance = new DisplayAttribute(displayName, displayDescription,
|
displayGroup, displayOrder, displayCollapsed, displayGroups);
|
plugin.Display = attrInstance;
|
}
|
break;
|
case "OpenTap.HelpLinkAttribute":
|
{
|
var valueString = attr.DecodeValue(new CustomAttributeTypeProvider(AllTypes));
|
if (valueString.FixedArguments.Length == 1 && valueString.FixedArguments[0].Value is string helpLink)
|
{
|
plugin.HelpLink = new HelpLinkAttribute(helpLink);
|
}
|
else
|
{
|
plugin.HelpLink = new HelpLinkAttribute();
|
}
|
}
|
break;
|
case "System.ComponentModel.BrowsableAttribute":
|
{
|
var valueString = attr.DecodeValue(new CustomAttributeTypeProvider());
|
plugin.IsBrowsable = bool.Parse(valueString.FixedArguments.First().Value.ToString());
|
}
|
break;
|
default:
|
break;
|
}
|
}
|
|
// If the plugin type is not compatible with this platform, don't add it.
|
if (supportedPlatforms != null)
|
{
|
bool supported = supportedPlatforms.Any(platform =>
|
{
|
var cmp = StringComparison.OrdinalIgnoreCase;
|
if (platform.StartsWith("windows", cmp)) return OperatingSystem.Current == OperatingSystem.Windows;
|
if (platform.StartsWith("linux", cmp)) return OperatingSystem.Current == OperatingSystem.Linux;
|
if (platform.StartsWith("macos", cmp)) return OperatingSystem.Current == OperatingSystem.MacOS;
|
if (platform.StartsWith("osx", cmp)) return OperatingSystem.Current == OperatingSystem.MacOS;
|
return false;
|
});
|
if (!supported) return null;
|
}
|
|
TypesInCurrentAsm.Add(handle, plugin);
|
AllTypes.Add(plugin.Name, plugin);
|
if (!typeDef.BaseType.IsNil)
|
{
|
TypeData baseType = PluginFromEntityRecursive(typeDef.BaseType);
|
if (baseType != null)
|
{
|
baseType.AddDerivedType(plugin);
|
plugin.AddBaseType(baseType);
|
plugin.AddPluginTypes(baseType.PluginTypes);
|
}
|
}
|
|
foreach (InterfaceImplementationHandle ifaceHandle in typeDef.GetInterfaceImplementations())
|
{
|
EntityHandle ifaceEntity = CurrentReader.GetInterfaceImplementation(ifaceHandle).Interface;
|
TypeData iface = PluginFromEntityRecursive(ifaceEntity);
|
if (iface == null)
|
continue;
|
iface.AddDerivedType(plugin);
|
plugin.AddBaseType(iface);
|
plugin.AddPluginTypes(iface.PluginTypes);
|
if (iface.Name == PluginMarkerType.Name && plugin.PluginTypes == null)
|
{
|
plugin.AddPluginType(plugin); // this inherits directly from ITapPlugin (otherwise it should have been picked up earlier)
|
}
|
}
|
plugin.FinalizeCreation();
|
|
// Check if the type is constructable by inspecting the available constructors
|
if (plugin.createInstanceSet == false)
|
{
|
// Abstract types and interfaces cannot be instantiated
|
if (typeAttributes.HasFlag(TypeAttributes.Interface) || typeAttributes.HasFlag(TypeAttributes.Abstract))
|
{
|
plugin.CanCreateInstance = false;
|
}
|
// It is not possible to instantiate types if they have unresolved generic parameters.
|
// Since we are currently reflecing an unloaded assembly, it is impossible for generic parameters
|
// to be resolved. If there are generic parameters, this typedata must therefore be unconstroctable.
|
// Once the type is actually loaded, whether an instance can be created for resolved instances
|
// of this type will be computed differently in the TypeData implementation.
|
else if (typeDef.GetGenericParameters().Count != 0)
|
{
|
plugin.CanCreateInstance = false;
|
}
|
else if (IsValueType(typeDef, typeName))
|
{
|
plugin.CanCreateInstance = true;
|
}
|
else
|
{
|
// The type can only be instantiated if it has a parameter-less constructor which does not require type arguments
|
bool hasGenericParameters(MethodDefinition m)
|
{
|
return m.GetGenericParameters().Count > 0;
|
}
|
|
bool hasParameters(MethodDefinition m)
|
{
|
return m.GetParameters().Count > 0;
|
}
|
|
foreach (var methodHandle in typeDef.GetMethods())
|
{
|
var m = CurrentReader.GetMethodDefinition(methodHandle);
|
|
// This method is applicable if it is public, non-static, and has the RTSpecialName attribute
|
// The RTSpecialName attribute means that the method has a special significance explained by its name.
|
// All constructors will have this attribute, but most user-defined methods will not.
|
var attributes = m.Attributes;
|
var applicable = attributes.HasFlag(MethodAttributes.Public) &&
|
attributes.HasFlag(MethodAttributes.Static) == false &&
|
attributes.HasFlag(MethodAttributes.RTSpecialName);
|
|
if (!applicable)
|
continue;
|
|
if (CurrentReader.GetString(m.Name) != ".ctor")
|
continue;
|
|
if (hasGenericParameters(m) || hasParameters(m))
|
{
|
plugin.CanCreateInstance = false;
|
continue;
|
}
|
|
// We know that the type is constructable, so we can stop searching.
|
plugin.CanCreateInstance = true;
|
break;
|
}
|
}
|
}
|
|
if (plugin.PluginTypes != null)
|
{
|
PluginTypes.Add(plugin);
|
CurrentAsm.AddPluginType(plugin);
|
|
if(plugin.Assembly.RawVersion == null)
|
{
|
foreach (CustomAttributeHandle attrHandle in CurrentReader.GetAssemblyDefinition().GetCustomAttributes())
|
{
|
CustomAttribute attr = CurrentReader.GetCustomAttribute(attrHandle);
|
|
if (attr.Constructor.Kind == HandleKind.MemberReference)
|
{
|
var ctor = CurrentReader.GetMemberReference((MemberReferenceHandle)attr.Constructor);
|
string attributeFullName = GetFullName(CurrentReader, ctor.Parent);
|
if(attributeFullName == typeof(AssemblyInformationalVersionAttribute).FullName)
|
{
|
var valueString = attr.DecodeValue(new CustomAttributeTypeProvider(AllTypes));
|
plugin.Assembly.RawVersion = GetStringIfNotNull(valueString.FixedArguments[0].Value);
|
}
|
}
|
}
|
}
|
}
|
return plugin;
|
}
|
|
private static string GetStringIfNotNull(object obj)
|
{
|
return obj?.ToString();
|
}
|
|
private static string[] GetStringArrayIfNotNull(object obj)
|
{
|
if (obj == null)
|
return null;
|
return (obj as IEnumerable<CustomAttributeTypedArgument<TypeData>>).Select(o => o.Value.ToString()).ToArray();
|
}
|
|
/// <summary>
|
/// Helper to get the full name (namespace + name) of the type referenced by a TypeDefinitionHandle or TypeReferenceHandle
|
/// </summary>
|
static string GetFullName(MetadataReader metadata, EntityHandle handle)
|
{
|
switch (handle.Kind)
|
{
|
case HandleKind.TypeDefinition:
|
var def = metadata.GetTypeDefinition((TypeDefinitionHandle)handle);
|
return String.Format("{0}.{1}", metadata.GetString(def.Namespace), metadata.GetString(def.Name));
|
case HandleKind.TypeReference:
|
var r = metadata.GetTypeReference((TypeReferenceHandle)handle);
|
return String.Format("{0}.{1}", metadata.GetString(r.Namespace), metadata.GetString(r.Name));
|
//case HandleKind.TypeSpecification:
|
// var s = metadata.GetTypeSpecification((TypeSpecificationHandle)handle);
|
// s.DecodeSignature(new CustomAttributeTypeProvider(), null);
|
// return new PluginType ();
|
default:
|
return null;
|
}
|
}
|
|
bool MatchFullName(MetadataReader metadata, EntityHandle handle, string matchNamespace, string matchName)
|
{
|
switch (handle.Kind)
|
{
|
case HandleKind.TypeDefinition:
|
var def = metadata.GetTypeDefinition((TypeDefinitionHandle)handle);
|
return metadata.GetString(def.Namespace) == matchNamespace && metadata.GetString(def.Name) == matchName;
|
case HandleKind.TypeReference:
|
var r = metadata.GetTypeReference((TypeReferenceHandle)handle);
|
return metadata.GetString(r.Namespace) == matchNamespace && metadata.GetString(r.Name) == matchName;
|
default:
|
return false;
|
}
|
}
|
|
#region Providers needed by the Metadata API (not really important the way we use the API)
|
struct CustomAttributeTypeProvider : ICustomAttributeTypeProvider<TypeData>
|
{
|
private Dictionary<string, TypeData> _types;
|
|
public CustomAttributeTypeProvider(Dictionary<string, TypeData> types)
|
{
|
_types = types;
|
}
|
|
public TypeData GetPrimitiveType(PrimitiveTypeCode typeCode)
|
{
|
return null;
|
}
|
|
public TypeData GetSystemType()
|
{
|
return _types["System.Type"];
|
}
|
|
public TypeData GetSZArrayType(TypeData elementType)
|
{
|
return null;
|
}
|
|
public TypeData GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind)
|
{
|
string fullName = GetFullName(reader,handle);
|
return _types[fullName];
|
}
|
|
public TypeData GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
|
{
|
string fullName = GetFullName(reader, handle);
|
return _types[fullName];
|
}
|
|
public TypeData GetTypeFromSerializedName(string name)
|
{
|
if (name == null)
|
return null;
|
|
return _types[name];
|
}
|
|
public PrimitiveTypeCode GetUnderlyingEnumType(TypeData type)
|
{
|
throw new NotImplementedException();
|
}
|
|
public bool IsSystemType(TypeData type)
|
{
|
return type.Name == "System.Type";
|
}
|
}
|
|
class SignatureTypeProvider : ISignatureTypeProvider<TypeData, Dictionary<string, TypeData>>
|
{
|
private readonly PluginSearcher _Searcher;
|
public SignatureTypeProvider(PluginSearcher searcher)
|
{
|
_Searcher = searcher;
|
}
|
|
public TypeData GetArrayType(TypeData elementType, ArrayShape shape)
|
{
|
throw new NotImplementedException();
|
}
|
|
public TypeData GetByReferenceType(TypeData elementType)
|
{
|
throw new NotImplementedException();
|
}
|
|
public TypeData GetFunctionPointerType(MethodSignature<TypeData> signature)
|
{
|
throw new NotImplementedException();
|
}
|
|
public TypeData GetGenericInstantiation(TypeData genericType, ImmutableArray<TypeData> typeArguments)
|
{
|
return genericType;
|
}
|
|
public TypeData GetGenericMethodParameter(Dictionary<string, TypeData> genericContext, int index)
|
{
|
throw new NotImplementedException();
|
}
|
|
public TypeData GetGenericTypeParameter(Dictionary<string, TypeData> genericContext, int index)
|
{
|
return null;
|
}
|
|
public TypeData GetModifiedType(TypeData modifier, TypeData unmodifiedType, bool isRequired)
|
{
|
throw new NotImplementedException();
|
}
|
|
public TypeData GetPinnedType(TypeData elementType)
|
{
|
throw new NotImplementedException();
|
}
|
|
public TypeData GetPointerType(TypeData elementType)
|
{
|
throw new NotImplementedException();
|
}
|
|
public TypeData GetPrimitiveType(PrimitiveTypeCode typeCode)
|
{
|
return new TypeData("System." + typeCode);
|
}
|
|
public TypeData GetSZArrayType(TypeData elementType)
|
{
|
return elementType != null ? new TypeData(elementType.Name) : null;
|
}
|
|
public TypeData GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind)
|
{
|
return _Searcher.PluginFromTypeDefRecursive(handle);
|
}
|
|
public TypeData GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
|
{
|
return _Searcher.PluginFromTypeRef(handle);
|
}
|
|
public TypeData GetTypeFromSpecification(MetadataReader reader, Dictionary<string, TypeData> genericContext, TypeSpecificationHandle handle, byte rawTypeKind)
|
{
|
throw new NotImplementedException();
|
}
|
}
|
#endregion
|
internal AssemblyData GetAssemblyData(Assembly asm) => graph.FindAssemblyData(asm);
|
|
}
|
}
|
