// 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.Concurrent;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.IO;
|
using System.Diagnostics;
|
using System.IO.Compression;
|
using System.Threading;
|
using System.ComponentModel;
|
|
namespace OpenTap.Package
|
{
|
internal enum ActionResult
|
{
|
/// <summary>
|
/// An error occurred.
|
/// </summary>
|
Error,
|
/// <summary>
|
/// No error occurred.
|
/// </summary>
|
Ok,
|
/// <summary>
|
/// No action steps were defined for the given package.
|
/// </summary>
|
NothingToDo
|
}
|
|
/// <summary>
|
/// Executes a package action on a single package. Can optionally be used to execute a builtin action first.
|
/// </summary>
|
internal class ActionExecuter
|
{
|
static TraceSource log = OpenTap.Log.CreateSource("Plugin");
|
|
private ConcurrentDictionary<string, TraceSource> LogSources { get; } =
|
new ConcurrentDictionary<string, TraceSource>();
|
|
/// <summary>
|
/// The name of this rule.
|
/// </summary>
|
public string ActionName { get; set; }
|
|
/// <summary>
|
/// The inbuilt action that is executed first.
|
/// </summary>
|
public Func<PluginInstaller, ActionExecuter, PackageDef, bool, string, ActionResult> Execute { get; set; }
|
|
public ActionResult DoExecute(PluginInstaller pluginInstaller, PackageDef package, bool force, string target)
|
{
|
try
|
{
|
if (Execute != null)
|
{
|
return Execute(pluginInstaller, this, package, force, target);
|
}
|
else
|
return ExecutePackageActionSteps(package, force, target);
|
}
|
catch (Exception ex)
|
{
|
log.Error(ex.Message);
|
return ActionResult.Error;
|
}
|
}
|
|
internal ActionResult ExecutePackageActionSteps(PackageDef package, bool force, string workingDirectory)
|
{
|
ActionResult res = ActionResult.NothingToDo;
|
|
// if the package is being installed as a system wide package, we'll want to look in the system-wide
|
// package folder for the executable. Additionally, the system-wide install directory will also be used as
|
// the working directory.
|
bool isSystemWide = package.IsSystemWide();
|
string systemWideDir = PackageDef.SystemWideInstallationDirectory;
|
IEnumerable<string> possiblePaths(string file)
|
{
|
// If you want to run tap as a PackageActionExtension, you would specify "tap" as ExeFile for cross platform compatibility.
|
// In that case, File.Exists wont be successful on Windows. That is why .exe is added if needed.
|
if (isSystemWide)
|
{
|
yield return Path.Combine(systemWideDir, file);
|
if(!file.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
|
yield return Path.Combine(systemWideDir,file + ".exe");
|
}
|
yield return Path.Combine(workingDirectory, file);
|
if(!file.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
|
yield return Path.Combine(workingDirectory, file + ".exe");
|
}
|
|
foreach (var step in package.PackageActionExtensions)
|
{
|
if (step.ActionName.Equals(ActionName, StringComparison.OrdinalIgnoreCase) == false)
|
continue;
|
|
var stepName = $"'{step.ExeFile} {step.Arguments}'";
|
log.Info($"Starting {step.ActionName} step {stepName}");
|
var sw = Stopwatch.StartNew();
|
|
string exefile = step.ExeFile;
|
bool isTap = exefile.EndsWith("tap") || exefile.EndsWith("tap.exe");
|
|
if (isTap)
|
{
|
// Run verbose in order to inherit log source and log type
|
step.Arguments += " --verbose ";
|
}
|
|
|
// If path is relative, check if file is in fact in workingDirectory (isolated mode)
|
if (!Path.IsPathRooted(step.ExeFile))
|
{
|
exefile = possiblePaths(step.ExeFile).FirstOrDefault(File.Exists) ?? step.ExeFile;
|
}
|
|
// Upgrade to ok output
|
res = ActionResult.Ok;
|
|
var pi = new ProcessStartInfo(exefile, step.Arguments);
|
|
pi.CreateNoWindow = step.CreateNoWindow;
|
pi.WorkingDirectory = isSystemWide ? systemWideDir : workingDirectory;
|
pi.Environment.Remove(ExecutorSubProcess.EnvVarNames.ParentProcessExeDir);
|
// If OPENTAP_COLOR is set, the escape symbols for colors in the child process will break the parsing of the forwarded logs.
|
// Ensure color is never set in the child process. Colors will still be set in the parent process.
|
pi.Environment["OPENTAP_COLOR"] = "never";
|
|
try
|
{
|
Process p;
|
if (step.UseShellExecute)
|
{
|
pi.UseShellExecute = true;
|
|
p = Process.Start(pi);
|
}
|
else
|
{
|
pi.RedirectStandardOutput = true;
|
pi.RedirectStandardError = true;
|
pi.UseShellExecute = false;
|
|
p = Process.Start(pi);
|
|
p.ErrorDataReceived += (s, e) =>
|
{
|
if (step.Quiet)
|
return;
|
if (!string.IsNullOrEmpty(e.Data))
|
{
|
if (isTap)
|
RedirectTapLog(e.Data, true);
|
else
|
log.Error(e.Data);
|
}
|
};
|
p.OutputDataReceived += (s, e) =>
|
{
|
if (step.Quiet)
|
return;
|
if (!string.IsNullOrEmpty(e.Data))
|
{
|
if (isTap)
|
RedirectTapLog(e.Data, false);
|
else
|
log.Debug(e.Data);
|
}
|
};
|
|
p.BeginErrorReadLine();
|
p.BeginOutputReadLine();
|
}
|
|
p.WaitForExit();
|
|
if (step.ExpectedExitCodes != "*")
|
{
|
var expectedExitCodes = step.ExpectedExitCodes.Split(',').TrySelect(int.Parse,
|
(_, stringValue) => log.Error($"Failed to parse string '{stringValue}' as an integer."))
|
.ToHashSet();
|
|
if (expectedExitCodes.Count == 0)
|
expectedExitCodes.Add(0);
|
|
if (!expectedExitCodes.Contains(p.ExitCode))
|
throw new Exception($"Failed to run {step.ActionName} step {stepName}. Unexpected exitcode: {p.ExitCode}");
|
}
|
|
log.Info(sw, $"Successfully ran {step.ActionName} step {stepName}. {(p.ExitCode != 0 ? $"Exitcode: {p.ExitCode}" : "")}");
|
}
|
catch (Win32Exception) when (step.Optional)
|
{
|
log.Warning($"'{step.ExeFile}' not found, skipping action.");
|
}
|
catch (Exception e)
|
{
|
log.Error(sw, e.Message);
|
|
if (!force)
|
throw new Exception($"Failed to run {step.ActionName} package action.");
|
}
|
}
|
|
return res;
|
}
|
|
private void RedirectTapLog(string lines, bool IsStandardError)
|
{
|
|
foreach (var line in lines.Split('\n'))
|
{
|
var message = line;
|
string split = " : ";
|
|
var logParts = line.Split(new string[] { split }, StringSplitOptions.None);
|
|
if (logParts.Length < 4)
|
{
|
if (IsStandardError)
|
log.Error(message);
|
else
|
log.Info(message);
|
continue;
|
}
|
|
var sourceName = logParts[1].Trim();
|
var logType = logParts[2].Trim();
|
|
var idx = 0;
|
|
for (int i = 0; i < 3; i++)
|
{
|
idx = message.IndexOf(split, idx, StringComparison.Ordinal) + split.Length;
|
}
|
|
message = message.Substring(idx);
|
|
var source = LogSources.GetOrAdd(sourceName, Log.CreateSource);
|
|
switch (logType)
|
{
|
case "Information":
|
source.Info(message);
|
break;
|
case "Error":
|
source.Error(message);
|
break;
|
case "Warning":
|
source.Warning(message);
|
break;
|
default:
|
source.Debug(message);
|
break;
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// Install system for Tap Plugins, which are OpenTAP dll/waveforms in a renamed zip.
|
/// </summary>
|
internal class PluginInstaller
|
{
|
static List<ActionExecuter> builtinActions = new List<ActionExecuter>
|
{
|
new ActionExecuter{ ActionName = Installer.Uninstall, Execute = DoUninstall }
|
};
|
|
static TraceSource log = OpenTap.Log.CreateSource("package");
|
|
/// <summary>
|
/// Returns the names of the files in a plugin package.
|
/// </summary>
|
/// <param name="packagePath"></param>
|
/// <returns></returns>
|
internal static List<string> FilesInPackage(string packagePath)
|
{
|
List<string> files = new List<string>();
|
string fileType = Path.GetExtension(packagePath);
|
if (fileType == ".xml")
|
{
|
var pkg = PackageDef.FromXml(packagePath);
|
return pkg.Files.Select(f => f.FileName).ToList();
|
}
|
|
try
|
{
|
using var fileStream = new FileStream(packagePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
|
using var zip = new ZipArchive(fileStream, ZipArchiveMode.Read);
|
foreach (var part in zip.Entries)
|
{
|
if (part.Name == "[Content_Types].xml" || part.Name == ".rels" || part.FullName.StartsWith("package/services/metadata/core-properties"))
|
continue; // skip strange extra files that are created by System.IO.Packaging.Package (TAP 7.x)
|
|
string path = Uri.UnescapeDataString(part.FullName);
|
files.Add(path);
|
}
|
}
|
catch (InvalidDataException)
|
{
|
log.Error($"Could not unpack '{packagePath}'.");
|
throw;
|
}
|
return files;
|
|
}
|
|
private static bool EulaAccept(PackageDef package)
|
{
|
if (string.IsNullOrWhiteSpace(package?.EULA?.Identifier)) return true;
|
|
string accept = $"{package.Name} - {package.EULA.Identifier}: Yes";
|
// These special characters should not occur, but let's not take any chances
|
accept = accept.Replace(":", "").Replace("\r", "").Replace("\n", "");
|
var EulaAcceptanceFile = Path.Combine(PackageCacheHelper.PackageCacheDirectory, "EulaAcceptance.txt");
|
var acceptedEulas = File.Exists(EulaAcceptanceFile) ? File.ReadLines(EulaAcceptanceFile) : [];
|
if (acceptedEulas.Contains(accept))
|
return true;
|
|
var EulaDialog = new EulaAcceptanceDialog(package);
|
UserInput.Request(EulaDialog);
|
if (EulaDialog.Answer == EulaAcceptanceDialog.Acceptance.Accept)
|
{
|
log.Info($"Accepted Eula {package.EULA.Identifier}");
|
File.AppendAllLines(EulaAcceptanceFile, [accept]);
|
return true;
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// Tries to install a plugin from 'path', throws an exception on error.
|
/// </summary>
|
internal static PackageDef InstallPluginPackage(string target, string path, bool unpackOnly = false)
|
{
|
checkExtension(path);
|
checkFileExists(path);
|
|
var package = PackageDef.FromPackage(path);
|
if (!EulaAccept(package))
|
throw new Cli.ExitCodeException((int)PackageExitCodes.EulaNotAccepted, "EULA not accepted.");
|
|
var destination = package.IsSystemWide() ? PackageDef.SystemWideInstallationDirectory : target;
|
|
try
|
{
|
if (Path.GetExtension(path).ToLower().EndsWith("tappackages")) // This is a bundle
|
{
|
var tempDir = Path.GetTempPath();
|
var bundleFiles = UnpackPackage(path, tempDir);
|
|
foreach (var file in bundleFiles)
|
UnpackPackage(file, destination);
|
}
|
else
|
UnpackPackage(path, destination);
|
}
|
catch (Exception e)
|
{
|
log.Error($"Install failed to execute for '{package.Name}'.");
|
tryUninstall(path, package, target);
|
throw new Exception($"Failed to install package '{path}'.", e);
|
}
|
|
if (unpackOnly)
|
{
|
log.Info("Skipping install actions as unpack-only was specified.");
|
return package;
|
}
|
|
var pi = new PluginInstaller();
|
if (pi.ExecuteAction(package, Installer.Install, false, target) == ActionResult.Error)
|
{
|
log.Error($"Install package action failed to execute for '{package.Name}'.");
|
tryUninstall(path, package, target);
|
throw new Exception($"Failed to install package '{path}'.");
|
}
|
|
CustomPackageActionHelper.RunCustomActions(package, PackageActionStage.Install,
|
new CustomPackageActionArgs(null, false));
|
|
return package;
|
}
|
|
static void tryUninstall(string path, PackageDef package, string target)
|
{
|
log.Info("Uninstalling package '{0}'.", package.Name);
|
Uninstall(package, target);
|
log.Flush();
|
log.Info("Uninstalled package '{0}'.", path);
|
}
|
|
static void checkExtension(string path)
|
{
|
string pathGetExtension = Path.GetExtension(path);
|
if (String.Compare(pathGetExtension, ".tappackage", true) != 0 && String.Compare(pathGetExtension, ".tapplugin", true) != 0 && String.Compare(pathGetExtension, ".tappackages", true) != 0)
|
{
|
throw new Exception(String.Format("Unknown file type '{0}'.", pathGetExtension));
|
}
|
}
|
|
static void checkFileExists(string path)
|
{
|
if (!File.Exists(path))
|
{
|
throw new Exception(String.Format("TapPackage does not exist '{0}'.", path));
|
}
|
}
|
|
/// <summary>
|
/// Unpacks a *.TapPackages file to the specified directory.
|
/// </summary>
|
internal static List<string> UnpackPackage(string packagePath, string destinationDir)
|
{
|
List<string> installedParts = new List<string>();
|
try
|
{
|
using (var packageStream = File.OpenRead(packagePath))
|
using (var zip = new ZipArchive(packageStream, ZipArchiveMode.Read))
|
{
|
foreach (var part in zip.Entries)
|
{
|
if (part.Name == "[Content_Types].xml" || part.Name == ".rels" || part.FullName.StartsWith("package/services/metadata/core-properties"))
|
continue; // skip strange extra files that are created by System.IO.Packaging.Package (TAP 7.x)
|
if (string.IsNullOrWhiteSpace(part.Name))
|
continue;
|
|
string path = Uri.UnescapeDataString(part.FullName).Replace('\\', '/');
|
path = Path.Combine(destinationDir, path).Replace('\\', '/');
|
|
var sw = Stopwatch.StartNew();
|
|
int Retries = 0, MaxRetries = 10;
|
while (true)
|
{
|
try
|
{
|
FileSystemHelper.EnsureDirectoryOf(path);
|
if (OperatingSystem.Current == OperatingSystem.Windows)
|
{
|
// on windows, hidden files cannot be overwritten.
|
// an exception will be thrown in File.Create further down.
|
if (Path.GetFileName(path).StartsWith(".") && File.Exists(path))
|
{
|
var attrs = File.GetAttributes(path);
|
var attrs2 = attrs & ~FileAttributes.Hidden;
|
if(attrs2 != attrs)
|
File.SetAttributes(path, attrs2);
|
}
|
}
|
|
|
var deflate_stream = part.Open();
|
using (var fileStream = File.Create(path))
|
{
|
var task = deflate_stream.CopyToAsync(fileStream, 4096, TapThread.Current.AbortToken);
|
ConsoleUtils.PrintProgressTillEnd(task, "Decompressing", () => fileStream.Position, () => part.Length);
|
}
|
log.Debug(sw, "Decompressed {0}", path);
|
installedParts.Add(path);
|
break;
|
}
|
catch (OperationCanceledException)
|
{
|
throw;
|
}
|
catch (IOException ex) when (ex.Message.Contains("There is not enough space on the disk"))
|
{
|
log.Error(ex.Message);
|
var req = new AbortOrRetryRequest("Not Enough Disk Space", $"File '{part.FullName}' requires {Utils.BytesToReadable(part.Length)} of free space. " +
|
$"Please free some space to continue.") {Response = AbortOrRetryResponse.Abort};
|
UserInput.Request(req, true);
|
if (req.Response == AbortOrRetryResponse.Abort)
|
throw new OperationCanceledException("Installation aborted due to missing disk space.");
|
}
|
catch (Exception ex)
|
{
|
if (Retries == MaxRetries)
|
throw;
|
Retries++;
|
log.Warning("Unable to unpack file {0}. Retry {1} of {2}.", path, Retries, MaxRetries);
|
log.Debug(ex);
|
Thread.Sleep(200);
|
}
|
}
|
}
|
}
|
}
|
catch (InvalidDataException)
|
{
|
log.Error($"Could not unpackage '{packagePath}'.");
|
throw;
|
}
|
|
SetHiddenAttributes(installedParts);
|
return installedParts;
|
}
|
|
private static void SetHiddenAttributes(List<string> parts)
|
{
|
if (OperatingSystem.Current == OperatingSystem.Windows)
|
{
|
foreach (var path in parts)
|
{
|
// Set file hidden attribute
|
if (Path.GetFileName(path).StartsWith("."))
|
File.SetAttributes(path, FileAttributes.Hidden);
|
|
// Set directory hidden attribute
|
var hiddenIndex = path.IndexOf("/.");
|
while (hiddenIndex > 0)
|
{
|
var hiddenDirLength = path.Substring(++hiddenIndex).IndexOf('/');
|
if (hiddenDirLength > 0)
|
{
|
var tempPath = path.Substring(0, hiddenIndex + hiddenDirLength + 1);
|
File.SetAttributes(tempPath, FileAttributes.Hidden);
|
}
|
hiddenIndex = path.IndexOf("/.", ++hiddenIndex);
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// Unpackages a plugin file.
|
/// </summary>
|
/// <param name="packagePath"></param>
|
/// <param name="relativeFilePath"></param>
|
/// <param name="destination"></param>
|
/// <returns></returns>
|
internal static bool UnpackageFile(string packagePath, string relativeFilePath, Stream destination)
|
{
|
try
|
{
|
using var fileStream = new FileStream(packagePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
|
using var zip = new ZipArchive(fileStream, ZipArchiveMode.Read);
|
foreach (var part in zip.Entries)
|
{
|
if (part.Name == "[Content_Types].xml" || part.Name == ".rels" || part.FullName.StartsWith("package/services/metadata/core-properties"))
|
continue; // skip strange extra files that are created by System.IO.Packaging.Package (TAP 7.x)
|
|
string path = Uri.UnescapeDataString(part.FullName);
|
if (path == relativeFilePath)
|
{
|
part.Open().CopyTo(destination);
|
return true;
|
}
|
}
|
}
|
catch (InvalidDataException)
|
{
|
log.Error($"Could not unpackage '{packagePath}'.");
|
throw;
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// Uninstalls a package.
|
/// </summary>
|
internal static void Uninstall(PackageDef package, string target)
|
{
|
var pi = new PluginInstaller();
|
|
pi.ExecuteAction(package, Installer.PrepareUninstall, true, target);
|
pi.ExecuteAction(package, Installer.Uninstall, true, target);
|
}
|
|
internal ActionResult ExecuteAction(PackageDef package, string actionName, bool force, string target)
|
{
|
ActionExecuter action = builtinActions.FirstOrDefault(r => r.ActionName == actionName);
|
|
if (action == null)
|
action = new ActionExecuter { ActionName = actionName };
|
|
return action.DoExecute(this, package, force, target);
|
}
|
|
private static ActionResult DoUninstall(PluginInstaller pluginInstaller, ActionExecuter action, PackageDef package, bool force, string target)
|
{
|
var result = ActionResult.Ok;
|
var destination = package.IsSystemWide() ? PackageDef.SystemWideInstallationDirectory : target;
|
var installation = new Installation(destination);
|
|
var filesToRemain = installation.GetPackages()
|
.Where(p => p.Name != package.Name)
|
.SelectMany(p => p.Files)
|
.Select(f => f.RelativeDestinationPath)
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
|
try
|
{
|
CustomPackageActionHelper.RunCustomActions(package, PackageActionStage.Uninstall, new CustomPackageActionArgs(null, force));
|
}
|
catch (Exception ex)
|
{
|
log.Error(ex);
|
result = ActionResult.Error;
|
}
|
|
try
|
{
|
if (action.ExecutePackageActionSteps(package, force, target) == ActionResult.Error)
|
throw new Exception();
|
}
|
catch
|
{
|
log.Error($"Uninstall package action failed to execute for package '{package.Name}'.");
|
result = ActionResult.Error;
|
}
|
|
var mover = UninstallContext.Create(installation);
|
foreach (var file in package.Files)
|
{
|
string fullPath = Path.Combine(destination, file.RelativeDestinationPath);
|
|
if (filesToRemain.Contains(file.RelativeDestinationPath))
|
{
|
log.Debug("Skipping deletion of file '{0}' since it is required by another plugin package.", file.RelativeDestinationPath);
|
continue;
|
}
|
|
log.Debug("Deleting file '{0}'.", file.RelativeDestinationPath);
|
if (!mover.Delete(file))
|
{
|
mover.UndoAllDeletions();
|
throw new Exception($"Unable to delete file '{file.RelativeDestinationPath}'.");
|
}
|
|
DeleteEmptyDirectory(new FileInfo(fullPath).Directory);
|
}
|
|
var packageFile = PackageDef.GetDefaultPackageMetadataPath(package, target);
|
|
if (!File.Exists(packageFile))
|
{
|
// TAP 8.x support:
|
packageFile = $"Package Definitions/{package.Name}.package.xml";
|
}
|
if (File.Exists(packageFile))
|
{
|
log.Debug("Deleting file '{0}'.", packageFile);
|
File.Delete(packageFile);
|
DeleteEmptyDirectory(new FileInfo(packageFile).Directory);
|
}
|
|
if (package.PackageSource is XmlPackageDefSource f2 && File.Exists(f2.PackageDefFilePath))
|
// in case the package def XML was not in the default package definition directory
|
// it is better to delete it anyway, because otherwise it will seem like it is still installed.
|
File.Delete(f2.PackageDefFilePath);
|
|
return result;
|
}
|
|
private static void DeleteEmptyDirectory(DirectoryInfo dir)
|
{
|
if (dir == null) return;
|
if (!dir.Exists) return;
|
if (dir.EnumerateFiles().Any() || dir.EnumerateDirectories().Any()) return;
|
|
try
|
{
|
dir.Delete(false);
|
// If it succeeded then we should check the parent directory.
|
DeleteEmptyDirectory(dir.Parent);
|
}
|
catch
|
{
|
// Do nothing, it's not a big deal anyway
|
}
|
}
|
}
|
}
|
