// 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.IO;
|
using System.Linq;
|
using System.Reflection;
|
using System.Text;
|
using System.Text.RegularExpressions;
|
using System.Xml;
|
using System.Xml.Linq;
|
using DotNet.Globbing;
|
using DotNet.Globbing.Token;
|
using Microsoft.Build.Framework;
|
using Microsoft.Build.Utilities;
|
using Task = Microsoft.Build.Utilities.Task;
|
|
namespace Keysight.OpenTap.Sdk.MSBuild
|
{
|
internal class GlobWrapper : IComparable<GlobWrapper>
|
{
|
internal bool Include { get; }
|
|
private static GlobOptions _globOptions = new DotNet.Globbing.GlobOptions
|
{Evaluation = {CaseInsensitive = false}};
|
|
internal Glob Globber { get; }
|
|
internal GlobWrapper(string pattern, bool include)
|
{
|
Include = include;
|
Globber = Glob.Parse(pattern, _globOptions);
|
}
|
|
public int CompareTo(GlobWrapper other)
|
{
|
bool isLiteral(Glob glob)
|
{
|
var pattern = glob.ToString();
|
return ((pattern.EndsWith(".dll") || pattern.EndsWith(".dll$")) && !(pattern.EndsWith("*.dll") || pattern.EndsWith("*.dll$"))) ||
|
glob.Tokens.All(x => x is LiteralToken);
|
}
|
|
var t1IsLiteral = isLiteral(Globber);
|
var t2IsLiteral = isLiteral(other.Globber);
|
|
// If one is literal, put it before the other;
|
if (t1IsLiteral || t2IsLiteral)
|
{
|
var literalComp = t2IsLiteral.CompareTo(t1IsLiteral);
|
if (literalComp != 0)
|
return literalComp;
|
}
|
|
// Otherwise, put the one with the most tokens first
|
var lengthComp = other.Globber.Tokens.Length.CompareTo(Globber.Tokens.Length);
|
if (lengthComp != 0)
|
return lengthComp;
|
|
// Put includes before excludes in case of ties
|
return other.Include.CompareTo(Include);
|
}
|
}
|
|
internal class GlobTask
|
{
|
internal void LogWarningWithLineNumber(string msg)
|
{
|
Owner.LogWarningWithLineNumber(msg, TaskItem);
|
}
|
internal List<GlobWrapper> Globs { get; }
|
|
internal static List<GlobTask> Parse(ITaskItem[] tasks,
|
AddAssemblyReferencesFromPackage caller)
|
{
|
var result = new List<GlobTask>();
|
|
foreach (var task in tasks)
|
{
|
var includeAssemblies = task.GetMetadata("IncludeAssemblies");
|
var excludeAssemblies = task.GetMetadata("ExcludeAssemblies");
|
|
|
var includeGlobs = string.IsNullOrWhiteSpace(includeAssemblies)
|
? new[] {DefaultInclude}
|
: includeAssemblies.Split(':', ';');
|
var excludeGlobs = string.IsNullOrWhiteSpace(excludeAssemblies)
|
? new[] {DefaultExclude}
|
: excludeAssemblies.Split(':', ';');
|
|
result.Add(new GlobTask(task, includeGlobs, excludeGlobs, caller));
|
}
|
|
return result;
|
}
|
|
internal const string DefaultExclude = "Dependencies/**";
|
|
internal const string DefaultInclude = "**";
|
|
internal string PackageName { get; }
|
private ITaskItem TaskItem { get; }
|
private AddAssemblyReferencesFromPackage Owner { get; set; }
|
|
private GlobTask(ITaskItem item, IEnumerable<string> includePatterns, IEnumerable<string> excludePatterns,
|
AddAssemblyReferencesFromPackage owner)
|
{
|
this.Owner = owner;
|
TaskItem = item;
|
PackageName = item.ItemSpec;
|
includePatterns = includePatterns.Distinct().Where(x => !string.IsNullOrWhiteSpace(x));
|
excludePatterns = excludePatterns.Distinct().Where(x => !string.IsNullOrWhiteSpace(x));
|
Globs = includePatterns.Select(x => new GlobWrapper(x, true)).Concat(
|
excludePatterns.Select(x => new GlobWrapper(x, false))).ToList();
|
Globs.Sort();
|
}
|
|
internal bool Includes(string file, TaskLoggingHelper log)
|
{
|
foreach (var glob in Globs)
|
{
|
try
|
{
|
if (glob.Globber.IsMatch(file))
|
{
|
return glob.Include;
|
}
|
}
|
catch (IndexOutOfRangeException)
|
{
|
log.LogError(null, "OpenTAP Reference", null,
|
Owner.SourceFile, Owner.GetLineNumber(TaskItem), 0, 0, 0,
|
$"Error in glob pattern {glob.Globber} when testing against '{file}'");
|
}
|
}
|
|
// Default to excluding something that isn't explicitly included;
|
// Note that everything is "explicitly included" when no patterns are specified, since we then default to including the "**" pattern
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// MSBuild Task to help package plugin. This task is used by the OpenTAP SDK project template
|
/// </summary>
|
[Serializable]
|
public class AddAssemblyReferencesFromPackage : Task
|
{
|
private XElement _document;
|
private BuildVariableExpander Expander { get; set; }
|
|
internal XElement Document
|
{
|
get
|
{
|
if (_document != null)
|
return _document;
|
|
var expander = new BuildVariableExpander(SourceFile);
|
// Expand all the build variables in the document to accurately identify which element corresponds to 'item'
|
_document = XElement.Parse(expander.ExpandBuildVariables(File.ReadAllText(SourceFile)),
|
LoadOptions.SetLineInfo);
|
return _document;
|
}
|
}
|
|
internal void LogWarningWithLineNumber(string msg, ITaskItem item)
|
{
|
Log.LogWarning(null, "OpenTAP Reference", null,
|
SourceFile, GetLineNumber(item), 0, 0, 0, msg);
|
}
|
internal int GetLineNumber(ITaskItem item)
|
{
|
try
|
{
|
var packageName = item.ItemSpec;
|
var version = item.GetMetadata("Version");
|
var repository = item.GetMetadata("Repository");
|
var includeAssemblies = item.GetMetadata("IncludeAssemblies");
|
var excludeAssemblies = item.GetMetadata("ExcludeAssemblies");
|
|
includeAssemblies = string.IsNullOrWhiteSpace(includeAssemblies)
|
? GlobTask.DefaultInclude
|
: includeAssemblies;
|
excludeAssemblies = string.IsNullOrWhiteSpace(excludeAssemblies)
|
? GlobTask.DefaultExclude
|
: excludeAssemblies;
|
|
foreach (var elem in Document.GetPackageElements(packageName))
|
{
|
if (elem is IXmlLineInfo lineInfo && lineInfo.HasLineInfo())
|
{
|
var elemVersion = elem.ElemOrAttributeValue("Version", "");
|
var elemRepo = elem.ElemOrAttributeValue("Repository", "");
|
var elemIncludeAssemblies =
|
elem.ElemOrAttributeValue("IncludeAssemblies", GlobTask.DefaultInclude);
|
var elemExcludeAssemblies =
|
elem.ElemOrAttributeValue("ExcludeAssemblies", GlobTask.DefaultExclude);
|
|
if (elemVersion != version ||
|
elemRepo != repository ||
|
elemIncludeAssemblies != includeAssemblies ||
|
elemExcludeAssemblies != excludeAssemblies)
|
continue;
|
|
return lineInfo.LineNumber;
|
}
|
}
|
}
|
catch
|
{
|
// Ignore exception
|
}
|
|
return 0;
|
}
|
public string SourceFile { get; set; }
|
public AddAssemblyReferencesFromPackage()
|
{
|
_added = new HashSet<string>();
|
}
|
private HashSet<string> _added;
|
private Regex dllRx = new Regex("<File +.*Path=\"(?<name>.+\\.dll)\"");
|
|
[Output]
|
public string[] Assemblies { get; set; }
|
|
[Required]
|
public string PackageInstallDir { get; set; }
|
|
public string TargetMsBuildFile { get; set; }
|
public ITaskItem[] OpenTapPackagesToReference { get; set; }
|
|
private StringBuilder Result { get; } = new StringBuilder();
|
|
private void Write()
|
{
|
using (var writer = File.CreateText(TargetMsBuildFile))
|
{
|
writer.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>");
|
writer.WriteLine(
|
"<Project ToolsVersion=\"14.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">");
|
writer.Write(Result.ToString());
|
writer.WriteLine("</Project>");
|
}
|
}
|
|
/// <summary>
|
/// Get the preferred path separator, based on what is used in the expansion of '$(OutDir)'.
|
/// This is necessary because dotnet core throws up in certain circumstances when path separators are repeatedly flipped
|
/// </summary>
|
private string Separator { get; set; }
|
private bool ShouldAppendSeparator { get; set; }
|
|
private void WriteItemGroup(IEnumerable<string> assembliesInPackage)
|
{
|
Result.AppendLine(" <ItemGroup>");
|
|
var OutDir = "$(OutDir)";
|
if (ShouldAppendSeparator) OutDir += Separator;
|
|
foreach (var asmPath in assembliesInPackage)
|
{
|
// Replace all path separators the preferred path separator based on '$(OutDir)'.
|
var asm = Separator == "\\" ? asmPath.Replace("/", Separator) : asmPath.Replace("\\", Separator);
|
|
Result.AppendLine($" <Reference Include=\"{Path.GetFileNameWithoutExtension(asmPath)}\">");
|
Result.AppendLine($" <HintPath>{OutDir}{asm}</HintPath>");
|
Result.AppendLine(" </Reference>");
|
}
|
|
Result.AppendLine(" </ItemGroup>");
|
}
|
|
public override bool Execute()
|
{
|
if (OpenTapPackagesToReference == null || OpenTapPackagesToReference.Length == 0)
|
{ // This happens when a .csproj file does not specify any OpenTapPackageReferences -- simply ignore it
|
Write(); // write an "empty" file in this case, so msbuild does not think that the task failed, and re runs it endlessly
|
Log.LogMessage("Got 0 OpenTapPackageReference targets.");
|
return true;
|
}
|
|
|
// Compute some values related to path separators in the generated props file
|
{
|
Expander = new BuildVariableExpander(SourceFile);
|
string[] pathSeparators = { "\\", "/" };
|
var outDir = Expander.ExpandBuildVariables("$(OutDir)");
|
// A separator should be appended if '$(OutDir)' does not end with a path separator already
|
ShouldAppendSeparator = pathSeparators.Contains(outDir.Last().ToString()) == false;
|
if (ShouldAppendSeparator)
|
{
|
// If it does not end with a path separator, use the last path separator in '$(OutDir)' as the separator.
|
var separatorCharIndex = pathSeparators.Max(outDir.LastIndexOf);
|
Separator = separatorCharIndex > -1 ? outDir[separatorCharIndex].ToString() : "/";
|
}
|
else Separator = "/";
|
}
|
|
if (TargetMsBuildFile == null)
|
throw new Exception("TargetMsBuildFile is null");
|
|
// Task instances are sometimes reused by the build engine -- ensure 'document' is reinstantiated
|
_document = null;
|
|
Assemblies = new string[] { };
|
try
|
{
|
// Distincting the tasks is not necessary, but it is a much more helpful warning than
|
// 'No references added from package' which would be given in 'HandlePackage'.
|
var distinctTasks = new List<ITaskItem>(OpenTapPackagesToReference.Length);
|
foreach (var task in OpenTapPackagesToReference)
|
{
|
if (distinctTasks.Contains(task))
|
LogWarningWithLineNumber($"Duplicate entry detected.", task);
|
else
|
{
|
distinctTasks.Add(task);
|
}
|
}
|
|
if (distinctTasks.Count != OpenTapPackagesToReference.Length)
|
Log.LogWarning("Skipped duplicate entries.");
|
|
var globTasks = GlobTask.Parse(distinctTasks.ToArray(), this);
|
Log.LogMessage($"Got {globTasks.Count} OpenTapPackageReference targets.");
|
|
foreach (var task in globTasks)
|
{
|
var includeGlobs = task.Globs.Where(x => x.Include).Select(x => x.Globber.ToString());
|
var excludeGlobs = task.Globs.Where(x => x.Include == false).Select(x => x.Globber.ToString());
|
var includeGlobString = string.Join(",", includeGlobs);
|
var excludeGlobString = string.Join(",", excludeGlobs);
|
|
Log.LogMessage($"{task.PackageName} Include=\"{includeGlobString}\" Exclude=\"{excludeGlobString}\"");
|
}
|
|
foreach (var globTask in globTasks)
|
{
|
HandlePackage(globTask);
|
}
|
}
|
catch (Exception e)
|
{
|
Log.LogWarning($"Unexpected error while parsing patterns in '<OpenTapPackageReference>'. If the problem persists, please open an issue and include the build log.");
|
Log.LogErrorFromException(e);
|
throw;
|
}
|
finally
|
{
|
// Ensure we always write an output file. MSBuild may get confused otherwise.
|
Write();
|
}
|
|
return true;
|
}
|
|
private void HandlePackage(GlobTask globTask)
|
{
|
var assembliesInPackage = new List<string>();
|
|
var packageDefPath = Path.Combine(PackageInstallDir, "Packages", globTask.PackageName, "package.xml");
|
|
if (!File.Exists(packageDefPath))
|
{
|
globTask.LogWarningWithLineNumber(
|
$"No package named '{globTask.PackageName}'.");
|
return;
|
}
|
|
var dllsInPackage = dllRx.Matches(File.ReadAllText(packageDefPath)).Cast<Match>()
|
.Where(match => match.Groups["name"].Success)
|
.Select(match => match.Groups["name"].Value);
|
|
var matchedDlls = dllsInPackage.Where(x => globTask.Includes(x, Log));
|
|
foreach (var dllPath in matchedDlls.Distinct())
|
{
|
var absolutedllPath = Path.Combine(PackageInstallDir, dllPath);
|
|
// Ensure we don't add references twice if they are matched by multiple patterns
|
if (_added.Contains(absolutedllPath))
|
{
|
Log.LogMessage($"{absolutedllPath} already added. Not adding again.");
|
continue;
|
}
|
|
_added.Add(absolutedllPath);
|
|
if (IsDotNetAssembly(absolutedllPath))
|
{
|
assembliesInPackage.Add(dllPath);
|
}
|
else
|
{
|
globTask.LogWarningWithLineNumber($"{absolutedllPath} not recognized as a DotNet assembly. Reference not added.");
|
}
|
}
|
|
Log.LogMessage(MessageImportance.Normal,
|
"Found these assemblies in OpenTAP references: " + string.Join(", ", assembliesInPackage));
|
|
if (!assembliesInPackage.Any())
|
{
|
globTask.LogWarningWithLineNumber($"No references added from package '{globTask.PackageName}'.");
|
}
|
else
|
{
|
WriteItemGroup(assembliesInPackage);
|
Assemblies = Assemblies.Concat(assembliesInPackage).ToArray();
|
}
|
}
|
|
private bool IsDotNetAssembly(string fullPath)
|
{
|
try
|
{
|
AssemblyName testAssembly = AssemblyName.GetAssemblyName(fullPath);
|
return true;
|
}
|
catch (Exception ex)
|
{
|
Log.LogMessage(MessageImportance.Low, $"Could not load assembly name from '{fullPath}'. {ex}\n{ex.GetType()}\n{ex.Message}\n{ex.StackTrace}");
|
return false;
|
}
|
}
|
}
|
}
|
