using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
using System.Threading;
|
using Microsoft.Build.Framework;
|
using OpenTap;
|
using OpenTap.Diagnostic;
|
using OpenTap.Package;
|
|
namespace Keysight.OpenTap.Sdk.MSBuild
|
{
|
internal interface IImageDeployer
|
{
|
void Install(ImageSpecifier spec, Installation install, CancellationToken cts);
|
}
|
|
internal class DefaultImageDeployer : IImageDeployer
|
{
|
public void Install(ImageSpecifier spec, Installation install, CancellationToken cts)
|
{
|
if (!spec.Repositories.Any(r => r.ToLower().Contains("https://packages.opentap.io") || r.ToLower().Contains("http://packages.opentap.io")))
|
spec.Repositories.Add("https://packages.opentap.io");
|
spec.MergeAndDeploy(install, cts);
|
}
|
}
|
|
internal class OpenTapImageInstaller : IDisposable
|
{
|
public string TapDir { get; set; }
|
public string RuntimeDir { get; set; }
|
public CancellationToken CancellationToken { get; set; }
|
public PackageDef OpenTapNugetPackage { get; set; }
|
public IImageDeployer ImageDeployer { get; set; }
|
|
/// <summary>
|
/// This object represents a trace listener of the type EventTraceListener from the <see cref="OpenTAP"/> assembly
|
/// </summary>
|
private EventTraceListener traceListener;
|
|
void onEvent(IEnumerable<Event> events)
|
{
|
// These sources are really loud and not relevant to the image install.
|
// In addition, messages logged at the error level are treated as build errors by MSBuild.
|
// Skip these log sources.
|
var mutedSources = new HashSet<string>()
|
{
|
"Searcher", "PluginManager", "TypeDataProvider", "Resolver", "Serializer"
|
};
|
|
foreach (var evt in events)
|
{
|
if (mutedSources.Contains(evt.Source)) continue;
|
|
var msg = $"{evt.Source} : {evt.Message}";
|
LogMessage(msg, evt.EventType, null);
|
}
|
}
|
|
/// <summary>
|
/// Instantiate an OpenTAP trace listener and create a delegate to handle log messages
|
/// </summary>
|
/// <exception cref="Exception"></exception>
|
void attachTraceListener()
|
{
|
traceListener = new EventTraceListener();
|
traceListener.MessageLogged += onEvent;
|
Log.AddListener(traceListener);
|
}
|
|
public OpenTapImageInstaller(string tapDir, string runtimeDir, CancellationToken cancellationToken)
|
{
|
CancellationToken = cancellationToken;
|
TapDir = tapDir;
|
RuntimeDir = runtimeDir;
|
attachTraceListener();
|
}
|
|
/// <summary>
|
/// UserInputInterface implementation which returns immediately. Intended for non-interactive use.
|
/// </summary>
|
class NonInteractiveUserInputInterface : IUserInputInterface
|
{
|
void IUserInputInterface.RequestUserInput(object dataObject, TimeSpan timeout, bool modal) { }
|
}
|
|
/// <summary>
|
/// Creates a merged image of currently installed packages and the packages contained in ITaskItem[]
|
/// and deploys it to the output directory.
|
/// </summary>
|
/// <param name="packagesToInstall"></param>
|
/// <param name="repositories"></param>
|
/// <returns></returns>
|
public bool InstallImage(ITaskItem[] packagesToInstall, List<string> repositories)
|
{
|
bool success = false;
|
var mutexName = Path.GetFullPath(TapDir) + ".image.lock";
|
using var filelock = FileLock.Create(mutexName);
|
var sw = Stopwatch.StartNew();
|
int count = 0;
|
while (!filelock.WaitOne(TimeSpan.FromSeconds(5)))
|
{
|
if (sw.Elapsed > TimeSpan.FromMinutes(10))
|
{
|
LogMessage($"Image installer timed out waiting for mutex.", (int)LogEventType.Error, null);
|
return false;
|
}
|
|
count++;
|
LogMessage($"Image Installer waiting for mutex... ({count})", (int)LogEventType.Warning, null);
|
}
|
|
try
|
{
|
// This installation is happening during a C# compilation context. The user will not be able to respond to any user input requests.
|
// We should ensure a non-interactive user input is configured in case any user inputs are raised.
|
UserInput.SetInterface(new NonInteractiveUserInputInterface());
|
var install = new Installation(TapDir);
|
|
OpenTapNugetPackage = install.GetOpenTapPackage();
|
|
var imageSpecifier = ImageSpecifierFromTaskItems(packagesToInstall);
|
imageSpecifier.Repositories.AddRange(repositories);
|
|
var openTapSpec = new PackageSpecifier("OpenTAP",
|
VersionSpecifier.Parse(OpenTapNugetPackage.Version.ToString()));
|
|
imageSpecifier.Packages.Add(openTapSpec);
|
|
ImageDeployer ??= new DefaultImageDeployer();
|
|
try
|
{
|
ImageDeployer.Install(imageSpecifier, install, CancellationToken);
|
success = true;
|
}
|
catch (ImageResolveException ex)
|
{
|
LogMessage(ex.Message, (int)LogEventType.Error, null);
|
LogMessage("Unable to resolve image.", (int)LogEventType.Error, null);
|
}
|
}
|
catch (AggregateException aex)
|
{
|
LogMessage(aex.Message, (int)LogEventType.Error, null);
|
foreach (var ex in aex.InnerExceptions)
|
{
|
LogMessage(ex.Message, (int)LogEventType.Error, null);
|
}
|
}
|
catch (Exception ex)
|
{
|
LogMessage(ex.Message, (int)LogEventType.Error, null);
|
}
|
finally
|
{
|
filelock.Release();
|
if (success == false)
|
{
|
LogMessage($"Failed to install packages.", (int)LogEventType.Error, null);
|
}
|
}
|
|
return success;
|
}
|
|
|
public Action<string, int, ITaskItem> LogMessage = (msg, evt, item) => { };
|
|
public void Dispose()
|
{
|
Log.RemoveListener(traceListener);
|
}
|
|
private ImageSpecifier ImageSpecifierFromTaskItems(ITaskItem[] items)
|
{
|
var spec = new ImageSpecifier();
|
foreach (var i in items)
|
{
|
var name = i.ItemSpec;
|
var versionString = i.GetMetadata("Version");
|
|
// The version of OpenTAP installed through nuget is added manually and should not be considered from task items
|
if (name == "OpenTAP")
|
{
|
// The version was omitted - this is fine
|
if (string.IsNullOrWhiteSpace(versionString)) continue;
|
if (VersionSpecifier.TryParse(versionString, out var versionSpecifier))
|
{
|
// The requested version is compatible with the installed version -- this is fine
|
if (versionSpecifier.IsCompatible(OpenTapNugetPackage.Version)) continue;
|
}
|
|
LogMessage(
|
$"This project was restored using OpenTAP version '{OpenTapNugetPackage.Version}', but version " +
|
$"'{versionString}' was requested. Changing the version of OpenTAP installed through nuget " +
|
$"can have unpredictable results and is not supported. Please omit the version from this element.",
|
(int)LogEventType.Warning, i);
|
|
continue;
|
|
}
|
|
var archString = i.GetMetadata("Architecture");
|
var os = i.GetMetadata("OS");
|
|
if (Enum.TryParse(archString, out CpuArchitecture arch) == false)
|
arch = CpuArchitecture.Unspecified;
|
|
if (VersionSpecifier.TryParse(versionString, out var version) == false)
|
{
|
LogMessage($"String '{versionString}' is not a valid version specifier." +
|
$" Falling back to latest release.", (int)LogEventType.Warning, i);
|
version = VersionSpecifier.Parse("");
|
}
|
|
spec.Packages.Add(new PackageSpecifier(name, version, arch, os));
|
}
|
|
return spec;
|
}
|
}
|
}
|
