// 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.Collections.Immutable;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
|
namespace OpenTap.Package
|
{
|
static class PackageActionHelpers
|
{
|
readonly static TraceSource log = Log.CreateSource("PackageAction");
|
|
static List<PackageDef> TriviallyResolvePackage(IEnumerable<PackageSpecifier> packages,
|
ICollection<IPackageRepository> repositories, ICollection<PackageDef> directlyReferencedPackages)
|
{
|
directlyReferencedPackages = directlyReferencedPackages ?? new List<PackageDef>();
|
List<PackageDef> forcePackages = new List<PackageDef>();
|
foreach (var pkgSpec in packages)
|
{
|
PackageDef pkgDef = null;
|
foreach (var repo in repositories)
|
{
|
pkgDef = repo.GetPackages(pkgSpec).FirstOrDefault();
|
if (pkgDef != null) break;
|
}
|
|
if (pkgDef == null)
|
{
|
pkgDef = directlyReferencedPackages.FirstOrDefault(x => x.Name == pkgSpec.Name && pkgSpec.Version.IsCompatible(x.Version));
|
}
|
|
|
if (pkgDef == null)
|
{
|
throw new Exception($"Could not find package exactly matching {pkgSpec} (--force specified).");
|
}
|
|
forcePackages.Add(pkgDef);
|
|
}
|
return forcePackages;
|
|
}
|
|
|
internal static List<PackageDef> GatherPackagesAndDependencyDefs(Installation installation, PackageSpecifier[] pkgRefs, string[] packageNames,
|
string Version, CpuArchitecture arch, string OS, List<IPackageRepository> repositories, bool force, bool noDowngrade)
|
{
|
List<PackageDef> directlyReferencesPackages = new List<PackageDef>();
|
|
|
List<PackageSpecifier> packages = new List<PackageSpecifier>();
|
if (pkgRefs != null)
|
packages = pkgRefs.ToList();
|
else
|
{
|
if (packageNames == null)
|
throw new Exception("No packages specified.");
|
foreach (string packageName in packageNames)
|
{
|
var version = Version;
|
if (Path.GetExtension(packageName).ToLower().EndsWith("tappackages"))
|
{
|
if(!File.Exists(packageName))
|
throw new FileNotFoundException($"Unable to find the file {packageName}.");
|
var tempDir = Path.GetTempPath();
|
var bundleFiles = PluginInstaller.UnpackPackage(packageName, tempDir);
|
var packagesInBundle = bundleFiles.Select(PackageDef.FromPackage);
|
|
// A packages file may contain the several variants of the same package, try to select one based on OS and Architecture
|
foreach (IGrouping<string, PackageDef> grp in packagesInBundle.GroupBy(p => p.Name))
|
{
|
var selected = grp.ToList();
|
if (selected.Count == 1)
|
{
|
var pkg = selected.First();
|
directlyReferencesPackages.Add(pkg);
|
packages.Add(pkg.GetSpecifier());
|
continue;
|
}
|
if (!string.IsNullOrEmpty(OS))
|
{
|
selected = selected.Where(p => p.OS.ToLower().Split(',').Any(OS.ToLower().Contains)).ToList();
|
if (selected.Count == 1)
|
{
|
var pkg = selected.First();
|
directlyReferencesPackages.Add(pkg);
|
packages.Add(pkg.GetSpecifier());
|
log.Debug("TapPackages file contains packages for several operating systems. Picking only the one for {0}.", OS);
|
continue;
|
}
|
}
|
if (arch != CpuArchitecture.Unspecified)
|
{
|
selected = selected.Where(p => ArchitectureHelper.CompatibleWith(arch, p.Architecture)).ToList();
|
if (selected.Count == 1)
|
{
|
var pkg = selected.First();
|
directlyReferencesPackages.Add(pkg);
|
packages.Add(pkg.GetSpecifier());
|
log.Debug("TapPackages file contains packages for several CPU architectures. Picking only the one for {0}.", arch);
|
continue;
|
}
|
}
|
throw new Exception("TapPackages file contains multiple variants of the same package. Unable to auto-select a suitable one.");
|
}
|
}
|
else if (Path.GetExtension(packageName)
|
.Equals(".Tappackage", StringComparison.OrdinalIgnoreCase)
|
// if the file exists try installing it, but only if it has an extension.
|
// otherwise there is a great risk that the name conflicts with a remote package name.
|
// For example, the Editor package has a file called Editor inside it (on Linux).
|
|| (File.Exists(packageName) && Path.HasExtension(packageName)))
|
{
|
|
var pkg = PackageDef.FromPackage(packageName);
|
directlyReferencesPackages.Add(pkg);
|
packages.Add(pkg.GetSpecifier());
|
}
|
else if (string.IsNullOrWhiteSpace(packageName) == false)
|
{
|
packages.Add(new PackageSpecifier(packageName, VersionSpecifier.Parse(version ?? ""), arch, OS));
|
}
|
}
|
}
|
|
if (force)
|
{
|
// when --force is specified, exact package specifiers has to be used.
|
// there is no need to resolve the image in this case.
|
var packagesToInstall = TriviallyResolvePackage(packages, repositories, directlyReferencesPackages);
|
|
if (noDowngrade)
|
{
|
packagesToInstall = packagesToInstall.Where(x =>
|
{
|
var installed = installation.FindPackage(x.Name);
|
if (installed != null && installed.Version.CompareTo(x.Version) > 0)
|
return false;
|
return true;
|
}).Select(x => directlyReferencesPackages.FirstOrDefault(y => y.Name == x.Name && y.Version == x.Version) ?? x)
|
.ToList();
|
}
|
// make sure to use the TapPackage if one was directly referenced
|
packagesToInstall = packagesToInstall.Select(x => directlyReferencesPackages.FirstOrDefault(y => y.Name == x.Name && y.Version == x.Version) ?? x)
|
.ToList();
|
|
return packagesToInstall;
|
|
}
|
|
if (noDowngrade)
|
{
|
// if --no-downgrade is specified, none of the already installed packages are allowed to get downgraded
|
// hence they can be added as extra constraints for the dependency resolver.
|
var existingSpec = installation.GetPackages().Select(pkg =>
|
new PackageSpecifier(pkg.Name, pkg.Version.AsCompatibleSpecifier(), pkg.Architecture, pkg.OS));
|
packages = packages.Concat(existingSpec).ToList();
|
}
|
|
var img = ImageSpecifier.FromAddedPackages(installation, packages);
|
if (!string.IsNullOrWhiteSpace(OS))
|
img.OS = OS;
|
if (arch != CpuArchitecture.Unspecified)
|
img.Architecture = arch;
|
|
if (noDowngrade)
|
{
|
img.InstalledPackages = installation.GetPackages().ToImmutableArray();
|
}
|
img.Repositories = repositories.Select(x => x.Url).ToList();
|
img.AdditionalPackages.AddRange(directlyReferencesPackages);
|
var result = img.Resolve(TapThread.Current.AbortToken);
|
|
// missing dependencies are those which are not installed
|
|
List<PackageDef> installedAsDependencies = new List<PackageDef>();
|
List<PackageDef> gatheredPackages = new List<PackageDef>();
|
foreach (var pkg in result.Packages)
|
{
|
var installed = img.InstalledPackages.FirstOrDefault(x => x.Name == pkg.Name && x.Version == pkg.Version);
|
if (installed != null) continue; // this package is already provided by the installation.
|
var gathered = packages.FirstOrDefault(x => x.Name == pkg.Name);
|
gatheredPackages.Add(pkg);
|
if (gathered == null)
|
installedAsDependencies.Add(pkg);
|
}
|
|
foreach (var additional in installedAsDependencies)
|
{
|
if (img.InstalledPackages.Any(x => x.Name == additional.Name))
|
{
|
// This implies that the version is newer.
|
log.Info("Updating dependency {0} {1}", additional.Name, additional.Version);
|
}
|
else
|
{
|
log.Info("Adding dependency {0} {1}", additional.Name, additional.Version);
|
}
|
}
|
|
// make sure to use the TapPackage if one was directly referenced
|
gatheredPackages = gatheredPackages
|
.Select(x => directlyReferencesPackages.FirstOrDefault(y => y.Name == x.Name && y.Version == x.Version) ?? x)
|
.ToList();
|
|
var unavailablePackages =
|
gatheredPackages.Where(x => x.PackageSource is InstalledPackageDefSource).ToArray();
|
if (unavailablePackages.Any())
|
{
|
var str = string.Join("', '", unavailablePackages.Select(x => x.Name));
|
throw new Exception($"The following packages are not available: '{str}'");
|
}
|
|
return gatheredPackages;
|
}
|
|
internal static List<string> DownloadPackages(string destinationDir, List<PackageDef> PackagesToDownload, List<string> filenames = null, Action<int, string> progressUpdate = null, bool ignoreCache = false)
|
{
|
progressUpdate = progressUpdate ?? ((i, s) => { });
|
|
List<string> downloadedPackages = new List<string>();
|
|
for (int i = 0; i < PackagesToDownload.Count; i++)
|
{
|
Stopwatch timer = Stopwatch.StartNew();
|
|
var pkg = PackagesToDownload[i];
|
// Package names can contain slashes and backslashes -- avoid creating subdirectories when downloading packages
|
var packageName = GetQualifiedFileName(pkg).Replace('/', '.');
|
string filename = filenames?.ElementAtOrDefault(i) ??
|
Path.Combine(destinationDir, packageName);
|
|
TapThread.ThrowIfAborted();
|
|
var i1 = i;
|
|
void innerProgress(string header, long pos, long len)
|
{
|
var downloadProgress = 100.0 * pos / len;
|
|
var thisProgress = downloadProgress / PackagesToDownload.Count;
|
var otherProgress = (100.0 * i1) / PackagesToDownload.Count;
|
|
var progress = thisProgress + otherProgress;
|
|
var progressString = $"({downloadProgress:0.00}% | {Utils.BytesToReadable(pos)} of {Utils.BytesToReadable(len)})";
|
progressUpdate((int)progress, $"Downloading '{pkg}' {progressString}");
|
}
|
|
|
try
|
{
|
PackageDef existingPkg = null;
|
try
|
{
|
// If the package we are installing is from a file, we should always use that file instead of a cached package.
|
// During development a package might not change version but still have different content.
|
if (pkg.PackageSource is FilePackageDefSource == false && File.Exists(filename) &&
|
!ignoreCache && Path.HasExtension(filename))
|
{
|
log.Info($"Treating {filename} as a package");
|
existingPkg = PackageDef.FromPackage(filename);
|
}
|
}
|
catch (Exception e)
|
{
|
log.Warning("Could not open OpenTAP Package. Redownloading package.", e);
|
File.Delete(filename);
|
}
|
|
if (existingPkg != null)
|
{
|
if (existingPkg.Version == pkg.Version && existingPkg.OS == pkg.OS && existingPkg.Architecture == pkg.Architecture)
|
{
|
if (!PackageCacheHelper.PackageIsFromCache(existingPkg))
|
log.Info("Package '{0}' already exists in '{1}'.", pkg.Name, destinationDir);
|
else
|
log.Info("Package '{0}' already exists in cache '{1}'.", pkg.Name, destinationDir);
|
}
|
else
|
{
|
throw new Exception($"A package already exists but it is not the same as the package that is being downloaded.");
|
}
|
}
|
else
|
{
|
IPackageRepository rm = null;
|
switch (pkg.PackageSource)
|
{
|
case HttpRepositoryPackageDefSource repoSource:
|
rm = new HttpPackageRepository(repoSource.RepositoryUrl);
|
break;
|
case FileRepositoryPackageDefSource repoSource:
|
rm = new FilePackageRepository(repoSource.RepositoryUrl);
|
break;
|
case IFilePackageDefSource fileSource:
|
rm = new FilePackageRepository(System.IO.Path.GetDirectoryName(fileSource.PackageFilePath));
|
break;
|
default:
|
throw new Exception($"Unable to determine repository type for package source {pkg.PackageSource.GetType()}.");
|
}
|
if (rm is IPackageDownloadProgress r)
|
{
|
r.OnProgressUpdate = innerProgress;
|
}
|
if (PackageCacheHelper.PackageIsFromCache(pkg) && !ignoreCache)
|
{
|
rm.DownloadPackage(pkg, filename);
|
log.Info(timer, "Found package '{0}' in cache. Copied to '{1}'.", pkg.Name, Path.GetFullPath(filename));
|
}
|
else
|
{
|
log.Debug("Downloading '{0}' version '{1}' from '{2}'", pkg.Name, pkg.Version, rm.Url);
|
rm.DownloadPackage(pkg, filename);
|
log.Info(timer, "Downloaded '{0}' to '{1}'.", pkg.Name, Path.GetFullPath(filename));
|
PackageCacheHelper.CachePackage(filename);
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
if (ex is OperationCanceledException)
|
throw;
|
log.Error($"Failed to download '{pkg.Name}' package.");
|
log.Debug(ex);
|
throw;
|
}
|
|
downloadedPackages.Add(filename);
|
float progress_f = (float)(i + 1) / PackagesToDownload.Count;
|
progressUpdate((int)(progress_f * 100), $"Acquired '{pkg}'.");
|
}
|
|
progressUpdate(100, "Finished downloading packages.");
|
|
return downloadedPackages;
|
}
|
|
internal static string GetQualifiedFileName(PackageDef pkg)
|
{
|
List<string> filenameParts = new List<string> { pkg.Name };
|
if (pkg.Version != null)
|
filenameParts.Add(pkg.Version.ToString());
|
if (pkg.Architecture != CpuArchitecture.AnyCPU)
|
filenameParts.Add(pkg.Architecture.ToString());
|
if (!String.IsNullOrEmpty(pkg.OS) && pkg.OS != "Windows")
|
filenameParts.Add(pkg.OS);
|
filenameParts.Add("TapPackage");
|
return String.Join(".", filenameParts);
|
}
|
}
|
}
|
