// 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.ComponentModel;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
using System.Reflection;
|
using System.Text;
|
using System.Threading;
|
using OpenTap.Cli;
|
|
namespace OpenTap.Package
|
{
|
internal class Installer
|
{
|
private static readonly TraceSource log = Log.CreateSource("Installer");
|
private CancellationToken cancellationToken;
|
|
internal delegate void ProgressUpdateDelegate(int progressPercent, string message);
|
internal event ProgressUpdateDelegate ProgressUpdate;
|
internal delegate void ErrorDelegate(Exception ex);
|
internal event ErrorDelegate Error;
|
|
internal bool DoSleep { get; set; }
|
internal List<string> PackagePaths { get; private set; }
|
internal string TapDir { get; set; }
|
internal bool UnpackOnly { get; set; }
|
|
internal bool ForceInstall { get; set; }
|
|
internal Installer(string tapDir, CancellationToken cancellationToken)
|
{
|
this.cancellationToken = cancellationToken;
|
DoSleep = true;
|
UnpackOnly = false;
|
PackagePaths = [];
|
TapDir = tapDir?.Trim() ?? Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
|
if(ExecutorClient.IsRunningIsolated)
|
{
|
TapDir = tapDir?.Trim() ?? Directory.GetCurrentDirectory();
|
}
|
else
|
{
|
TapDir = tapDir?.Trim() ?? Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
|
}
|
}
|
|
internal void InstallThread()
|
{
|
if (cancellationToken.IsCancellationRequested)
|
throw new OperationCanceledException();
|
|
try
|
{
|
WaitForPackageFilesFree(TapDir, PackagePaths);
|
RenamePackageFiles(TapDir, PackagePaths);
|
|
// The packages have all been downloaded at this stage. Now we just need to install them.
|
// Assume this accounts for roughly 60% of the installation process.
|
int progressPercent = 60;
|
OnProgressUpdate(progressPercent, "Installing packages.");
|
foreach (string fileName in PackagePaths)
|
{
|
try
|
{
|
progressPercent += 30 / PackagePaths.Count();
|
|
log.Info($"Installing {fileName}");
|
OnProgressUpdate(progressPercent, "Installing " + Path.GetFileNameWithoutExtension(fileName));
|
Stopwatch timer = Stopwatch.StartNew();
|
PackageDef pkg = PluginInstaller.InstallPluginPackage(TapDir, fileName, UnpackOnly);
|
|
log.Info(timer, $"Installed {pkg.Name} version {pkg.Version}");
|
|
if (pkg.Files.Any(s => s.Plugins.Any(p => p.BaseType == nameof(ICustomPackageData))) &&
|
PackagePaths.Last() != fileName)
|
{
|
var newPlugins = pkg.Files.SelectMany(s => s.Plugins.Select(t => t))
|
.Where(t => t.BaseType == nameof(ICustomPackageData));
|
if (newPlugins.Any(np =>
|
TypeData.GetTypeData(np.Name) ==
|
null)) // Only search again, if the new plugins are not already loaded.
|
{
|
if (ExecutorClient.IsRunningIsolated)
|
{
|
// Only load installed assemblies if we're running isolated.
|
log.Info(timer,
|
$"Package '{pkg.Name}' contains possibly relevant plugins for next package installations. Searching for plugins..");
|
PluginManager.DirectoriesToSearch.Add(TapDir);
|
PluginManager.SearchAsync();
|
}
|
else
|
log.Warning(
|
$"Package '{pkg.Name}' contains possibly relevant plugins for next package installations, but these will not be loaded.");
|
}
|
}
|
}
|
catch (Exception ex) when (ex is not ExitCodeException)
|
{
|
if (!ForceInstall)
|
{
|
if (PackagePaths.Last() != fileName)
|
log.Warning(
|
"Aborting installation of remaining packages (use --force to override this behavior).");
|
PackageDef failedPackage = PackageDef.FromPackage(fileName);
|
throw new ExitCodeException((int)PackageExitCodes.PackageInstallError,
|
$"Package failed to install: {failedPackage.Name} version {failedPackage.Version} ({fileName})");
|
}
|
else
|
{
|
if (PackagePaths.Last() != fileName)
|
log.Warning("Continuing installation of remaining packages (--force argument used).");
|
}
|
}
|
}
|
|
|
if (DoSleep)
|
Thread.Sleep(100);
|
|
OnProgressUpdate(100, $"Package installation finished.");
|
Thread.Sleep(50);
|
}
|
catch (Exception ex)
|
{
|
OnError(ex);
|
if (ex is ExitCodeException)
|
System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
|
throw new ExitCodeException((int)PackageExitCodes.PackageInstallError, $"Failed to install packages");
|
}
|
|
Installation installation = new Installation(TapDir);
|
installation.AnnouncePackageChange();
|
}
|
|
internal int UninstallThread()
|
{
|
var status = RunCommand(PrepareUninstall, false, false);
|
if (status == (int)ExitCodes.Success)
|
status = RunCommand(Uninstall, false, true);
|
return status;
|
}
|
|
internal const string Uninstall = "uninstall";
|
internal const string PrepareUninstall = "prepareuninstall";
|
internal const string Install = "install";
|
internal const string Test = "test";
|
|
internal int RunCommand(string command, bool force, bool modifiesPackageFiles)
|
{
|
// Example usage:
|
// "Successfully {pastTense} {pkg.Name} version {pkg.Version}."
|
Dictionary<string, string> pastTenseLookup = new(StringComparer.OrdinalIgnoreCase)
|
{
|
[PrepareUninstall] = "prepared to uninstall",
|
[Uninstall] = "uninstalled",
|
[Install] = "installed",
|
[Test] = "tested",
|
};
|
|
// Example usages:
|
// "Tried to {commandFriendlyName} {pkg.Name}, but there was nothing to do."
|
// "There was an error while trying to {commandFriendlyName} '{pkg.Name}'."
|
Dictionary<string, string> friendlyNameLookup = new(StringComparer.OrdinalIgnoreCase)
|
{
|
[PrepareUninstall] = "prepare uninstalling",
|
[Uninstall] = "uninstall",
|
[Install] = "install",
|
[Test] = "test",
|
};
|
|
var pastTense = pastTenseLookup[command];
|
var friendlyName = friendlyNameLookup[command];
|
|
try
|
{
|
if (modifiesPackageFiles)
|
{
|
try
|
{
|
WaitForPackageFilesFree(TapDir, PackagePaths);
|
}
|
|
catch (Exception ex)
|
{
|
log.Warning("Uninstall stopped while waiting for package files to become unlocked.");
|
if (!force)
|
{
|
OnError(ex);
|
throw;
|
}
|
}
|
}
|
|
double progressPercent = 10;
|
OnProgressUpdate((int)progressPercent, "");
|
|
PluginInstaller pi = new PluginInstaller();
|
|
foreach (string fileName in PackagePaths)
|
{
|
PackageDef pkg = PackageDef.FromXml(fileName);
|
pkg.PackageSource = new XmlPackageDefSource { PackageDefFilePath = fileName };
|
|
OnProgressUpdate((int)progressPercent, $"Running command '{friendlyName}' on '{pkg.Name}'");
|
Stopwatch timer = Stopwatch.StartNew();
|
var res = pi.ExecuteAction(pkg, command, force, TapDir);
|
|
if (res == ActionResult.Error)
|
{
|
if (!force)
|
{
|
OnProgressUpdate(100, "Done");
|
return (int)ExitCodes.GeneralException;
|
}
|
else
|
log.Warning($"There was an error while trying to {friendlyName} '{pkg.Name}'.");
|
}
|
else if (res == ActionResult.NothingToDo)
|
{
|
log.Debug($"Tried to {friendlyName} {pkg.Name}, but there was nothing to do.");
|
}
|
else
|
log.Info(timer, $"Successfully {pastTense} {pkg.Name} version {pkg.Version}.");
|
|
progressPercent += (double)80 / PackagePaths.Count();
|
}
|
|
OnProgressUpdate(90, "");
|
|
if (DoSleep)
|
Thread.Sleep(100);
|
|
OnProgressUpdate(100, "Done");
|
Thread.Sleep(50); // Let Eventhandler get the last OnProgressUpdate
|
}
|
catch (Exception ex)
|
{
|
if (ex is ExitCodeException ec)
|
{
|
log.Error(ec.Message);
|
return ec.ExitCode;
|
}
|
|
if (ex is OperationCanceledException)
|
return (int)ExitCodes.UserCancelled;
|
|
log.Debug(ex);
|
return (int)ExitCodes.GeneralException;
|
}
|
|
new Installation(TapDir).AnnouncePackageChange();
|
|
return (int)ExitCodes.Success;
|
}
|
|
private FileInfo[] GetFilesInUse(string tapDir, List<string> packagePaths)
|
{
|
List<FileInfo> filesInUse = [];
|
|
// Get all files that we are trying to install, but are already in use in a 'locked' way.
|
// Here 'locked' means 'cannot be moved'.
|
foreach (string packageFileName in packagePaths)
|
{
|
foreach (string file in PluginInstaller.FilesInPackage(packageFileName))
|
{
|
string fullPath = Path.Combine(tapDir, file);
|
if (IsFileLocked(new FileInfo(fullPath)))
|
filesInUse.Add(new FileInfo(fullPath));
|
}
|
}
|
|
// Check if the files that are in use are used by any other package
|
var packages = packagePaths.Select(p => p.EndsWith("TapPackage") ? PackageDef.FromPackage(p) : PackageDef.FromXml(p));
|
var remainingInstalledPlugins = new Installation(tapDir).GetPackages().Where(i => packages.Any(p => p.Name == i.Name) == false);
|
var filesToRemain = remainingInstalledPlugins.SelectMany(p => p.Files).Select(f => f.RelativeDestinationPath).Distinct(StringComparer.OrdinalIgnoreCase);
|
filesInUse = filesInUse.Where(f => filesToRemain.Contains(f.Name, StringComparer.OrdinalIgnoreCase) == false).ToList();
|
|
return filesInUse.ToArray();
|
}
|
|
private void WaitForPackageFilesFree(string tapDir, List<string> packagePaths)
|
{
|
var noninteractive = UserInput.GetInterface() is NonInteractiveUserInputInterface;
|
var filesInUse = GetFilesInUse(tapDir, packagePaths);
|
|
if (filesInUse.Length > 0)
|
{
|
var allProcesses = Process.GetProcesses().Where(p =>
|
p.ProcessName.ToLowerInvariant().Contains("opentap") &&
|
p.ProcessName.ToLowerInvariant().Contains("vshost") == false &&
|
p.ProcessName != Assembly.GetExecutingAssembly().GetName().Name).ToArray();
|
|
if (allProcesses.Any())
|
{
|
// The file could be locked by someone other than OpenTAP processes. We should not assume it's OpenTAP holding the file.
|
log.Warning(Environment.NewLine +
|
"To continue, try closing applications that could be using the files.");
|
foreach (var process in allProcesses)
|
log.Warning("- " + process.ProcessName);
|
}
|
|
var tries = 0;
|
const int maxTries = 10;
|
var delaySeconds = 3;
|
var inUseString = BuildString(filesInUse);
|
if (noninteractive)
|
log.Warning(inUseString);
|
|
while (isPackageFilesInUse(tapDir, packagePaths))
|
{
|
var req = new AbortOrRetryRequest("Package Files Are In Use", inUseString) {Response = AbortOrRetryResponse.Abort};
|
UserInput.Request(req, waitForFilesTimeout, true);
|
|
if (req.Response == AbortOrRetryResponse.Abort)
|
{
|
if (noninteractive && tries < maxTries)
|
{
|
tries += 1;
|
log.Info($"Package files are in use. Retrying in {delaySeconds} seconds. ({tries} / {maxTries})");
|
TapThread.Sleep(TimeSpan.FromSeconds(delaySeconds));
|
continue;
|
}
|
|
OnError(new IOException(inUseString));
|
throw new OperationCanceledException();
|
}
|
|
filesInUse = GetFilesInUse(tapDir, packagePaths);
|
inUseString = BuildString(filesInUse);
|
}
|
}
|
}
|
|
private string BuildString(FileInfo[] filesInUse)
|
{
|
var sb = new StringBuilder();
|
sb.AppendLine("The following files cannot be modified because they are in use:");
|
foreach (var file in filesInUse)
|
{
|
sb.AppendLine("- " + file.FullName);
|
|
var loaded_asm = AppDomain.CurrentDomain.GetAssemblies()
|
.FirstOrDefault(x => x.IsDynamic == false && x.Location == file.FullName);
|
if (loaded_asm != null)
|
throw new InvalidOperationException(
|
$"The file '{file.FullName}' is being used by this process.");
|
}
|
|
sb.AppendLine("To continue, try closing applications that could be using the files.");
|
|
return sb.ToString();
|
}
|
|
static readonly TimeSpan waitForFilesTimeout = TimeSpan.FromMinutes(2);
|
|
private bool isPackageFilesInUse(string tapDir, List<string> packagePaths)
|
{
|
foreach (string packageFileName in packagePaths)
|
{
|
foreach (string file in PluginInstaller.FilesInPackage(packageFileName))
|
{
|
string fullPath = Path.Combine(tapDir, file);
|
if (IsFileLocked(new FileInfo(fullPath)))
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private bool IsFileLocked(FileInfo file)
|
{
|
// Previous iterations of this check attempted to open the file for writing on the assumption that this
|
// would also indicate that the file can be deleted. This assumption was incorrect, and today, we are interested
|
// in whether we can move the file out of the way in order to write a new file to the current location.
|
var fn = file.FullName;
|
if (!File.Exists(fn)) return false;
|
var dirname = Path.GetDirectoryName(fn);
|
var temp = Path.Combine(dirname, Guid.NewGuid().ToString());
|
try
|
{
|
// First try to move the file to a temp location (in the same directory)
|
File.Move(fn, temp);
|
// If the move succeeded, move it back and indicate the file is not locked.
|
File.Move(temp, fn);
|
return false;
|
}
|
catch
|
{
|
// This failure mode seems unlikely, but let's guard against it.
|
// This could only happen in the scenario where the first Move operation
|
// could not happen atomically, and was converted to a Copy -> Delete operation,
|
// where the Delete operation failed. To my knowledge, this only happens when the
|
// source and destination are on different volumes.
|
if (File.Exists(temp))
|
{
|
try
|
{
|
File.Delete(temp);
|
}
|
catch
|
{
|
}
|
}
|
return true;
|
}
|
}
|
|
public static void RenamePackageFiles(string tapDir, List<string> packagePaths)
|
{
|
var mover = UninstallContext.Create(new Installation(tapDir));
|
|
foreach (string packageFileName in packagePaths)
|
{
|
foreach (string file in PluginInstaller.FilesInPackage(packageFileName))
|
{
|
if (!mover.Delete(file))
|
{
|
mover.UndoAllDeletions();
|
throw new Exception($"Unable to delete file '{file}'.");
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// Triggers the Error event.
|
/// </summary>
|
private void OnError(Exception ex)
|
{
|
ErrorDelegate handler = Error;
|
if (handler != null)
|
handler(ex);
|
else
|
log.Error(ex);
|
}
|
|
/// <summary>
|
/// Triggers the ProgressUpdate event.
|
/// </summary>
|
private void OnProgressUpdate(int progressPercent, string message = null)
|
{
|
ProgressUpdateDelegate handler = ProgressUpdate;
|
if (handler != null)
|
handler(progressPercent, message);
|
}
|
}
|
|
enum AbortOrRetryResponse
|
{
|
Abort,
|
Retry
|
}
|
|
class AbortOrRetryRequest
|
{
|
public AbortOrRetryRequest(string title, string message)
|
{
|
Message = message;
|
Name = title;
|
}
|
|
[Browsable(false)] public string Name { get; }
|
|
[Browsable(true)]
|
[Layout(LayoutMode.FullRow)]
|
public string Message { get; }
|
[Layout(LayoutMode.FullRow | LayoutMode.FloatBottom)]
|
[Submit] public AbortOrRetryResponse Response { get; set; }
|
}
|
}
|
