using System;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
using System.Text;
|
using System.Text.RegularExpressions;
|
using System.Xml.Linq;
|
using Microsoft.Build.Framework;
|
using Task = Microsoft.Build.Utilities.Task;
|
|
namespace Keysight.OpenTap.Sdk.MSBuild
|
{
|
/// <summary>
|
/// MSBuild Task to version the build output using gitversion.
|
/// </summary>
|
[Serializable]
|
public class CalculateVersion : Task, ICancelableTask
|
{
|
private const string TargetName = "OpenTapSetAssemblyVersion";
|
/// <summary>
|
/// The build directory containing 'tap.exe' and 'OpenTAP.dll'
|
/// </summary>
|
public string TapDir { get; set; }
|
|
/// <summary>
|
/// csproj file. This is needed because OpenTAP supports multiple gitversion files.
|
/// Gitversion should be resolved from the directory containing the project file.
|
/// </summary>
|
public string SourceFile { get; set; }
|
|
/// <summary>
|
/// Optional input version. This is useful in CI pipelines where shallow clones
|
/// are used for performance reasons.
|
/// </summary>
|
public string InputVersion { get; set; }
|
|
/// <summary>
|
/// The output shortversion (x.y.z).
|
/// </summary>
|
[Microsoft.Build.Framework.Output]
|
public string OutputShortVersion { get; set; }
|
|
/// <summary>
|
/// The output gitversion plus informational version (x.y.z-beta.1+hash).
|
/// </summary>
|
[Microsoft.Build.Framework.Output]
|
public string OutputLongVersion { get; set; }
|
|
private bool tryParseXElement(string text, out XElement elem)
|
{
|
try
|
{
|
elem = XElement.Parse(text, LoadOptions.None);
|
return true;
|
}
|
catch
|
{
|
elem = null;
|
return false;
|
}
|
}
|
|
private bool runProcess(string filename, string arguments, string workingDirectory, out string stdout,
|
out string stderr)
|
{
|
var si = new ProcessStartInfo(filename, arguments)
|
{
|
RedirectStandardError = true,
|
RedirectStandardOutput = true,
|
UseShellExecute = false,
|
WorkingDirectory = workingDirectory,
|
};
|
var errStream = new StringBuilder();
|
var outStream = new StringBuilder();
|
var proc = new Process();
|
proc.StartInfo = si;
|
proc.OutputDataReceived += (_, data) =>
|
{
|
if (!string.IsNullOrWhiteSpace(data?.Data)) outStream.Append(data.Data);
|
};
|
proc.ErrorDataReceived += (_, data) =>
|
{
|
if (!string.IsNullOrWhiteSpace(data?.Data)) errStream.Append(data.Data);
|
};
|
proc.Start();
|
proc.BeginOutputReadLine();
|
proc.BeginErrorReadLine();
|
proc.WaitForExit(10000);
|
|
if (!proc.HasExited)
|
{
|
stdout = stderr = null;
|
Log.LogError($"{TargetName}: tap sdk gitversion is hanging.");
|
return false;
|
}
|
stdout = outStream.ToString();
|
stderr = errStream.ToString();
|
|
return proc.ExitCode == 0;
|
}
|
|
private bool isWindows()
|
{
|
switch (Environment.OSVersion.Platform)
|
{
|
case PlatformID.Win32NT:
|
case PlatformID.Win32S:
|
case PlatformID.Win32Windows:
|
case PlatformID.WinCE:
|
return true;
|
default:
|
return false;
|
}
|
}
|
|
// Check if a file with the given name exists in any ancestor directory
|
private bool fileIsAncestor(string name, DirectoryInfo root)
|
{
|
var comparer = isWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
|
while (root != null)
|
{
|
if (root.EnumerateFileSystemInfos().Any(i => i.Name.Equals(name, comparer)))
|
return true;
|
root = root.Parent;
|
}
|
|
return false;
|
}
|
|
// This does not need to be perfect.
|
private static Regex versionRegex = new Regex(@"^\d+\.\d+\.\d+", RegexOptions.Compiled);
|
private bool tryParseVersion(string inputVersion, out string shortVersion, out string longVersion)
|
{
|
inputVersion = inputVersion.Trim();
|
var m = versionRegex.Match(inputVersion);
|
if (m.Success)
|
{
|
shortVersion = m.Value;
|
longVersion = inputVersion;
|
return true;
|
}
|
|
shortVersion = longVersion = null;
|
return false;
|
}
|
|
private bool tryCalculateGitversion(out string shortVersion, out string gitversion)
|
{
|
shortVersion = null;
|
gitversion = null;
|
|
var workingDirectory = Path.GetDirectoryName(SourceFile);
|
var dirInfo = new DirectoryInfo(workingDirectory);
|
|
// Ensure this is a git repository
|
if (!fileIsAncestor(".git", dirInfo))
|
{
|
Log.LogError(
|
$"{TargetName}: The project file '{SourceFile}' is not in a git directory. {TargetName} is only supported in git projects.");
|
return false;
|
}
|
|
// And that it uses gitversioning
|
if (!fileIsAncestor(".gitversion", dirInfo))
|
{
|
Log.LogError(
|
$"{TargetName}: This project does not have a .gitversion file. {TargetName} is only supported in gitversion projects.\n" +
|
$"See https://doc.opentap.io/Developer%20Guide/Plugin%20Packaging%20and%20Versioning/Readme.html#git-assisted-versioning");
|
return false;
|
}
|
|
// Start a subprocess to get the gitversion. There are a couple of reasons we don't calculate it in-process:
|
// 1. libgit uses a native dll which is annoying to load. OpenTAP already includes logic for this which
|
// makes several assumptions that do not apply during dotnet build.
|
// 2. GitVersionCalculator is internal, and I would prefer to not make it public.
|
// For these reasons, it is much simpler to just start a process and parse the output.
|
string tapName = isWindows() ? "tap.exe" : "tap";
|
var tap = Path.Combine(TapDir, tapName);
|
if (!runProcess(tap, "sdk gitversion", workingDirectory, out var stdout, out var stderr))
|
{
|
return false;
|
}
|
|
if (!string.IsNullOrWhiteSpace(stderr))
|
{
|
// This could indicate a problem, but logging it as an error would fail the build.
|
// Log it as a warning instead so the user is at least aware
|
Log.LogWarning(stderr);
|
}
|
|
// There could potentially be multiple lines in the output due diagnostics or warnings from OpenTAP.
|
// Find the line that looks like a gitversion
|
var lines = stdout.Split('\n').Select(line => line.Trim()).ToArray();
|
|
foreach (var l in lines)
|
{
|
if (tryParseVersion(l, out shortVersion, out gitversion))
|
return true;
|
}
|
|
Log.LogError($"{TargetName}: Unable to parse gitversion from output:\n{stdout}");
|
|
return false;
|
}
|
|
public override bool Execute()
|
{
|
string shortVersion;
|
string longVersion;
|
string input;
|
|
// parse input gitversion. It can have a couple of different formats:
|
// 1. A flag, such as '1' or 'true'
|
// 2. A semantic version
|
// 3. An xml tag enclosing a value, such as <GitVersion>1.2.3</GitVersion>
|
|
// Case 1: calculate the version
|
if (new[] { "true", "1" , "gitversion", "auto", "git" }.Contains(InputVersion.Trim(), StringComparer.OrdinalIgnoreCase))
|
{
|
if (tryCalculateGitversion(out shortVersion, out longVersion))
|
{
|
OutputShortVersion = shortVersion;
|
OutputLongVersion = longVersion;
|
return true;
|
}
|
|
return false;
|
}
|
|
// Case 2/3: parse the provided version from the input
|
if (!tryParseXElement($"<{TargetName}>{InputVersion.Trim()}</{TargetName}>", out var elem))
|
{
|
// This should not be possible since the input is exactly the inner text of the .csproj property element.
|
// If the input is not valid xml, then the compilation should have already failed.
|
Log.LogError($"{TargetName}: Failed to parse input.");
|
return false;
|
}
|
|
if (elem.Element("Version") is XElement gv)
|
{
|
input = gv.Value.Trim();
|
}
|
else if (tryParseVersion(elem.Value.Trim(), out _, out _))
|
{
|
input = elem.Value.Trim();
|
}
|
else
|
{
|
Log.LogError($"{TargetName}: Expected element named 'Version'.");
|
return false;
|
}
|
|
if (!tryParseVersion(input, out shortVersion, out longVersion))
|
{
|
Log.LogError($"{TargetName}: Provided version is not a valid semantic version: '{input}'");
|
return false;
|
}
|
|
OutputShortVersion = shortVersion;
|
OutputLongVersion = longVersion;
|
return true;
|
}
|
|
public void Cancel()
|
{
|
// No cancel logic needed
|
}
|
}
|
}
|
