using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Reflection;
|
using System.Threading.Tasks;
|
|
namespace OpenTap.Package
|
{
|
class PackageDependencyCache
|
{
|
readonly string os;
|
readonly CpuArchitecture deploymentInstallationArchitecture;
|
readonly PackageDependencyGraph graph = new PackageDependencyGraph();
|
public PackageDependencyGraph Graph => graph;
|
public List<string> Repositories { get; }
|
static readonly TraceSource log = Log.CreateSource("Package Query");
|
|
public PackageDependencyCache(string os, CpuArchitecture deploymentInstallationArchitecture, IEnumerable<string> repositories = null)
|
{
|
graph.UpdatePrerelease = UpdatePrerelease;
|
this.os = os;
|
this.deploymentInstallationArchitecture = deploymentInstallationArchitecture;
|
var urls = PackageManagerSettings.Current.GetEnabledRepositories(repositories).Select(x => x.Url).ToList();
|
Repositories = urls;
|
}
|
|
private void UpdatePrerelease(string name, string version)
|
{
|
var newGraphs = graphs
|
.Where(g => repos[g] is IQueryPrereleases)
|
.AsParallel()
|
.Select(g =>
|
{
|
var newGraph =
|
(repos[g] as IQueryPrereleases).QueryPrereleases(os, deploymentInstallationArchitecture,
|
version, name);
|
g.Absorb(newGraph);
|
return newGraph;
|
});
|
foreach (var g in newGraphs)
|
{
|
Graph.Absorb(g);
|
}
|
}
|
|
readonly List<PackageDependencyGraph> graphs = new List<PackageDependencyGraph>();
|
readonly Dictionary<PackageDependencyGraph, IPackageRepository> repos =
|
new Dictionary<PackageDependencyGraph, IPackageRepository>();
|
public void LoadFromRepositories()
|
{
|
Exception GetInnermostException(Exception ex)
|
{
|
return ex switch
|
{
|
AggregateException aex when aex.InnerExceptions.Count == 1 => GetInnermostException(
|
aex.InnerException),
|
TargetInvocationException tex => GetInnermostException(tex.InnerException),
|
_ => ex
|
};
|
}
|
|
var repositories = Repositories.Select(PackageRepositoryHelpers.DetermineRepositoryType).ToArray();
|
graphs.Clear();
|
var graphList = repositories.AsParallel().TrySelect(repo => (graph: GetGraph(repo), repo: repo),
|
(ex, repo) =>
|
{
|
var innermost = GetInnermostException(ex);
|
if (innermost is TaskCanceledException or OperationCanceledException)
|
{
|
log.Warning($"Timeout while querying '{repo.Url}': {innermost.Message}", innermost);
|
}
|
else if (innermost is PackageQueryException)
|
{
|
log.Warning($"Error querying '{repo.Url}': {innermost.Message}", innermost);
|
}
|
else
|
{
|
log.Warning($"Repository is unreachable: {innermost.Message}", innermost);
|
}
|
});
|
foreach (var r in graphList)
|
{
|
if (r.graph == null)
|
continue; // error while querying repo.
|
graphs.Add(r.graph);
|
repos[r.graph] = r.repo;
|
graph.Absorb(r.graph);
|
}
|
}
|
|
List<PackageDef> addedPackages = new List<PackageDef>();
|
public void AddPackages(IEnumerable<PackageDef> packages)
|
{
|
var graph = new PackageDependencyGraph();
|
graph.LoadFromPackageDefs(packages);
|
this.graph.Absorb(graph);
|
addedPackages.AddRange(packages);
|
}
|
|
PackageDependencyGraph GetGraph(IPackageRepository repo)
|
{
|
if (repo is IQueryPrereleases q)
|
return q.QueryPrereleases(os, deploymentInstallationArchitecture, "", null);
|
|
if (repo is FilePackageRepository fpkg)
|
{
|
var sw = Stopwatch.StartNew();
|
var graph = new PackageDependencyGraph();
|
var packages = fpkg.GetAllPackages(TapThread.Current.AbortToken);
|
graph.LoadFromPackageDefs(packages.Where(x =>
|
x.IsPlatformCompatible(deploymentInstallationArchitecture, os)));
|
|
log.Debug(sw, "Read {1} packages from {0}", repo, packages.Length);
|
|
return graph;
|
}
|
|
{
|
// This occurs during unit testing when mock repositories are used.
|
// UPDATE: No it doesn't. Mock Repository implements IQueryPrereleases.
|
// Figure out if this is safe to delete.
|
// IPackageRepository is public, so this code is probably not unreachable.
|
var sw = Stopwatch.StartNew();
|
var graph = new PackageDependencyGraph();
|
var names = repo.GetPackageNames();
|
List<PackageDef> packages = new List<PackageDef>();
|
foreach (var name in names)
|
{
|
foreach (var version in repo.GetPackageVersions(name))
|
{
|
var pkgs = repo.GetPackages(
|
new PackageSpecifier(version.Name, version.Version.AsExactSpecifier(), version.Architecture,
|
version.OS), TapThread.Current.AbortToken);
|
packages.AddRange(pkgs);
|
}
|
}
|
|
var compatiblePackages = packages
|
.Where(x => x.IsPlatformCompatible(deploymentInstallationArchitecture, os)).ToArray();
|
graph.LoadFromPackageDefs(compatiblePackages);
|
|
log.Debug(sw, "Read {1} packages from {0}", repo, packages.Count);
|
return graph;
|
}
|
}
|
|
public PackageDef GetPackageDef(PackageSpecifier packageSpecifier)
|
{
|
|
if (packageSpecifier.Version.TryAsExactSemanticVersion(out var v) == false)
|
return null;
|
var ps = new PackageSpecifier(packageSpecifier.Name, packageSpecifier.Version,
|
deploymentInstallationArchitecture, os);
|
foreach (var graph in graphs)
|
{
|
if (graph.HasPackage(packageSpecifier.Name, v))
|
{
|
|
if (repos.TryGetValue(graph, out var repo))
|
{
|
var pkgs = repo.GetPackages(ps);
|
if (pkgs.FirstOrDefault() is PackageDef r)
|
return r;
|
}
|
}
|
}
|
|
return addedPackages.FirstOrDefault(x =>
|
x.Name == packageSpecifier.Name && packageSpecifier.Version.IsSatisfiedBy(x.Version.AsExactSpecifier()));
|
}
|
}
|
}
|
