using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
using System.Reflection;
|
using System.Text;
|
using Tap.Shared;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Representation of an assembly including its dependencies. Part of the object model used in the PluginManager
|
/// </summary>
|
[DebuggerDisplay("{Name} ({Location})")]
|
public class AssemblyData : ITypeDataSource
|
{
|
private static readonly TraceSource log = Log.CreateSource("AssemblyData");
|
/// <summary>
|
/// The name of the assembly. This is the same as the filename without extension
|
/// </summary>
|
public string Name { get; internal set; }
|
|
/// <summary>
|
/// The file from which this assembly can be loaded. The information contained in this AssemblyData object comes from this file.
|
/// </summary>
|
public string Location { get; }
|
|
/// <summary> Gets the attributes of this .net assembly. </summary>
|
public IEnumerable<object> Attributes => Load()?.GetCustomAttributes() ?? Enumerable.Empty<object>();
|
|
IEnumerable<ITypeData> ITypeDataSource.Types => PluginTypes;
|
|
/// <summary>
|
/// <see cref="PluginAssemblyAttribute"/> decorating assembly, if included
|
/// </summary>
|
public PluginAssemblyAttribute PluginAssemblyAttribute { get; internal set; }
|
|
/// <summary>
|
/// A list of Assemblies that this Assembly references.
|
/// </summary>
|
public IEnumerable<AssemblyData> References { get; internal set; }
|
|
IEnumerable<ITypeDataSource> ITypeDataSource.References => References;
|
|
List<TypeData> pluginTypes;
|
|
/// <summary>
|
/// Gets a list of plugin types that this Assembly defines
|
/// </summary>
|
public IEnumerable<TypeData> PluginTypes => pluginTypes;
|
|
internal void AddPluginType(TypeData typename)
|
{
|
if (typename == null)
|
return;
|
if (pluginTypes == null)
|
pluginTypes = new List<TypeData>();
|
pluginTypes.Add(typename);
|
}
|
|
/// <summary> The loaded state of the assembly. </summary>
|
internal LoadStatus Status => assembly != null ? LoadStatus.Loaded : (failedLoad ? LoadStatus.FailedToLoad : LoadStatus.NotLoaded);
|
|
/// <summary>
|
/// Gets the version of this Assembly. This will return null if the version cannot be parsed.
|
/// </summary>
|
public Version Version { get; internal set; } = null;
|
|
// NoSemanticVersion - marker version instead of null to show that no version has been parsed. Null is a valid value for version.
|
static readonly SemanticVersion NoSemanticVersion = new SemanticVersion(-1, 0, 0, "", "invalidversion");
|
|
SemanticVersion semanticVersion = NoSemanticVersion;
|
|
/// <summary>
|
/// Gets the version of this Assembly as a <see cref="SemanticVersion"/>. Will return null if the version is not well formatted.
|
/// </summary>
|
public SemanticVersion SemanticVersion
|
{
|
get
|
{
|
if (ReferenceEquals(semanticVersion, NoSemanticVersion))
|
{
|
if (SemanticVersion.TryParse(RawVersion, out var version))
|
semanticVersion = version;
|
else if (Version != null)
|
semanticVersion = new SemanticVersion(Version.Major, Version.Minor, Version.Revision, null, null);
|
else
|
semanticVersion = null;
|
}
|
|
return semanticVersion;
|
}
|
}
|
|
string ITypeDataSource.Version => RawVersion;
|
|
/// <summary> Raw version as set by the assembly. </summary>
|
internal string RawVersion { get; set; }
|
|
internal AssemblyData(string location, Assembly preloadedAssembly = null)
|
{
|
Location = location;
|
this.preloadedAssembly = preloadedAssembly;
|
}
|
|
/// <summary> Optionally set for preloaded assemblies. </summary>
|
readonly Assembly preloadedAssembly;
|
Assembly assembly;
|
|
bool failedLoad;
|
|
/// <summary> Gets the assembly without loading it.</summary>
|
internal Assembly GetCached() => assembly ?? preloadedAssembly;
|
|
/// <summary> Check if the assembly is loaded. </summary>
|
internal bool IsLoaded() => (assembly ?? preloadedAssembly) != null;
|
|
/// <summary>
|
/// Returns the System.Reflection.Assembly corresponding to this.
|
/// If the assembly has not yet been loaded, this call will load it.
|
/// </summary>
|
public Assembly Load()
|
{
|
if (failedLoad)
|
return null;
|
if (assembly == null)
|
{
|
try
|
{
|
var watch = Stopwatch.StartNew();
|
if (preloadedAssembly != null)
|
assembly = preloadedAssembly;
|
else
|
{
|
var _asm = AppDomain.CurrentDomain.GetAssemblies()
|
.FirstOrDefault(asm => !asm.IsDynamic && !string.IsNullOrWhiteSpace(asm.Location) && PathUtils.AreEqual(asm.Location, this.Location));
|
assembly = _asm;
|
}
|
|
if (assembly == null)
|
{
|
if (this.Name == "OpenTap")
|
{
|
assembly = typeof(PluginSearcher).Assembly;
|
}
|
else
|
{
|
assembly = Assembly.LoadFrom(Path.GetFullPath(this.Location));
|
}
|
}
|
|
try
|
{
|
// Find attribute
|
if (PluginAssemblyAttribute != null && PluginAssemblyAttribute.PluginInitMethod != null)
|
{
|
string fullName = PluginAssemblyAttribute.PluginInitMethod;
|
// Break into namespace, class, and method name
|
string[] names = fullName.Split('.');
|
if (names.Count() < 3)
|
throw new Exception($"Could not find method {fullName} in assembly: {Location}");
|
string methodName = names.Last();
|
string className = names.ElementAt(names.Count() - 2);
|
string namespacePath = string.Join(".", names.Take(names.Count() - 2));
|
Type initClass = assembly.GetType($"{namespacePath}.{className}");
|
// Check if loaded class exists and is static (abstract and sealed) and is public
|
if (initClass == null || !initClass.IsClass || !initClass.IsAbstract || !initClass.IsSealed || !initClass.IsPublic)
|
throw new Exception($"Could not find method {fullName} in assembly: {Location}");
|
MethodInfo initMethod = initClass.GetMethod(methodName);
|
// Check if loaded method exists and is static and returns void and is public
|
if (initMethod == null || !initMethod.IsStatic || initMethod.ReturnType != typeof(void) || !initMethod.IsPublic)
|
throw new Exception($"Could not find method {fullName} in assembly: {Location}");
|
// Invoke the method and unwrap the InnerException to get meaningful error message
|
try
|
{
|
initMethod.Invoke(null, null);
|
}
|
catch (TargetInvocationException exc)
|
{
|
throw exc.InnerException;
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
failedLoad = true;
|
assembly = null;
|
log.Error($"Failed to load plugins from {this.Location}");
|
log.Debug(ex);
|
|
return null;
|
}
|
log.Debug(watch, "Loaded {0}.", this.Name);
|
}
|
catch (SystemException ex)
|
{
|
failedLoad = true;
|
StringBuilder sb = new StringBuilder(String.Format("Failed to load plugins from {0}", this.Location));
|
bool addedZoneInfo = false;
|
try
|
{
|
var zonetype = Type.GetType("System.Security.Policy.Zone");
|
if (zonetype != null)
|
{
|
// Hack to support .net core without having to build separate assemblies.
|
dynamic zone = zonetype.GetMethod("CreateFromUrl").Invoke(null, new object[] { this.Location });
|
var sec = zone.SecurityZone.ToString();
|
if (sec.Contains("Internet") || sec.Contains("Untrusted"))
|
|
{
|
// The file is in an NTFS Windows operating system blocked state
|
sb.Append(" The file came from another computer and might be blocked to help protect this computer. Please unblock the file in Windows.");
|
addedZoneInfo = true;
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
log.Error("Failed to check Security policy for file.");
|
log.Debug(e);
|
addedZoneInfo = true;
|
}
|
|
if (!addedZoneInfo)
|
sb.Append(" Error: " + ex.Message);
|
log.Error(sb.ToString());
|
log.Debug(ex);
|
}
|
}
|
return assembly;
|
}
|
|
/// <summary> Returns name and version as a string. </summary>
|
public override string ToString() => $"{Name}, {RawVersion}";
|
}
|
}
|
