// 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.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using OpenTap.Authentication;
|
|
namespace OpenTap.Package
|
{
|
/// <summary>
|
/// A client interface for a package repository. Implementations include <see cref="FilePackageRepository"/> and <see cref="HttpPackageRepository"/>.
|
/// </summary>
|
public interface IPackageRepository
|
{
|
/// <summary>
|
/// The url of the repository.
|
/// </summary>
|
string Url { get; }
|
|
/// <summary>
|
/// Downloads a package from this repository to a file.
|
/// </summary>
|
/// <param name="package">The package to download.</param>
|
/// <param name="destination">The destination path where the package should be stored.</param>
|
/// <param name="cancellationToken">A cancellation token that can be used to cancel the download.</param>
|
void DownloadPackage(IPackageIdentifier package, string destination, CancellationToken cancellationToken);
|
|
/// <summary>
|
/// Get all names of packages.
|
/// </summary>
|
/// <param name="cancellationToken">A cancellation token that can be used to cancel the download.</param>
|
/// <param name="compatibleWith">Any packages that the package to download must be compatible with.</param>
|
/// <returns>An array of package names.</returns>
|
string[] GetPackageNames(CancellationToken cancellationToken, params IPackageIdentifier[] compatibleWith);
|
|
/// <summary>
|
/// Returns all package version information about a package.
|
/// </summary>
|
/// <param name="packageName">The name package to retrieve version info about.</param>
|
/// <param name="cancellationToken">A cancellation token that can be used to cancel the download.</param>
|
/// <param name="compatibleWith">Any packages that the package to download must be compatible with.</param>
|
/// <returns>An array of package versions.</returns>
|
PackageVersion[] GetPackageVersions(string packageName, CancellationToken cancellationToken, params IPackageIdentifier[] compatibleWith);
|
|
/// <summary>
|
/// This returns the latest version of a package that matches a number of specified parameters.
|
/// If multiple packages have that same version number they all will be returned.
|
/// </summary>
|
/// <param name="package">A package identifier. If not specified, packages with any name will be returned.</param>
|
/// <param name="cancellationToken">A cancellation token that can be used to cancel the download.</param>
|
/// <param name="compatibleWith">Any packages that the package to download must be compatible with.</param>
|
/// <returns>An array of package definitions <see cref="PackageDef"/>.</returns>
|
PackageDef[] GetPackages(PackageSpecifier package, CancellationToken cancellationToken, params IPackageIdentifier[] compatibleWith);
|
|
/// <summary>
|
/// Returns a list of all packages that have an updated version.
|
/// </summary>
|
/// <param name="packages"></param>
|
/// <param name="cancellationToken">A cancellation token that can be used to cancel the download.</param>
|
/// <returns>An array of package definitions <see cref="PackageDef"/>.</returns>
|
PackageDef[] CheckForUpdates(IPackageIdentifier[] packages, CancellationToken cancellationToken);
|
}
|
|
/// <summary>
|
/// Represents a version of a package. Objects of this type is returned by<see cref="IPackageRepository.GetPackageVersions"/>.
|
/// </summary>
|
[DebuggerDisplay("{Name} : {Version.ToString()}")]
|
public class PackageVersion : PackageIdentifier, IEquatable<PackageVersion>
|
{
|
internal bool IsUnlisted { get; private set; }
|
internal static PackageVersion FromDictionary(Dictionary<string, object> dict)
|
{
|
var name = dict["Name"] as string;
|
Enum.TryParse(dict["Architecture"] as string, out CpuArchitecture arch);
|
var version = SemanticVersion.Parse(dict["Version"] as string);
|
var os = dict["OS"] as string;
|
var date = (DateTime)dict["Date"];
|
var licenses = new List<string>();
|
if (dict.TryGetValue("LicenseRequired", out var licenseRequired))
|
{
|
if (licenseRequired is string license)
|
licenses.Add(license);
|
else if (licenseRequired is string[] licenseArray)
|
licenses.AddRange(licenseArray);
|
}
|
|
return new PackageVersion(name, version, os, arch, date, licenses)
|
{
|
IsUnlisted = dict.TryGetValue("IsUnlisted", out var unlisted) && unlisted is bool b && b
|
};
|
}
|
|
/// <summary>
|
/// Initializes a new instance of a PackageVersion.
|
/// </summary>
|
public PackageVersion(string name, SemanticVersion version, string os, CpuArchitecture architechture, DateTime date, List<string> licenses) : base(name, version, architechture, os)
|
{
|
this.Date = date;
|
this.Licenses = licenses;
|
}
|
|
internal PackageVersion()
|
{
|
|
}
|
|
/// <summary>
|
/// The date that the package was build.
|
/// </summary>
|
public DateTime Date { get; set; }
|
|
/// <summary>
|
/// License(s) required to use this package.
|
/// </summary>
|
public List<string> Licenses { get; set; }
|
|
/// <summary>
|
/// Compares this PackageVersion with another.
|
/// </summary>
|
public bool Equals(PackageVersion other)
|
{
|
return (this as PackageIdentifier).Equals(other);
|
}
|
}
|
|
internal static class PackageRepositoryExtension
|
{
|
public static void DownloadPackage(this IPackageRepository repository, IPackageIdentifier package, string destination)
|
{
|
repository.DownloadPackage(package, destination, TapThread.Current.AbortToken);
|
}
|
|
public static string[] GetPackageNames(this IPackageRepository repository, params IPackageIdentifier[] compatibleWith)
|
{
|
return repository.GetPackageNames(TapThread.Current.AbortToken, compatibleWith);
|
}
|
|
public static PackageVersion[] GetPackageVersions(this IPackageRepository repository, string packageName, params IPackageIdentifier[] compatibleWith)
|
{
|
return repository.GetPackageVersions(packageName, TapThread.Current.AbortToken, compatibleWith);
|
}
|
|
public static PackageDef[] GetPackages(this IPackageRepository repository, PackageSpecifier package, params IPackageIdentifier[] compatibleWith)
|
{
|
return repository.GetPackages(package, TapThread.Current.AbortToken, compatibleWith);
|
}
|
|
public static PackageDef[] CheckForUpdates(this IPackageRepository repository, IPackageIdentifier[] packages)
|
{
|
return repository.CheckForUpdates(packages, TapThread.Current.AbortToken);
|
}
|
}
|
|
internal class PackageRepositoryHelpers
|
{
|
private static TraceSource log = Log.CreateSource("PackageRepository");
|
|
static void ParallelTryForEach<TSource>(IEnumerable<TSource> source, Action<TSource> body)
|
{
|
try
|
{
|
Parallel.ForEach(source, body);
|
}
|
catch (AggregateException ex)
|
{
|
foreach (var inner in ex.InnerExceptions)
|
{
|
log.Info(inner.Message);
|
log.Debug(inner);
|
}
|
}
|
}
|
|
internal static List<PackageDef> GetPackageNameAndVersionFromAllRepos(List<IPackageRepository> repositories,
|
PackageSpecifier id, params IPackageIdentifier[] compatibleWith)
|
{
|
var list = new List<PackageDef>();
|
|
ParallelTryForEach(repositories, repo =>
|
{
|
if (repo is HttpPackageRepository httprepo)
|
{
|
var parameters = HttpPackageRepository.GetQueryParameters(version: id.Version, os: id.OS,
|
architecture: id.Architecture, distinctName: true);
|
|
var repoClient = HttpPackageRepository.GetAuthenticatedClient(new Uri(httprepo.Url, UriKind.Absolute));
|
var result = repoClient.Query(parameters, CancellationToken.None, "name", "version");
|
|
var packages = result.Select(p => new PackageDef()
|
{
|
Name = p["name"] as string,
|
Version = SemanticVersion.Parse(p["version"] as string),
|
PackageSource = new HttpRepositoryPackageDefSource() { RepositoryUrl = httprepo.Url }
|
});
|
|
lock (list)
|
{
|
list.AddRange(packages);
|
}
|
}
|
else
|
{
|
var packages = repo.GetPackages(id, compatibleWith);
|
lock (list)
|
{
|
list.AddRange(packages);
|
}
|
}
|
});
|
return list;
|
}
|
|
internal static List<PackageDef> GetPackagesFromAllRepos(List<IPackageRepository> repositories,
|
PackageSpecifier id, params IPackageIdentifier[] compatibleWith)
|
{
|
var list = new List<PackageDef>();
|
|
ParallelTryForEach(repositories, repo =>
|
{
|
var packages = repo.GetPackages(id, compatibleWith);
|
lock (list)
|
{
|
list.AddRange(packages);
|
}
|
});
|
|
return list;
|
}
|
|
internal static List<PackageVersion> GetAllVersionsFromAllRepos(List<IPackageRepository> repositories,
|
string packageName, params IPackageIdentifier[] compatibleWith)
|
{
|
var list = new List<PackageVersion>();
|
ParallelTryForEach(repositories, repo =>
|
{
|
var packages = repo.GetPackageVersions(packageName, compatibleWith);
|
lock (list)
|
{
|
list.AddRange(packages);
|
}
|
});
|
return list;
|
}
|
|
/// <summary>
|
/// Returns FilePackageRepository if either of the following is true:
|
/// - Url is explicitly defined with file:///
|
/// - The url is relative and directory exists
|
/// - Starts with classic windows absolute path like 'C:/'
|
/// - Starts with '\\'
|
/// Otherwise returns HttpPackageRepository
|
/// </summary>
|
/// <param name="url">url to be determined to be file path or http path</param>
|
/// <returns>Determined repository type</returns>
|
internal static IPackageRepository DetermineRepositoryType(string url)
|
{
|
if (registeredRepositories.TryGetValue(url, out var repo))
|
return repo;
|
if (Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out Uri uri))
|
{
|
if(uri.IsAbsoluteUri)
|
{
|
switch(uri.Scheme)
|
{
|
case "http":
|
case "https":
|
return new HttpPackageRepository(url);
|
case "file":
|
return new FilePackageRepository(url);
|
default:
|
throw new NotSupportedException($"Scheme {uri.Scheme} is not supported as a package repository ({url}).");
|
}
|
}
|
|
if (!Directory.Exists(url))
|
{
|
try
|
{
|
var repo2 = new HttpPackageRepository(url);
|
if (repo2.Version != null)
|
return repo2;
|
}
|
catch
|
{
|
// probably not an http repo
|
}
|
}
|
|
// If the url starts with a slash, and we are not on windows, it could be an absolute path
|
if (OperatingSystem.Current != OperatingSystem.Windows && url.StartsWith("/") && Directory.Exists(url))
|
{
|
return new FilePackageRepository(url);
|
}
|
|
if (!string.IsNullOrWhiteSpace(AuthenticationSettings.Current.BaseAddress))
|
return DetermineRepositoryType(new Uri(new Uri(AuthenticationSettings.Current.BaseAddress), url).AbsoluteUri);
|
|
// This is a relative URI, and it's scheme cannot be determined. The best we can do is guess.
|
// If the path contains any invalid path chars, it cannot be a file repository
|
// Trailing slashes don't matter. Simplify the logic by stripping them
|
url = url.TrimEnd('/');
|
var canBeFile = Path.GetInvalidPathChars().Any(url.Contains) == false;
|
if (canBeFile)
|
{
|
try
|
{
|
// GetFullPath detects issues not detected by GetInvalidPathChars
|
_ = Path.GetFullPath(url);
|
}
|
catch
|
{
|
canBeFile = false;
|
}
|
}
|
|
var canBeUrl = Uri.IsWellFormedUriString("https://" + url, UriKind.Absolute);
|
if (canBeFile && canBeUrl)
|
{
|
// The URI is ambiguous. Assume it is a http repository if it ends with something that looks like a top-level domain
|
var segments = url.Split('.');
|
var topLevel = segments.LastOrDefault();
|
if (segments.Count() > 1 && !string.IsNullOrWhiteSpace(topLevel))
|
{
|
canBeFile = false;
|
}
|
}
|
|
if (canBeFile) return new FilePackageRepository(Path.GetFullPath(url));
|
if (canBeUrl) return new HttpPackageRepository("http://" + url);
|
}
|
|
throw new NotSupportedException($"Unable to determine repository type of '{url}'. Try specifying a scheme using 'http://' or 'file:///'.");
|
}
|
|
static Dictionary<string, IPackageRepository> registeredRepositories = new Dictionary<string, IPackageRepository>();
|
|
internal static void RegisterRepository(IPackageRepository repo)
|
{
|
registeredRepositories[repo.Url] = repo;
|
}
|
}
|
}
|
