public void ResolveChooseBestMatchForDependencyBehavior()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() {
{ "B", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "4.0.0", new Dictionary<string, string>() { { "C", "2.0.0" } }));
sourceRepository.Add(CreatePackage("B", "2.0.0", new Dictionary<string, string>() { { "C", "2.0.0" } }));
sourceRepository.Add(CreatePackage("C", "4.0.0"));
sourceRepository.Add(CreatePackage("C", "3.0.0"));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(3, packages.Count());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("3.0.0", packages["C"].Version.ToNormalizedString());
}
public void ResolveDependencyForInstallPackageWithDependencyThatDoesntMeetExactVersionThrows()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() {
{ "B", "[1.5]" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "1.4"));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependencies. 'B 1.4' is not compatible with 'A 1.0 constraint: B (= 1.5.0)'.", message);
}
public void ResolveDependenciesForInstallDiamondDependencyGraph()
{
// Arrange
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", null }, { "C", null }
});
var sourceRepository = new List <ResolverPackage>()
{
target,
CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "D", null }
}),
CreatePackage("C", "1.0", new Dictionary <string, string>()
{
{ "D", null }
}),
CreatePackage("D", "1.0"),
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count());
Assert.NotNull(packages["A"]);
Assert.NotNull(packages["B"]);
Assert.NotNull(packages["C"]);
Assert.NotNull(packages["D"]);
}
public void Resolver_MissingPackage2()
{
// No version constraints for any dependency
// A -> B 2.0 -> (C, D)
// A -> B 1.0 -> Missing Package
var packageA = CreatePackage("A", "2.0", new Dictionary <string, string>()
{
{ "B", "0.0" }
});
var packageB = CreatePackage("B", "2.0", new Dictionary <string, string>()
{
{ "C", "0.0" }, { "D", "0.0" }
});
var packageC = CreatePackage("C", "2.0");
var packageD = CreatePackage("D", "2.0");
// OldB is the lowest but it has a missing dependency
var packageOldB = CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "E", "0.0" }
});
var sourceRepository = new List <ResolverPackage>()
{
packageA,
packageB,
packageC,
packageD,
packageOldB
};
var resolver = new PackageResolver(DependencyBehavior.Lowest);
var packages = resolver.Resolve(new ResolverPackage[] { packageA }, sourceRepository, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count());
Assert.NotNull(packages["A"]);
Assert.NotNull(packages["B"]);
Assert.NotNull(packages["C"]);
Assert.NotNull(packages["D"]);
}
private static IReadOnlyCollection <PackageIdentity> GetPackagesToInstall(
PackageIdentity packageIdentity,
ResolutionContext resolutionContext,
INuGetProjectContext nuGetProjectContext,
IReadOnlyCollection <SourcePackageDependencyInfo> availablePackages,
ISet <SourceRepository> sources,
CancellationToken token)
{
var packageResolverContext = new PackageResolverContext(
resolutionContext.DependencyBehavior,
new[] { packageIdentity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sources.Select(s => s.PackageSource),
new LoggerAdapter(nuGetProjectContext));
var packageResolver = new PackageResolver();
return(packageResolver.Resolve(packageResolverContext, token)?.ToList());
}
public void Resolver_Basic()
{
ResolverPackage target = new ResolverPackage("a", new NuGetVersion(1, 0, 0),
new NuGet.Packaging.Core.PackageDependency[] {
new NuGet.Packaging.Core.PackageDependency("b", new VersionRange(new NuGetVersion(1, 0, 0), true, new NuGetVersion(3, 0, 0), true))
});
var dep1 = new ResolverPackage("b", new NuGetVersion(2, 0, 0));
var dep2 = new ResolverPackage("b", new NuGetVersion(2, 5, 0));
var dep3 = new ResolverPackage("b", new NuGetVersion(4, 0, 0));
List <ResolverPackage> possible = new List <ResolverPackage>();
possible.Add(dep1);
possible.Add(dep2);
possible.Add(dep3);
possible.Add(target);
var resolver = new PackageResolver(DependencyBehavior.Lowest);
var solution = resolver.Resolve(new ResolverPackage[] { target }, possible, CancellationToken.None).ToList();
Assert.Equal(2, solution.Count());
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(PackageIdentity identity)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
Logger);
var resolver = new PackageResolver();
// resolverContext.IncludeUnlisted = true;
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
await Download(packageToInstall);
await InstallPackage(packageToInstall);
}
}
return(result);
}
public void Resolver_Basic_Listed()
{
var a100 = new ResolverPackage("a", new NuGetVersion(1, 0, 0),
new NuGet.Packaging.Core.PackageDependency[]
{
new NuGet.Packaging.Core.PackageDependency("b",
new VersionRange(new NuGetVersion(1, 0, 0), true, new NuGetVersion(5, 0, 0), true))
},
true,
false);
var b200 = new ResolverPackage("b", new NuGetVersion(2, 0, 0), null, false, false);
var b250 = new ResolverPackage("b", new NuGetVersion(2, 5, 0), null, false, false);
var b400 = new ResolverPackage("b", new NuGetVersion(4, 0, 0), null, true, false);
var b500 = new ResolverPackage("b", new NuGetVersion(5, 0, 0), null, true, false);
var b600 = new ResolverPackage("b", new NuGetVersion(6, 0, 0), null, true, false);
List <ResolverPackage> available = new List <ResolverPackage>();
available.Add(a100);
available.Add(b200);
available.Add(b250);
available.Add(b400);
available.Add(b500);
available.Add(b600);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, a100, available);
var solution = resolver.Resolve(context, CancellationToken.None)
.OrderBy(pi => pi.Id)
.ToList();
// the result includes "b" version "4.0.0" because it is the lowest listed dependency
Assert.Equal(new PackageIdentity("a", new NuGetVersion(1, 0, 0)), solution[0], PackageIdentityComparer.Default);
Assert.Equal(new PackageIdentity("b", new NuGetVersion(4, 0, 0)), solution[1], PackageIdentityComparer.Default);
}
public void ResolveChooseBestMatchForDependencyBehavior()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", "1.0.0" },
});
var sourceRepository = new List <ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "4.0.0", new Dictionary <string, string>()
{
{ "C", "2.0.0" }
}));
sourceRepository.Add(CreatePackage("B", "2.0.0", new Dictionary <string, string>()
{
{ "C", "2.0.0" }
}));
sourceRepository.Add(CreatePackage("C", "4.0.0"));
sourceRepository.Add(CreatePackage("C", "3.0.0"));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(3, packages.Count());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("3.0.0", packages["C"].Version.ToNormalizedString());
}
public static List <string> LoadPackageAssemblies(string configPath, string domainName, string userName)
{
List <string> assemblyPaths = new List <string>();
List <string> exceptionsList = new List <string>();
var dependencies = JsonConvert.DeserializeObject <Project>(File.ReadAllText(configPath)).Dependencies;
string appDataPath = new EnvironmentSettings().GetEnvironmentVariablePath(domainName, userName);
string packagePath = Path.Combine(Directory.GetParent(appDataPath).FullName, "packages");
var packagePathResolver = new PackagePathResolver(packagePath);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
var settings = NuGet.Configuration.Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var localRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(packagePath, "Local OpenBots Repo", true));
var resolver = new PackageResolver();
var frameworkReducer = new FrameworkReducer();
var repositories = new List <SourceRepository>
{
localRepo
};
Parallel.ForEach(dependencies, async dependency =>
{
try
{
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(dependency.Key, NuGetVersion.Parse(dependency.Value)),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { dependency.Key },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader = new PackageFolderReader(packagePathResolver.GetInstalledPath(packageToInstall));
var nearest = frameworkReducer.GetNearest(nuGetFramework, packageReader.GetLibItems().Select(x => x.TargetFramework));
var packageListAssemblyPaths = packageReader.GetLibItems()
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items.Where(i => i.EndsWith(".dll"))).ToList();
if (packageListAssemblyPaths != null)
{
foreach (string path in packageListAssemblyPaths)
{
if (!assemblyPaths.Contains(Path.Combine(packagePath, $"{packageToInstall.Id}.{packageToInstall.Version}", path)))
{
assemblyPaths.Add(Path.Combine(packagePath, $"{packageToInstall.Id}.{packageToInstall.Version}", path));
}
}
}
}
}
}
catch (Exception)
{
exceptionsList.Add($"Unable to load {packagePath}\\{dependency.Key}.{dependency.Value}");
}
});
if (exceptionsList.Count > 0)
{
exceptionsList.Add("Please install this package using the OpenBots Studio Package Manager");
throw new Exception(string.Join("\n", exceptionsList));
}
List <string> filteredPaths = new List <string>();
foreach (string path in assemblyPaths)
{
if (filteredPaths.Where(a => a.Contains(path.Split('/').Last()) && FileVersionInfo.GetVersionInfo(a).FileVersion ==
FileVersionInfo.GetVersionInfo(path).FileVersion).FirstOrDefault() == null)
{
filteredPaths.Add(path);
}
}
return(filteredPaths);
}
public void ResolveDependenciesWithCircularReference()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() {
{ "B", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "1.0", new Dictionary<string, string>() {
{ "A", "1.0.0" },
}));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Circular dependency detected 'A 1.0 => B 1.0 => A 1.0'.", message);
}
public async Task <IEnumerable <string> > DownloadPackageAndDependenciesAsync(string packageId, string version, string nuGetDir)
{
List <string> dllsToCopy = new List <string>();
NuGetVersion packageVersion = NuGetVersion.Parse(version);
using (SourceCacheContext cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = _sourceRepositoryProvider.GetRepositories();
HashSet <SourcePackageDependencyInfo> availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependenciesAsync(
new PackageIdentity(packageId, packageVersion),
_nuGetFramework, cacheContext, _logger, repositories, availablePackages);
PackageResolverContext resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
_sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
_logger);
PackageResolver resolver = new PackageResolver();
IEnumerable <SourcePackageDependencyInfo> packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
PackagePathResolver packagePathResolver = new PackagePathResolver(nuGetDir);
PackageExtractionContext packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(_settings, _logger), _logger);
FrameworkReducer frameworkReducer = new FrameworkReducer();
foreach (SourcePackageDependencyInfo packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
DownloadResource downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(_settings),
_logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
IEnumerable <FrameworkSpecificGroup> libItems = packageReader.GetLibItems();
NuGetFramework nearest = frameworkReducer.GetNearest(_nuGetFramework, libItems.Select(x => x.TargetFramework));
IEnumerable <string> items = libItems.Where(x => x.TargetFramework.Equals(nearest)).SelectMany(x => x.Items).Where(x => Path.GetExtension(x) == ".dll");
foreach (var item in items)
{
dllsToCopy.Add(Path.Combine(installedPath, item));
}
}
}
return(dllsToCopy);
}
public void TestPackageResolver()
{
using var tempDir = new TemporaryDirectory();
string packageName = "package.name";
string packageVersion = "0.1.0";
string packageRootPath =
Path.Combine(tempDir.Path, "path", "to", "packages", packageName, packageVersion);
string packageFrameworkPath = Path.Combine(packageRootPath, "lib", "framework");
Directory.CreateDirectory(packageRootPath);
var nugetFile = new FileInfo(
Path.Combine(packageRootPath, $"{packageName}.{packageVersion}.nupkg"));
using (File.Create(nugetFile.FullName))
{
}
var assemblyPaths = new List <FileInfo>
{
new FileInfo(Path.Combine(packageFrameworkPath, "1.dll")),
new FileInfo(Path.Combine(packageFrameworkPath, "2.dll"))
};
var probingPaths = new List <DirectoryInfo> {
new DirectoryInfo(packageRootPath)
};
var mockPackageRestoreContextWrapper = new Mock <PackageRestoreContextWrapper>();
mockPackageRestoreContextWrapper
.SetupGet(m => m.ResolvedPackageReferences)
.Returns(new ResolvedPackageReference[]
{
new ResolvedPackageReference(
packageName,
packageVersion,
assemblyPaths,
new DirectoryInfo(packageRootPath),
probingPaths)
});
var packageResolver = new PackageResolver(mockPackageRestoreContextWrapper.Object);
IEnumerable <string> actualFiles = packageResolver.GetFiles(tempDir.Path);
string metadataFilePath =
Path.Combine(tempDir.Path, DependencyProviderUtils.CreateFileName(1));
var expectedFiles = new string[]
{
nugetFile.FullName,
metadataFilePath
};
Assert.True(expectedFiles.SequenceEqual(actualFiles));
Assert.True(File.Exists(metadataFilePath));
DependencyProviderUtils.Metadata actualMetadata =
DependencyProviderUtils.Metadata.Deserialize(metadataFilePath);
var expectedMetadata = new DependencyProviderUtils.Metadata
{
AssemblyProbingPaths = new string[]
{
Path.Combine(packageName, packageVersion, "lib", "framework", "1.dll"),
Path.Combine(packageName, packageVersion, "lib", "framework", "2.dll")
},
NativeProbingPaths = new string[]
{
Path.Combine(packageName, packageVersion)
},
NuGets = new DependencyProviderUtils.NuGetMetadata[]
{
new DependencyProviderUtils.NuGetMetadata
{
FileName = $"{packageName}.{packageVersion}.nupkg",
PackageName = packageName,
PackageVersion = packageVersion
}
}
};
Assert.True(expectedMetadata.Equals(actualMetadata));
}
static void Main(string[] args)
{
// Import Dependencies
var p = new Program();
// hold onto the container, otherwise the lazy objects will be disposed!
var container = p.Initialize();
// Json.NET is already installed
List <PackageReference> installed = new List <PackageReference>();
installed.Add(new PackageReference(new PackageIdentity("Newtonsoft.Json", NuGetVersion.Parse("6.0.5")), NuGetFramework.Parse("portable-net40+win8")));
// build the repo provider instead of importing it so that it has only v3
var repositoryProvider = new SourceRepositoryProvider(new V3OnlyPackageSourceProvider(), p.ResourceProviders.ToArray());
// package to install
var target = new PackageIdentity("WindowsAzure.Storage", NuGetVersion.Parse("4.0.1"));
// project target framework
var framework = NuGetFramework.Parse("net451");
// build repos
var repos = repositoryProvider.GetRepositories();
Stopwatch timer = new Stopwatch();
// get a distinct set of packages from all repos
HashSet <PackageDependencyInfo> packages = new HashSet <PackageDependencyInfo>(PackageDependencyInfo.Comparer);
// find all needed packages from online
foreach (var repo in repos)
{
// get the resolver data resource
var depInfo = repo.GetResource <DepedencyInfoResource>();
// resources can always be null
if (depInfo != null)
{
timer.Restart();
var task = depInfo.ResolvePackages(new PackageIdentity[] { target }, framework, true);
task.Wait();
foreach (var pkg in task.Result)
{
packages.Add(pkg);
}
timer.Stop();
Console.WriteLine("Online fetch time: " + timer.Elapsed);
}
}
timer.Restart();
// find the best set to install
PackageResolver resolver = new PackageResolver(DependencyBehavior.Lowest);
var toInstall = resolver.Resolve(new PackageIdentity[] { target }, packages, installed, CancellationToken.None);
timer.Stop();
Console.WriteLine("Resolve time: " + timer.Elapsed);
Console.WriteLine("------------------------");
foreach (var pkg in toInstall)
{
Console.WriteLine(pkg.Id + " " + pkg.Version.ToNormalizedString());
}
}
/// <summary>
/// Adds any packages discovered from the NuGet package graph that was not part of any
/// references in the code.
/// </summary>
private static IEnumerable <PackageInspectionResult> AddMissingExplicitPackages(PackageResolver resolver, NamespaceExclusionList exclusions, List <PackageInspectionResult> results)
{
foreach (var package in resolver.GetPackages())
{
if (exclusions.IsExcluded(package.Name))
{
continue;
}
if (results.Any(result => result.Package.Equals(package)))
{
continue;
}
yield return(new PackageInspectionResult(package, new List <IMetricResult?>()));
}
}
public async Task PreProcess(string directive, ScriptExecutionContext context, Action <string> logger)
{
var actionLogger = new NugetLogger(logger);
var nugetDirective = NugetPreProcessorDirective.Parse(directive);
string frameworkName = Assembly.GetEntryAssembly() !.GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault() !;
NuGetFramework framework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
using var cache = new SourceCacheContext();
var packagesPath = Path.Combine(Path.GetTempPath(), "packages");
await CreateEmptyNugetConfig(packagesPath, nugetDirective.FeedUrl);
var settings = Settings.LoadImmutableSettingsGivenConfigPaths(new[] { Path.Combine(packagesPath, "empty.config") }, new SettingsLoadingContext());
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
#pragma warning disable CS0618 // Type or member is obsolete
var repositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
#pragma warning restore CS0618 // Type or member is obsolete
var repository = repositoryProvider.GetRepositories().FirstOrDefault();
var packageMetadataResource = await repository.GetResourceAsync <PackageMetadataResource>(CancellationToken.None);
var searchMetadata = await packageMetadataResource.GetMetadataAsync(
nugetDirective.PackageId,
includePrerelease : false,
includeUnlisted : false,
cache,
actionLogger,
CancellationToken.None);
if (!searchMetadata.Any())
{
throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}");
}
var latest = searchMetadata.OrderByDescending(a => a.Identity.Version).FirstOrDefault();
if (latest is null)
{
throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}");
}
var packageId = latest.Identity;
var dependencyResource = await repository.GetResourceAsync <DependencyInfoResource>();
await GetPackageDependencies(
packageId,
framework,
cache,
repository,
dependencyResource,
availablePackages, actionLogger);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { nugetDirective.PackageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
new[] { repository.PackageSource },
actionLogger);
var resolver = new PackageResolver();
var toInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(a => availablePackages.Single(b => PackageIdentityComparer.Default.Equals(b, a)));
var pathResolver = new PackagePathResolver(packagesPath);
var extractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, actionLogger),
actionLogger);
var libraries = new List <string>();
var frameworkReducer = new FrameworkReducer();
var downloadResource = await repository.GetResourceAsync <DownloadResource>(CancellationToken.None);
foreach (var package in toInstall)
{
libraries.AddRange(await Install(downloadResource, package, pathResolver, extractionContext, frameworkReducer, framework, packagesPath, actionLogger));
}
foreach (var path in libraries)
{
var assembly = Assembly.LoadFrom(path);
if (context.TryAddReferenceAssembly(assembly))
{
foreach (var ns in assembly.GetTypes().Where(a => a.Namespace != null).Select(a => a.Namespace).Distinct())
{
context.AddImport(ns);
}
}
}
}
private async Task <PluginPackage> GetLatestTemplatePackage(string packageId, string frameworkVersion, IAbsoluteDirectoryPath pluginRepositoryPath)
{
var nugetFramework = NuGetFramework.ParseFolder(frameworkVersion);
ISettings settings = Settings.LoadSpecificSettings(root: null, this.appEnvironment.NuGetConfigFilePath.ToString());
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var packageMetaDataList = new List <PluginPackage>();
using (var cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
foreach (SourceRepository sourceRepository in repositories)
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>().ConfigureAwait(false);
IEnumerable <SourcePackageDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages(
packageId,
nugetFramework,
cacheContext,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
if (dependencyInfo == null)
{
continue;
}
availablePackages.AddRange(dependencyInfo);
}
var resolverContext = new PackageResolverContext(
DependencyBehavior.Highest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
try
{
SourcePackageDependencyInfo packageToInstall = resolver
.Resolve(resolverContext, CancellationToken.None).Select(p =>
availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)))
.FirstOrDefault();
var packagePathResolver = new PackagePathResolver(SettingsUtility.GetGlobalPackagesFolder(settings));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
PackageReaderBase packageReader;
if (installedPath == null && packageToInstall != null)
{
DownloadResource downloadResource = await packageToInstall.Source
.GetResourceAsync <DownloadResource>(CancellationToken.None).ConfigureAwait(false);
DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None).ConfigureAwait(false);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
PackageIdentity identity = await packageReader.GetIdentityAsync(CancellationToken.None).ConfigureAwait(false);
var packageMetaData = new PluginPackage
{
Name = identity.Id,
Version = identity.Version.OriginalVersion,
RepositoryPath = pluginRepositoryPath,
};
foreach (FrameworkSpecificGroup contentItem in await packageReader.GetContentItemsAsync(CancellationToken.None).ConfigureAwait(false))
{
packageMetaData.Plugins.AddRange(contentItem.Items);
}
var packageFileExtractor = new PackageFileExtractor(
packageMetaData.Plugins,
XmlDocFileSaveMode.None);
await packageReader.CopyFilesAsync(
packageMetaData.PluginPath.ToString(),
packageMetaData.Plugins,
packageFileExtractor.ExtractPackageFile,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
foreach (IAbsoluteFilePath file in packageMetaData.PluginPath.GetChildDirectoryWithName("content").ChildrenFilesPath)
{
File.Copy(file.ToString(), Path.Join(packageMetaData.PluginPath.ToString(), file.FileName), overwrite: true);
}
packageMetaData.Plugins.Clear();
foreach (IAbsoluteFilePath file in packageMetaData.PluginPath.ChildrenFilesPath)
{
packageMetaData.Plugins.Add(file.GetRelativePathFrom(packageMetaData.PluginPath).ToString());
}
Directory.Delete(packageMetaData.PluginPath.GetChildDirectoryWithName("content").ToString(), recursive: true);
packageMetaDataList.Add(packageMetaData);
}
catch (NuGetResolverConstraintException exception)
{
string foo = exception.Message;
}
}
return(packageMetaDataList.FirstOrDefault());
}
public void Resolver_NoSolution()
{
ResolverPackage target = new ResolverPackage("a", new NuGetVersion(1, 0, 0), new NuGet.Packaging.Core.PackageDependency[] { new NuGet.Packaging.Core.PackageDependency("b", null) }, true, false);
List<ResolverPackage> possible = new List<ResolverPackage>();
possible.Add(target);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, possible);
Assert.Throws<NuGetResolverConstraintException>(() => resolver.Resolve(context, CancellationToken.None));
}
public void ResolveDependenciesForInstallDiamondDependencyGraphWithDifferentVersionsOfSamePackage()
{
// Arrange
var sourceRepository = new List<ResolverPackage>();
// A -> [B, C]
// B -> [D >= 1, E >= 2]
// C -> [D >= 2, E >= 1]
// A
// / \
// B C
// | \ | \
// D1 E2 D2 E1
var packageA = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", null }, { "C", null } });
var packageB = CreatePackage("B", "1.0", new Dictionary<string, string>() { { "D", "1.0" }, { "E", "2.0" } });
var packageC = CreatePackage("C", "1.0", new Dictionary<string, string>() { { "D", "2.0" }, { "E", "1.0" } });
var packageD1 = CreatePackage("D", "1.0");
var packageD2 = CreatePackage("D", "2.0");
var packageE1 = CreatePackage("E", "1.0");
var packageE2 = CreatePackage("E", "2.0");
sourceRepository.Add(packageA);
sourceRepository.Add(packageB);
sourceRepository.Add(packageC);
sourceRepository.Add(packageD2);
sourceRepository.Add(packageD1);
sourceRepository.Add(packageE2);
sourceRepository.Add(packageE1);
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, packageA, sourceRepository);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(5, packages.Count());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["C"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["D"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["E"].Version.ToNormalizedString());
//Verify that D & E are first (order doesn't matter), then B & C (order doesn't matter), then A
Assert.True(solution.Take(2).Select(a => a.Id).All(id => id == "D" || id == "E"));
Assert.True(solution.Skip(2).Take(2).Select(a => a.Id).All(id => id == "B" || id == "C"));
Assert.Equal("A", solution[4].Id);
}
public void Resolver_Basic()
{
ResolverPackage target = new ResolverPackage("a", new NuGetVersion(1, 0, 0),
new NuGet.Packaging.Core.PackageDependency[]
{
new NuGet.Packaging.Core.PackageDependency("b", new VersionRange(new NuGetVersion(1, 0, 0), true, new NuGetVersion(3, 0, 0), true))
},
true,
false);
var dep1 = new ResolverPackage("b", new NuGetVersion(2, 0, 0));
var dep2 = new ResolverPackage("b", new NuGetVersion(2, 5, 0));
var dep3 = new ResolverPackage("b", new NuGetVersion(4, 0, 0));
List<ResolverPackage> possible = new List<ResolverPackage>();
possible.Add(dep1);
possible.Add(dep2);
possible.Add(dep3);
possible.Add(target);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, possible);
var solution = resolver.Resolve(context, CancellationToken.None).ToList();
Assert.Equal(2, solution.Count());
}
public void ResolvesLowestMajorAndMinorHighestPatchVersionOfListedPackagesForDependencies()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", "1.0" } });
// A 1.0 -> B 1.0
// B 1.0 -> C 1.1
// C 1.1 -> D 1.0
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "2.0", new Dictionary<string, string>() { { "C", "1.1" } }),
CreatePackage("B", "1.0", new Dictionary<string, string>() { { "C", "1.1" } }),
CreatePackage("B", "1.0.1"),
CreatePackage("D", "2.0"),
CreatePackage("C", "1.1.3", new Dictionary<string, string>() { { "D", "1.0" } }),
CreatePackage("C", "1.1.1", new Dictionary<string, string>() { { "D", "1.0" } }),
CreatePackage("C", "1.5.1", new Dictionary<string, string>() { { "D", "1.0" } }),
CreatePackage("B", "1.0.9", new Dictionary<string, string>() { { "C", "1.1" } }),
CreatePackage("B", "1.1", new Dictionary<string, string>() { { "C", "1.1" } })
};
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.HighestPatch, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count);
Assert.Equal("2.0.0", packages["D"].Version.ToNormalizedString());
Assert.Equal("1.1.3", packages["C"].Version.ToNormalizedString());
Assert.Equal("1.0.9", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
}
public void ResolveActionsForSimpleUpdate()
{
// Arrange
// Installed: A, B
// A 1.0 -> B [1.0]
var project = new List<ResolverPackage>()
{
CreatePackage("A", "1.0", new Dictionary<string, string> { { "B", "1.0" } }),
CreatePackage("B", "1.0"),
};
var target = CreatePackage("A", "2.0", new Dictionary<string, string> { { "B", "1.0" } });
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "1.0"),
};
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.HighestPatch, target, sourceRepository);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(2, solution.Length);
Assert.Equal("2.0.0", packages["A"].Version.ToNormalizedString());
}
public void Resolver_IgnoreDependencies()
{
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", null }, { "C", null } });
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("C", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("D", "1.0"),
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Ignore, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(1, packages.Count());
Assert.NotNull(packages["A"]);
}
public void ResolveActionsPreferInstalledPackages()
{
// Arrange
// Local:
// B 1.0
// C 1.0
// Remote
// A 1.0 -> B 1.0, C 1.0
// B 1.0
// B 1.1
// C 1.0
// C 2.0
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", "1.0" }, { "C", "1.0" } });
// Expect: Install A 1.0 (no change to B or C)
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "1.0"),
CreatePackage("B", "1.1"),
CreatePackage("C", "1.0"),
CreatePackage("C", "2.0"),
};
var install = new List<PackageReference>()
{
new PackageReference(new PackageIdentity("B", NuGetVersion.Parse("1.0")), null),
new PackageReference(new PackageIdentity("C", NuGetVersion.Parse("1.0")), null),
};
List<PackageIdentity> targets = new List<PackageIdentity>();
targets.Add(target);
targets.AddRange(install.Select(e => e.PackageIdentity));
// Act
var resolver = new PackageResolver();
var context = new PackageResolverContext(DependencyBehavior.HighestMinor,
new string[] { "A" },
install.Select(p => p.PackageIdentity.Id),
install,
targets,
sourceRepository);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(3, packages.Count);
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["C"].Version.ToNormalizedString());
}
static void AnalyzePackage(
string packageId,
string version,
string framework,
//ILogger logger,
PackageSourceEnvironment packageSourceEnvironment)
{
var rootPackageIdentity = new PackageIdentity(packageId, NuGetVersion.Parse(version));
var rootNuGetFramework = NuGetFramework.ParseFolder(framework);
// If configFileName is null, the user specific settings file is %AppData%\NuGet\NuGet.config.
// After that, the machine wide settings files are added (c:\programdata\NuGet\Config\*.config).
//var settings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
//var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
// TODO: Configure packageSources from external config
// TODO: Use environment variables for MyGet username/password!!!!!!
// TODO: Make 3 different environments
// 1. MyGetCi
// 2. MyGet
// 3. Brf
string username = null, password = null;
if (packageSourceEnvironment == PackageSourceEnvironment.MyGetCi ||
packageSourceEnvironment == PackageSourceEnvironment.MyGet)
{
username = Environment.GetEnvironmentVariable("MYGET_USERNAME");
if (string.IsNullOrEmpty(username))
{
username = "******";
}
password = Environment.GetEnvironmentVariable("MYGET_PASSWORD");
if (string.IsNullOrEmpty(password))
{
throw new InvalidOperationException("Missing MYGET_PASSWORD environment variable.");
}
}
PackageSourceProvider packageSourceProvider;
switch (packageSourceEnvironment)
{
case PackageSourceEnvironment.MyGetCi:
packageSourceProvider = new PackageSourceProvider(NullSettings.Instance, new []
{
CreatePackageSource("https://api.nuget.org/v3/index.json", "NuGet.org v3"),
CreatePackageSource("https://www.myget.org/F/maxfire-ci/api/v3/index.json", "MaxfireCi"),
CreateAuthenticatedPackageSource("https://www.myget.org/F/brf-ci/api/v3/index.json", "BrfCiMyGet", username, password)
});
break;
case PackageSourceEnvironment.MyGet:
packageSourceProvider = new PackageSourceProvider(NullSettings.Instance, new []
{
CreatePackageSource("https://api.nuget.org/v3/index.json", "NuGet.org v3"),
CreateAuthenticatedPackageSource("https://www.myget.org/F/brf/api/v3/index.json", "BrfMyGet", username, password)
});
break;
case PackageSourceEnvironment.Brf:
packageSourceProvider = new PackageSourceProvider(NullSettings.Instance, new []
{
CreatePackageSource("https://api.nuget.org/v3/index.json", "NuGet.org v3"),
CreatePackageSource("http://pr-nuget/nuget", "Brf", protocolVersion: 2)
});
break;
case PackageSourceEnvironment.NugetOrg:
default:
packageSourceProvider = new PackageSourceProvider(NullSettings.Instance, new []
{
CreatePackageSource("https://api.nuget.org/v3/index.json", "NuGet.org v3")
});
break;
}
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, Repository.Provider.GetCoreV3());
Console.WriteLine("Feeds used:");
foreach (var packageSource in packageSourceProvider.LoadPackageSources())
{
Console.WriteLine($" {packageSource}");
}
Console.WriteLine();
//var nugetLogger = logger.AsNuGetLogger();
var nugetLogger = NullLogger.Instance;
var tmpDirToRestoreTo = Path.Combine(Path.GetTempPath(), "packages");
using (var cacheContext = new SourceCacheContext {
NoCache = true
})
{
var repositories = sourceRepositoryProvider.GetRepositories();
var resolvedPackages = new ConcurrentDictionary <PackageIdentity, SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
// Builds transitive closure
// TODO: is Wait okay?
ResolvePackageDependencies(rootPackageIdentity, rootNuGetFramework, cacheContext, nugetLogger, repositories, resolvedPackages).Wait();
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
targetIds: new[] { packageId },
availablePackages: new HashSet <SourcePackageDependencyInfo>(resolvedPackages.Values),
packageSources: sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
log: nugetLogger,
requiredPackageIds: Enumerable.Empty <string>(),
packagesConfig: Enumerable.Empty <PackageReference>(),
preferredVersions: Enumerable.Empty <PackageIdentity>());
var resolver = new PackageResolver();
List <SourcePackageDependencyInfo> prunedPackages;
//try
//{
prunedPackages = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(id => resolvedPackages[id]).ToList();
//}
//catch (Exception ex)
//{
// Console.WriteLine($"ERROR: {ex.Message}");
// return;
//}
Console.WriteLine($"root package identity: {rootPackageIdentity}");
Console.WriteLine($"root target framework: {rootNuGetFramework.DotNetFrameworkName} ({rootNuGetFramework.GetShortFolderName()})");
Console.WriteLine();
var packageNodes = new Dictionary <string, PackageReferenceNode>(StringComparer.OrdinalIgnoreCase);
//var builder = new DependencyGraph.Builder(rootNode);
// TODO: problem that the graph is flattened!!!!!
// TODO: Should we inspect the items (assemblies of each package). remember meta-packages contain other packages
// TODO: dependencies are important
Console.WriteLine("Vertices of dependency package graph:");
Console.WriteLine();
PackageReferenceNode rootPackage = null;
// resolve contained assemblies of packages
foreach (SourcePackageDependencyInfo target in prunedPackages)
{
//target.Id
//target.Version
//target.Dependencies
// TODO: --no-cache, --packages $tmpDirToRestoreTo
var downloadResource = target.Source.GetResource <DownloadResource>();
// TODO: .Result of Async
var downloadResult = downloadResource.GetDownloadResourceResultAsync(
new PackageIdentity(target.Id, target.Version),
new PackageDownloadContext(cacheContext, directDownloadDirectory: tmpDirToRestoreTo, directDownload: true),
SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance),
nugetLogger,
CancellationToken.None).Result;
// items in lib folder of target (a package is a collection of assemblies)
var packageReader = downloadResult.PackageReader;
if (packageReader == null)
{
downloadResult.PackageStream.Seek(0, SeekOrigin.Begin);
packageReader = new PackageArchiveReader(downloadResult.PackageStream);
}
var libItems = packageReader.GetLibItems();
NuGetFramework nearest = libItems.Select(x => x.TargetFramework).GetNearestFrameworkMatching(rootNuGetFramework);
// assembly references is a sequence of assembly names (file name including the extension)
var assemblyReferences = libItems
.Where(group => group.TargetFramework.Equals(nearest))
.SelectMany(group => group.Items)
.Where(itemRelativePath => Path.GetExtension(itemRelativePath).Equals(".dll", StringComparison.OrdinalIgnoreCase))
.Select(Path.GetFileName);
//.Select(assemblyName => new AssemblyReferenceNode(assemblyName)); // we do not include assembly references in the graph
// TODO we ignore framework references in nuspec (only used by MS)
//var frameworkItems = packageReader.GetFrameworkItems();
//nearest = reducer.GetNearest(nugetFramework, frameworkItems.Select(x => x.TargetFramework));
//// TODO: Why not use Path.GetFileName here?
//var frameworkAssemblyReferences = frameworkItems
// .Where(@group => @group.TargetFramework.Equals(nearest))
// .SelectMany(@group => @group.Items)
// .Select(Path.GetFileName); // Why
// //.Select(assemblyName => new AssemblyReferenceNode(assemblyName)); // we do not include assembly references in the graph
//assemblyReferences = assemblyReferences.Concat(frameworkAssemblyReferences);
var packageReferenceNode = new PackageReferenceNode(target.Id, target.Version.ToString(),
nearest.DotNetFrameworkName, nearest.GetShortFolderName(), assemblyReferences);
if (rootPackageIdentity.Equals(new PackageIdentity(target.Id, target.Version)))
{
if (rootPackage != null)
{
throw new InvalidOperationException("UNEXPECTED: Root package should be unique.");
}
rootPackage = packageReferenceNode;
}
Console.WriteLine($" {packageReferenceNode}");
//builder.WithNode(packageReferenceNode);
//builder.WithNodes(assemblyReferences);
// TODO: Target package has edges to assembly nodes
//builder.WithEdges(assemblyReferences.Select(x => new Edge(packageReferenceNode, x)));
// TODO: Pack2Pack reference (directed vertex)
packageNodes.Add(target.Id, packageReferenceNode);
}
Console.WriteLine();
// NOTE: We have transitive closure so all references are resolved!!!!
// NOTE: The relation is A 'depends on' B shown like A ---> B
// NOTE: The inverse relation is 'used by'....
// TODO: How to represent digraph (DAG)
// TODO: How to represent the topological order (evaluation order, traversal order)
// TODO: A directed acyclic graph (DAG) with a single root is not a tree!!!!!
// NOTE: Both trees and DAGs are connected, directed, rooted, and have no cycles
// so this means that starting from any node and going up the parents you will
// eventually work your way up to the top (root).
// However, since DAG nodes have multiple parents, there will be multiple paths
// on the way up (that eventually merge). This is like GIT history (DAG)
// Another way to see it is Tree is like single class inheritance, and DAG is like multiple class inheritance.
// A (successor, downstream, core) package can be depended on by many (predecessor, upstream) packages
Console.WriteLine("Edges of dependency package graph:");
Console.WriteLine();
// resolve dependencies of packages
foreach (SourcePackageDependencyInfo target in prunedPackages)
{
// TODO: predecessor node in dependency package graph
PackageReferenceNode sourceNode = packageNodes[target.Id];
// traverse all dependencies of nuspec
foreach (PackageDependency dependency in target.Dependencies)
{
//dependency.Id
//dependency.VersionRange
// resolved dependency of sourceNode
PackageReferenceNode targetNode = packageNodes[dependency.Id];
//targetNode.PackageId
//targetNode.Type (package)
//targetNode.Version
// labeled edge
//new Edge(sourceNode, targetNode, x.VersionRange.ToString())
Console.WriteLine($" {sourceNode}---{dependency.VersionRange}---->{targetNode}");
}
// TODO: directed edge with label of version range for each successor node (successor node carries resolved version)
//builder.WithEdges(target.Dependencies.Select(x =>
// new Edge(sourceNode, packageNodes[x.Id], x.VersionRange.ToString())));
}
Console.WriteLine();
Console.WriteLine($"root package: {rootPackage}");
//return builder.Build();
}
}
public void Resolver_Basic_AllUnlisted()
{
var a100 = new ResolverPackage("a", new NuGetVersion(1, 0, 0),
new NuGet.Packaging.Core.PackageDependency[]
{
new NuGet.Packaging.Core.PackageDependency("b",
new VersionRange(new NuGetVersion(1, 0, 0), true, new NuGetVersion(5, 0, 0), true))
},
false,
false);
var b200 = new ResolverPackage("b", new NuGetVersion(2, 0, 0), null, false, false);
var b250 = new ResolverPackage("b", new NuGetVersion(2, 5, 0), null, false, false);
var b400 = new ResolverPackage("b", new NuGetVersion(4, 0, 0), null, false, false);
var b500 = new ResolverPackage("b", new NuGetVersion(5, 0, 0), null, false, false);
var b600 = new ResolverPackage("b", new NuGetVersion(6, 0, 0), null, false, false);
List<ResolverPackage> available = new List<ResolverPackage>();
available.Add(a100);
available.Add(b200);
available.Add(b250);
available.Add(b400);
available.Add(b500);
available.Add(b600);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, a100, available);
var solution = resolver.Resolve(context, CancellationToken.None)
.OrderBy(pi => pi.Id)
.ToList();
Assert.Equal(new PackageIdentity("a", new NuGetVersion(1, 0, 0)), solution[0], PackageIdentityComparer.Default);
Assert.Equal(new PackageIdentity("b", new NuGetVersion(2, 0, 0)), solution[1], PackageIdentityComparer.Default);
}
private static void InitCli(string[] args)
{
var packageResolver = new PackageResolver();
var registery = new SetupRegistry();
var cliService = new CommandLineService();
CommandLineApplication commandLineApplication = new CommandLineApplication(true)
{
Name = "Rayvarz Setup",
FullName = "Rayvarz Setup Installer"
};
commandLineApplication.Command("install-package", command =>
{
command.Description = "example: install-package --package BPMS_9603.0.2.0 --jsonConfigFile ./config.json [--jsonConfigBase64 base64Value]";
CommandOption packageIdCommand = command.Option("--package", "Setup Package Id", CommandOptionType.SingleValue);
CommandOption jsonConfigFileCommand = command.Option("--jsonConfigFile", "Full Path to json config file", CommandOptionType.SingleValue);
CommandOption jsonConfigBase64Command = command.Option("--jsonConfigBase64", "Base64 encoded content of json config file", CommandOptionType.SingleValue);
command.OnExecute(() =>
{
if (!packageIdCommand.HasValue() && (!jsonConfigFileCommand.HasValue() && !jsonConfigBase64Command.HasValue()))
{
command.ShowHelp(null);
return(-1);
}
var manifest = packageResolver.GetPackage();
if (manifest == null)
{
Console.Error.WriteLine(string.Format("{0} does not exists.", (object)packageIdCommand.Value()));
return(-1);
}
string jsonConfig = string.Empty;
if (jsonConfigFileCommand.HasValue())
{
jsonConfig = File.ReadAllText(jsonConfigFileCommand.Value());
}
else if (jsonConfigBase64Command.HasValue())
{
jsonConfig = Encoding.UTF8.GetString(Convert.FromBase64String(jsonConfigBase64Command.Value()));
}
var installationResult = cliService.CommandLineInstall(jsonConfig).Result;
if (installationResult)
{
return(1);
}
return(-1);
});
}, true);
commandLineApplication.Command("uninstall-package", (Action <CommandLineApplication>)(command =>
{
CommandOption packageIdCommand = command.Option("--package", "Setup Package Id", CommandOptionType.SingleValue);
CommandOption jsonConfigFileCommand = command.Option("--jsonConfigFile", "Full Path to json config file", CommandOptionType.SingleValue);
CommandOption jsonConfigBase64Command = command.Option("--jsonConfigBase64", "Base64 encoded content of json config file", CommandOptionType.SingleValue);
command.OnExecute(() =>
{
if (!packageIdCommand.HasValue() && (!jsonConfigFileCommand.HasValue() && !jsonConfigBase64Command.HasValue()))
{
command.ShowHelp((string)null);
return(-1);
}
string jsonConfig = string.Empty;
if (jsonConfigFileCommand.HasValue())
{
jsonConfig = File.ReadAllText(jsonConfigFileCommand.Value());
}
else if (jsonConfigBase64Command.HasValue())
{
jsonConfig = Encoding.UTF8.GetString(Convert.FromBase64String(jsonConfigBase64Command.Value()));
}
var installationResult = cliService.CommandLineDelete(jsonConfig).Result;
if (installationResult)
{
return(1);
}
return(-1);
});
}), true);
commandLineApplication.Command("update-package", command =>
{
CommandOption packageIdCommand = command.Option("--package", "Setup Package Id", CommandOptionType.SingleValue);
CommandOption jsonConfigFileCommand = command.Option("--jsonConfigFile", "Full Path to json config file", CommandOptionType.SingleValue);
CommandOption jsonConfigBase64Command = command.Option("--jsonConfigBase64", "Base64 encoded content of json config file", CommandOptionType.SingleValue);
command.OnExecute(() =>
{
if (!packageIdCommand.HasValue() && (!jsonConfigFileCommand.HasValue() && !jsonConfigBase64Command.HasValue()))
{
command.ShowHelp(null);
return(-1);
}
//InstallPathInfo installPathInfo = registery.InstallPaths.SingleOrDefault<InstallPathInfo>((Func<InstallPathInfo, bool>)(ip => ip.Id == new Guid(installPathId.Value())));
//if (registery == null)
//{
// Console.WriteLine(string.Format("\r\n'{0}' not found", (object)result));
// return 1;
//}
//Manifest manifest = packageResolver.GetPackage();
string jsonConfig = string.Empty;
if (jsonConfigFileCommand.HasValue())
{
jsonConfig = File.ReadAllText(jsonConfigFileCommand.Value());
}
else if (jsonConfigBase64Command.HasValue())
{
jsonConfig = Encoding.UTF8.GetString(Convert.FromBase64String(jsonConfigBase64Command.Value()));
}
var installationResult = cliService.CommandLineUpdate(jsonConfig).Result;
if (installationResult)
{
return(1);
}
return(-1);
});
}, true);
try
{
commandLineApplication.Execute(args);
}
catch (CommandParsingException ex)
{
commandLineApplication.ShowHelp(null);
}
finally
{
FreeConsole();
//SendKeys.SendWait("{ENTER}");
}
}
public void Resolver_Complex()
{
var target = new PackageIdentity("EntityFramework", NuGetVersion.Parse("7.0.0-beta4"));
var packages = ResolverData.CreateEntityFrameworkPackageGraph();
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, packages);
var solution = resolver.Resolve(context, CancellationToken.None);
Assert.True(solution.Contains(target, PackageIdentityComparer.Default));
}
public async Task<PackageReaderBase> InstallPackageAsync(PackageIdentity package, NuGetFramework projectFramework, bool ignoreDependencies, CancellationToken token)
{
using (var cacheContext = new SourceCacheContext())
{
var logger = Logger;
var installedPath = PathResolver.GetInstalledPath(package);
if (installedPath != null)
{
return new PackageFolderReader(installedPath);
}
var repositories = SourceRepositoryProvider.GetRepositories();
var dependencyInfoResource = await LocalRepository.GetResourceAsync<DependencyInfoResource>(token);
var installedPackages = (await GetInstalledPackagesAsync(token)).Select(info => info.Identity);
var localPackages = await GetDependencyInfoAsync(dependencyInfoResource, installedPackages, projectFramework);
var sourcePackages = localPackages.ToDictionary(dependencyInfo => dependencyInfo, PackageIdentityComparer.Default);
var packageVersion = new VersionRange(package.Version, new FloatRange(NuGetVersionFloatBehavior.None));
await GetPackageDependencies(package.Id, packageVersion, projectFramework, cacheContext, repositories, sourcePackages, logger, ignoreDependencies, token);
var resolverContext = new PackageResolverContext(
dependencyBehavior: ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior,
targetIds: new[] { package.Id },
requiredPackageIds: Enumerable.Empty<string>(),
packagesConfig: Enumerable.Empty<PackageReference>(),
preferredVersions: new[] { package },
availablePackages: sourcePackages.Values,
packageSources: repositories.Select(repository => repository.PackageSource),
log: NullLogger.Instance);
var resolver = new PackageResolver();
var installOperations = resolver.Resolve(resolverContext, token);
var packagesToRemove = new List<PackageIdentity>();
var licensePackages = new List<IPackageSearchMetadata>();
var findLocalPackageResource = await LocalRepository.GetResourceAsync<FindPackageByIdResource>(token);
foreach (var identity in installOperations)
{
installedPath = PathResolver.GetInstalledPath(identity);
if (installedPath == null)
{
var packageInfo = sourcePackages[identity];
var packageMetadataResource = await packageInfo.Source.GetResourceAsync<PackageMetadataResource>(token);
var packageMetadata = await packageMetadataResource.GetMetadataAsync(identity, cacheContext, NullLogger.Instance, token);
if (packageMetadata.RequireLicenseAcceptance) licensePackages.Add(packageMetadata);
try
{
var existingPackages = await findLocalPackageResource.GetAllVersionsAsync(identity.Id, cacheContext, NullLogger.Instance, token);
packagesToRemove.AddRange(existingPackages.Select(version => new PackageIdentity(identity.Id, version)));
}
catch (NuGetProtocolException)
{
// Ignore exception if packages folder does not exist
continue;
}
}
}
if (licensePackages.Count > 0 && !AcceptLicenseAgreement(licensePackages))
{
token.ThrowIfCancellationRequested();
var pluralSuffix = licensePackages.Count == 1 ? "s" : "";
var message = $"Unable to install package '{package}' because '{string.Join(", ", licensePackages.Select(x => x.Identity))}' require{pluralSuffix} license acceptance.";
throw new InvalidOperationException(message);
}
// Get dependencies from removed packages while they are still installed
if (packagesToRemove.Count > 0)
{
localPackages = await GetDependencyInfoAsync(dependencyInfoResource, packagesToRemove, projectFramework);
await DeletePackages(packagesToRemove, projectFramework, logger, token);
}
var targetPackage = default(PackageReaderBase);
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(Settings, logger),
NullLogger.Instance);
foreach (var identity in installOperations)
{
PackageReaderBase packageReader;
installedPath = PathResolver.GetInstalledPath(identity);
if (installedPath == null)
{
var packageInfo = sourcePackages[identity];
packageReader = await ExtractPackage(packageInfo, projectFramework, cacheContext, packageExtractionContext, logger, token);
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
if (PackageIdentityComparer.Default.Equals(package, identity))
{
targetPackage = packageReader;
}
}
if (packagesToRemove.Count > 0)
{
IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependentPackages, packageDependencies;
installedPackages = (await GetInstalledPackagesAsync(token)).Select(info => info.Identity);
localPackages = localPackages.Union(await GetDependencyInfoAsync(dependencyInfoResource, installedPackages, projectFramework));
GetPackageDependents(installedPackages, localPackages, out dependentPackages, out packageDependencies);
var uninstallOperations = GetPackagesToUninstall(packagesToRemove, packageDependencies, removeDependencies: true);
uninstallOperations = KeepActiveDependencies(uninstallOperations, packagesToRemove, dependentPackages, forceRemoveTargets: true);
await DeletePackages(uninstallOperations, projectFramework, logger, token);
}
return targetPackage;
}
}
public void Resolver_MissingPackage()
{
// No version constraints for any dependency
// A -> B 2.0 -> (C, D)
// A -> B 1.0 -> Missing Package
var packageA = CreatePackage("A", "2.0", new Dictionary<string, string>() { { "B", null } });
var packageB = CreatePackage("B", "2.0", new Dictionary<string, string>() { { "C", null }, { "D", null } });
var packageC = CreatePackage("C", "2.0");
var packageD = CreatePackage("D", "2.0");
// OldB is the lowest but it has a missing dependency
var packageOldB = CreatePackage("B", "1.0", new Dictionary<string, string>() { { "E", null } });
var sourceRepository = new List<ResolverPackage>()
{
packageA,
packageB,
packageC,
packageD,
packageOldB
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, packageA, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count());
Assert.NotNull(packages["A"]);
Assert.NotNull(packages["B"]);
Assert.NotNull(packages["C"]);
Assert.NotNull(packages["D"]);
}
/// <summary>
/// Installs packages on any project that targets the dotnet v4. The packages are added to the packages folder
/// and the packages.config file and the .csproj file is updated.
/// </summary>
/// <param name="packageId">The package to install</param>
/// <param name="projectTargetVersion">The version of .net framework that the project targets.</param>
/// <returns>A completed task of the package installation</returns>
internal async Task InstallPackagesOnDotNetV4FrameworkProjects(string packageId, string projectTargetVersion)
{
using (SourceCacheContext cacheContext = new SourceCacheContext())
{
Logger logger = new Logger(this.messageLogger);
IEnumerable <SourceRepository> repositories = this.SourceRepositoryProvider.GetRepositories();
HashSet <SourcePackageDependencyInfo> availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
NuGetFramework nuGetFramework = NuGetFramework.ParseFolder(projectTargetVersion?.Split('=')[1]);
NuGetVersion packageVersion = await GetPackageLatestNugetVersionAsync(packageId, this.SourceRepository, nuGetFramework.DotNetFrameworkName);
//get all the package dependencies
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, logger, repositories, availablePackages);
PackageResolverContext resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
this.SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
logger);
PackageResolver resolver = new PackageResolver();
IEnumerable <SourcePackageDependencyInfo> packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
PackagePathResolver packagePathResolver = new PackagePathResolver(this.RootPath);
ClientPolicyContext clientPolicyContext = ClientPolicyContext.GetClientPolicy(this.DefaultSettings, logger);
PackageExtractionContext packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
clientPolicyContext,
logger);
foreach (SourcePackageDependencyInfo packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
DownloadResourceResult downloadResult = null;
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
DownloadResource downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(this.DefaultSettings),
logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
///update the packages.config file
await UpdatePackagesConfigFile(packageToInstall, packageReader, downloadResult, nuGetFramework);
UpdateProjectFile(packageReader, installedPath, packageToInstall, nuGetFramework);
}
}
}
public static List <string> LoadPackageAssemblies(string configPath, bool throwException = false)
{
string packagesPath = Folders.GetFolder(FolderType.LocalAppDataPackagesFolder);
List <string> assemblyPaths = new List <string>();
var dependencies = JsonConvert.DeserializeObject <Project>(File.ReadAllText(configPath)).Dependencies;
var packagePathResolver = new PackagePathResolver(packagesPath);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var localRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(packagesPath, "Local OpenBots Repo", true));
var resolver = new PackageResolver();
var frameworkReducer = new FrameworkReducer();
var repositories = new List <SourceRepository>
{
localRepo
};
Parallel.ForEach(dependencies, async dependency =>
{
try
{
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(dependency.Key, NuGetVersion.Parse(dependency.Value)),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { dependency.Key },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader = new PackageFolderReader(packagePathResolver.GetInstalledPath(packageToInstall));
var nearest = frameworkReducer.GetNearest(nuGetFramework, packageReader.GetLibItems().Select(x => x.TargetFramework));
var packageListAssemblyPaths = packageReader.GetLibItems()
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items.Where(i => i.EndsWith(".dll"))).ToList();
if (packageListAssemblyPaths != null)
{
foreach (string path in packageListAssemblyPaths)
{
if (!assemblyPaths.Contains(Path.Combine(packagesPath, $"{packageToInstall.Id}.{packageToInstall.Version}", path)))
{
assemblyPaths.Add(Path.Combine(packagesPath, $"{packageToInstall.Id}.{packageToInstall.Version}", path));
}
}
}
}
}
}
catch (Exception ex)
{
//Only true for scheduled and attended executions
if (throwException)
{
MessageBox.Show($"Unable to load {packagesPath}\\{dependency.Key}.{dependency.Value}. " +
"Please install this package using the OpenBots Studio Package Manager.", "Error");
Application.Exit();
}
else
{
Console.WriteLine(ex);
}
}
});
try
{
return(FilterAssemblies(assemblyPaths));
}
catch (Exception)
{
//try again
return(LoadPackageAssemblies(configPath, throwException));
}
}
private async Task DownloadDependecies(List <PluginDependencyConfig> packages)
{
var repositories = _nugetSourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
var resolver = new PackageResolver();
var frameworkReducer = new FrameworkReducer();
PackageReaderBase packageReader;
using (var context = new SourceCacheContext())
{
foreach (var package in packages)
{
_logger.LogInformation(
$"Getting Dependency for package {package.PackageName} v{package.PackageVersion}");
await GetPackageDependencies(GetPackageIdentity(package.PackageName, package.PackageVersion), context,
repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { package.PackageName },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
_nugetSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
foreach (var packageToInstall in packagesToInstall)
{
var basePath = "";
var installedPath = _packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
_logger.LogInformation(
$"Download package {packageToInstall.Id} {packageToInstall.Version}");
var downloadResource =
await packageToInstall.Source
.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(context),
SettingsUtility.GetGlobalPackagesFolder(_nugetSettings),
NullLogger.Instance, CancellationToken.None);
_logger.LogInformation(
$"Extracting package {packageToInstall.Id} v{packageToInstall.Version}");
var extractedFiles = await PackageExtractor.ExtractPackageAsync(downloadResult.PackageSource,
downloadResult.PackageStream,
_packagePathResolver,
_packageExtractionContext,
CancellationToken.None);
var pathList = extractedFiles.ToArray()[0].Split(Path.DirectorySeparatorChar).ToList();
pathList.RemoveAt(pathList.Count - 1);
basePath = string.Join($"{Path.DirectorySeparatorChar}", pathList);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
var pathList = packageReader.GetNuspecFile().Split(Path.DirectorySeparatorChar).ToList();
pathList.RemoveAt(pathList.Count - 1);
basePath = string.Join($"{Path.DirectorySeparatorChar}", pathList);
}
var libItems = packageReader.GetLibItems();
var nearest =
frameworkReducer.GetNearest(_nuGetFramework, libItems.Select(x => x.TargetFramework));
var items = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
//var frameworkItems = packageReader.GetFrameworkItems();
//nearest = frameworkReducer.GetNearest(_nuGetFramework,
// frameworkItems.Select(x => x.TargetFramework));
//items.AddRange(frameworkItems
// .Where(x => x.TargetFramework.Equals(nearest))
// .SelectMany(x => x.Items));
items.ForEach(lib =>
{
if (!string.IsNullOrEmpty(lib))
{
if (lib.EndsWith(".dll"))
{
if (!lib.Contains("System."))
{
var libName = Path.Combine(_packagesDirectory,
$"{basePath}", lib.Replace('/', Path.DirectorySeparatorChar));
_assembliesToLoad.Add(libName);
}
}
}
;
});
}
}
}
}
public void ResolveDependenciesForInstallDiamondDependencyGraphMissingPackage()
{
// Arrange
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", null }, { "C", null } });
var sourceRepository = new List<ResolverPackage>() {
target,
CreatePackage("B", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("C", "1.0", new Dictionary<string, string>() { { "D", null } }),
};
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
Assert.Equal("Unable to resolve dependency 'D'.", message);
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(PackageIdentity identity)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, OpenRPAPackageManagerLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, OpenRPAPackageManagerLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
// PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
// packageReader = downloadResult.PackageReader;
}
//else
//{
// packageReader = new PackageFolderReader(installedPath);
//}
InstallPackage(packageToInstall);
}
}
return(result);
}
public void ResolveDependenciesForUpdatePackageRequiringUpdatedDependencyThatRequiresUpdatedDependentBySeparatePath()
{
// Arrange
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
// Local:
// A 1.0 -> B [1.0, 2.0), C [1.0, 2.0)
// B 1.0 -> D [1.0, 2.0)
// C 1.0 -> D [1.0, 2.0)
// Remote:
// A 1.1 -> B [1.1, 2.0), C [2.0, 3.0)
// B 1.1 -> D [2.0, 3.0)
// C 2.0 -> D [2.0, 3.0)
// Update initiated on B, not A
var project = new List <PackageReference> {
new PackageReference(new PackageIdentity("A", NuGetVersion.Parse("1.0")), null),
new PackageReference(new PackageIdentity("B", NuGetVersion.Parse("1.0")), null),
new PackageReference(new PackageIdentity("C", NuGetVersion.Parse("1.0")), null),
new PackageReference(new PackageIdentity("D", NuGetVersion.Parse("1.0")), null)
};
var installed = new List <ResolverPackage>();
var sourceRepository = new List <ResolverPackage>();
var packageA1 =
CreatePackage("A", "1.0", new Dictionary <string, string>
{
{ "B", "[1.0, 2.0)" },
{ "C", "[1.0, 2.0)" }
});
installed.Add(packageA1);
var packageB1 =
CreatePackage("B", "1.0", new Dictionary <string, string>
{
{ "D", "[1.0, 2.0)" }
});
installed.Add(packageB1);
var packageC1 =
CreatePackage("C", "1.0", new Dictionary <string, string>
{
{ "D", "[1.0, 2.0)" }
});
installed.Add(packageC1);
var packageD1 = CreatePackage("D", "1.0");
installed.Add(packageD1);
var packageA11 =
CreatePackage("A", "1.1", new Dictionary <string, string>
{
{ "B", "[1.1, 2.0)" },
{ "C", "[2.0, 3.0)" }
});
sourceRepository.Add(packageA11);
var packageB11 =
CreatePackage("B", "1.1", new Dictionary <string, string>
{
{ "D", "[2.0, 3.0)" }
});
sourceRepository.Add(packageB11);
var packageC2 =
CreatePackage("C", "2.0", new Dictionary <string, string>
{
{ "D", "[2.0, 3.0)" }
});
sourceRepository.Add(packageC2);
var packageD2 = CreatePackage("D", "2.0");
sourceRepository.Add(packageD2);
// Act
var resolver = new PackageResolver();
var packageResolverContext
= CreatePackageResolverContext(DependencyBehavior.Lowest, installed, sourceRepository);
var solution = resolver.Resolve(packageResolverContext, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, solution.Length);
Assert.Equal("1.1.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("1.1.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["C"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["D"].Version.ToNormalizedString());
}
public static async Task InstallPackage(string packageId, string version, Dictionary <string, string> projectDependenciesDict, string domainName, string userName, string installDefaultSource = "")
{
string appSettingsDirPath = Directory.GetParent(new EnvironmentSettings().GetEnvironmentVariablePath(domainName, userName)).FullName;
var appSettings = new ApplicationSettings().GetOrCreateApplicationSettings(appSettingsDirPath);
var packageSources = appSettings.ClientSettings.PackageSourceDT.AsEnumerable()
.Where(r => r.Field <string>(0) == "True")
.CopyToDataTable();
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
var settings = NuGet.Configuration.Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var repositories = new List <SourceRepository>();
if (!string.IsNullOrEmpty(installDefaultSource))
{
var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(installDefaultSource, "Default Packages Source", true));
repositories.Add(sourceRepo);
}
else
{
foreach (DataRow row in packageSources.Rows)
{
var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(row[2].ToString(), row[1].ToString(), true));
repositories.Add(sourceRepo);
}
}
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Path.Combine(appSettingsDirPath, "packages"));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
PackageReaderBase packageReader;
PackageDownloadContext downloadContext = new PackageDownloadContext(cacheContext);
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
downloadContext,
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
if (packageToInstall.Id == packageId)
{
if (projectDependenciesDict.ContainsKey(packageToInstall.Id))
{
projectDependenciesDict[packageToInstall.Id] = packageToInstall.Version.ToString();
}
else
{
projectDependenciesDict.Add(packageToInstall.Id, packageToInstall.Version.ToString());
}
}
}
}
}
protected DependencyResolutionResult ResolveDependencies(PackageDescriptor packageDescriptor, IEnumerable <IPackageRepository> repos)
{
return(PackageResolver.TryResolveDependencies(packageDescriptor, repos));
}
public DependencyGraph Analyze(string packageId, string version, string framework)
{
var package = new PackageIdentity(packageId, NuGetVersion.Parse(version));
var settings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
var nuGetFramework = NuGetFramework.ParseFolder(framework);
var nugetLogger = _logger.AsNuGetLogger();
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
var resolvedPackages = new ConcurrentDictionary <PackageIdentity, SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
ResolvePackage(package, nuGetFramework, cacheContext, nugetLogger, repositories, resolvedPackages).Wait();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(resolvedPackages.Values);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
nugetLogger);
var resolver = new PackageResolver();
var prunedPackages = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(x => resolvedPackages[x]);
var rootNode = new PackageReferenceNode(package.Id, package.Version.ToString());
var packageNodes = new Dictionary <string, PackageReferenceNode>(StringComparer.OrdinalIgnoreCase);
var builder = new DependencyGraph.Builder(rootNode);
foreach (var target in prunedPackages)
{
var downloadResource = target.Source.GetResource <DownloadResource>();
var downloadResult = downloadResource.GetDownloadResourceResultAsync(new PackageIdentity(target.Id, target.Version),
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
nugetLogger, CancellationToken.None).Result;
var libItems = downloadResult.PackageReader.GetLibItems();
var reducer = new FrameworkReducer();
var nearest = reducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework));
var assemblyReferences = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Where(x => Path.GetExtension(x).Equals(".dll", StringComparison.OrdinalIgnoreCase))
.Select(x => new AssemblyReferenceNode(Path.GetFileName(x)));
var frameworkItems = downloadResult.PackageReader.GetFrameworkItems();
nearest = reducer.GetNearest(nuGetFramework, frameworkItems.Select(x => x.TargetFramework));
assemblyReferences = assemblyReferences.Concat(frameworkItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Select(x => new AssemblyReferenceNode(x)));
var packageReferenceNode = new PackageReferenceNode(target.Id, target.Version.ToString());
builder.WithNode(packageReferenceNode);
builder.WithNodes(assemblyReferences);
builder.WithEdges(assemblyReferences.Select(x => new Edge(packageReferenceNode, x)));
packageNodes.Add(target.Id, packageReferenceNode);
}
foreach (var target in prunedPackages)
{
var packageReferenceNode = packageNodes[target.Id];
builder.WithEdges(target.Dependencies.Select(x =>
new Edge(packageReferenceNode, packageNodes[x.Id], x.VersionRange.ToString())));
}
return(builder.Build());
}
}
public void ResolveDependenciesForLargeSet()
{
// Arrange
var target = CreatePackage("Package0", "1.0", new Dictionary<string, string>() {
{ "Package1", "1.0.0" },
{ "Package2", "1.0.0" },
{ "Package3", "1.0.0" },
{ "Package4", "1.0.0" },
{ "Package5", "1.0.0" },
{ "Package6", "1.0.0" },
{ "Package7", "1.0.0" },
{ "Package8", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
int next = -1;
// make lots of packages
for (int i = 0; i < 20; i++)
{
for (int j = 1; j < 10; j++)
{
next = j + 1;
sourceRepository.Add(CreatePackage($"Package{j}", $"2.0.{i}", new Dictionary<string, string>() { { $"Package{next}", "1.0.0" } }));
}
}
sourceRepository.Add(CreatePackage($"Package{next}", $"2.0.0"));
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
var packages = resolver.Resolve(context, CancellationToken.None);
// Assert
Assert.Equal(11, packages.Count());
}
public void ResolveDependenciesForLargeSetWithFailure()
{
// Arrange
var target = CreatePackage("Package0", "1.0", new Dictionary<string, string>() {
{ "Package1", "1.0.0" },
{ "Package2", "1.0.0" },
{ "Package3", "1.0.0" },
{ "Package4", "1.0.0" },
{ "Package5", "1.0.0" },
{ "Package6", "1.0.0" },
{ "Package7", "1.0.0" },
{ "Package8", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
// make lots of packages
for (int i = 0; i < 20; i++)
{
for (int j = 1; j < 10; j++)
{
int next = j + 1;
sourceRepository.Add(CreatePackage($"Package{j}", $"2.0.{i}", new Dictionary<string, string>() { { $"Package{next}", "1.0.0" } }));
}
}
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependency 'Package10'.", message);
}
public void ResolveDependenciesForInstallDiamondDependencyGraph()
{
// Arrange
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", null }, { "C", null } });
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("C", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("D", "1.0"),
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count());
Assert.NotNull(packages["A"]);
Assert.NotNull(packages["B"]);
Assert.NotNull(packages["C"]);
Assert.NotNull(packages["D"]);
}
public void ResolvesLowestMajorHighestMinorHighestPatchVersionOfListedPackagesForDependencies()
{
// Arrange
// A 1.0 -> B 1.0
// B 1.0 -> C 1.1
// C 1.1 -> D 1.0
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", "1.0" }
});
var sourceRepository = new List <ResolverPackage>()
{
target,
CreatePackage("B", "2.0", new Dictionary <string, string>()
{
{ "C", "1.1" }
}),
CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "C", "1.1" }
}),
CreatePackage("B", "1.0.1"),
CreatePackage("D", "2.0"),
CreatePackage("C", "1.1.3", new Dictionary <string, string>()
{
{ "D", "1.0" }
}),
CreatePackage("C", "1.1.1", new Dictionary <string, string>()
{
{ "D", "1.0" }
}),
CreatePackage("C", "1.5.1", new Dictionary <string, string>()
{
{ "D", "1.0" }
}),
CreatePackage("B", "1.0.9", new Dictionary <string, string>()
{
{ "C", "1.1" }
}),
CreatePackage("B", "1.1", new Dictionary <string, string>()
{
{ "C", "1.1" }
})
};
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.HighestMinor, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count);
Assert.Equal("2.0.0", packages["D"].Version.ToNormalizedString());
Assert.Equal("1.5.1", packages["C"].Version.ToNormalizedString());
Assert.Equal("1.1.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
}
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
var packageRoot = path.MakeAbsolute(_environment).FullPath;
var targetFramework = type == PackageType.Addin ? _currentFramework : NuGetFramework.AnyFramework;
var sourceRepositoryProvider = new NuGetSourceRepositoryProvider(_nugetSettings, _config, package, packageRoot);
var localAndPrimaryRepositories = new HashSet <SourceRepository>(new NuGetSourceRepositoryComparer());
localAndPrimaryRepositories.AddRange(sourceRepositoryProvider.LocalRepositories);
localAndPrimaryRepositories.AddRange(sourceRepositoryProvider.PrimaryRepositories);
var allRepositories = new HashSet <SourceRepository>(new NuGetSourceRepositoryComparer());
allRepositories.AddRange(localAndPrimaryRepositories);
allRepositories.AddRange(sourceRepositoryProvider.Repositories);
var packageIdentity = GetPackageId(package, localAndPrimaryRepositories, targetFramework, _sourceCacheContext, _nugetLogger);
if (packageIdentity == null)
{
_log.Debug("No package identity returned.");
return(Array.Empty <IFile>());
}
if (packageIdentity.Version.IsPrerelease && !package.IsPrerelease())
{
// If a prerelease version is explicitly specified, we should install that with or without prerelease flag.
_log.Debug("Prerelease version string explicitly specified. Installing prerelease package version.");
}
var pathResolver = new PackagePathResolver(packageRoot);
var dependencyBehavior = GetDependencyBehavior(type, package);
var downloadContext = new PackageDownloadContext(_sourceCacheContext);
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
GetPackageDependencies(packageIdentity,
targetFramework,
_sourceCacheContext,
_nugetLogger,
allRepositories,
availablePackages,
dependencyBehavior,
localAndPrimaryRepositories);
var resolverContext = new PackageResolverContext(
dependencyBehavior,
new[] { packageIdentity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <global::NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
allRepositories.Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))).ToArray();
if (packagesToInstall.Length == 0)
{
_log.Debug("No packages to install after running package resolver.");
}
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Nuspec | PackageSaveMode.Files | PackageSaveMode.Nupkg,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(_nugetSettings, _nugetLogger),
_nugetLogger);
var installedFiles = new List <IFile>();
foreach (var packageToInstall in packagesToInstall)
{
var isTargetPackage = packageToInstall.Id.Equals(package.Package, StringComparison.OrdinalIgnoreCase);
var installPath = new DirectoryPath(pathResolver.GetInstallPath(packageToInstall));
if (!_fileSystem.Exist(installPath))
{
var downloadResource = packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None).GetAwaiter().GetResult();
var downloadResult = downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
downloadContext,
SettingsUtility.GetGlobalPackagesFolder(_nugetSettings),
_nugetLogger, CancellationToken.None).GetAwaiter().GetResult();
PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
pathResolver,
packageExtractionContext,
CancellationToken.None).GetAwaiter().GetResult();
// If this is the target package, to avoid problems with casing, get the actual install path from the nuspec
if (isTargetPackage)
{
installPath = new DirectoryPath(pathResolver.GetInstallPath(downloadResult.PackageReader.GetIdentity()));
}
}
if (_denyListPackages.Contains(packageToInstall.Id))
{
const string format = "Package {0} depends on package {1}. This dependency won't be loaded.";
_log.Debug(format, package.Package, packageToInstall.ToString());
continue;
}
// If the installed package is not the target package, create a new PackageReference
// which is passed to the content resolver. This makes logging make more sense.
var installedPackageReference = isTargetPackage ? package : new PackageReference($"nuget:?package={packageToInstall.Id}");
var assemblies = _contentResolver.GetFiles(installPath, installedPackageReference, type);
if (assemblies.Count == 0)
{
_log.Debug("No assemblies found after running content resolver.");
}
installedFiles.AddRange(assemblies);
}
return(installedFiles);
}
public IEnumerable <SourcePackageDependencyInfo> ResolveDependencyGraph(PackageIdentity pkgId)
{
// We used PackageResolver to flatten the dependency graph. This is the process Nuget uses
// when adding a package to a project. It takes:
// - a list of targets, in this case the package we want to add
// - a list of packages already installed, (i.e. the package that used to be defined in the packages.config)
// * in our case, the packages already added to this service
// - a list of available packages (i.e. the list of packages in the nuget sources).
// * in our case, all the dependencies we already found via GetPackageDependencies
// The resolver will then filter out the list such that only one version of each package
// gets installed.
var resolverContext = new PackageResolverContext(
dependencyBehavior: DependencyBehavior.Lowest,
targetIds: new[] { pkgId.Id },
requiredPackageIds: Enumerable.Empty <string>(),
packagesConfig: Items.Select(p => new PackageReference(p, NETCOREAPP3_1, true)),
preferredVersions: Enumerable.Empty <PackageIdentity>(),
availablePackages: AvailablePackages,
packageSources: Repositories.Select(s => s.PackageSource),
log: Logger);
var resolver = new PackageResolver();
try
{
return(resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => AvailablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))));
}
catch (NuGetResolverConstraintException exception)
{
Logger.LogWarning($"Exception caught when resolving package dependencies: {exception.Message}");
}
/*
* First we try using the NuGet PackageResolver to resolve all package dependencies.
* It's main purpose is to find which version of each package that needs to be loaded
* that satisfies all dependencies.
* But it may fail trying to find the perfect solution because some deeper package
* dependency might not be available, even though that dependency might never be
* needed in runtime.
* So we are opting to try to load our target package and all the available
* dependencies that could be found using the latest versions that are available in
* the local folders.
*/
var uniquePackageIds = AvailablePackages.Select(pkg => pkg.Id).Distinct();
var uniqueAvailablePackages = uniquePackageIds.SelectMany(
pkgId =>
LocalPackagesFinder.FindPackagesById(pkgId, Logger, CancellationToken.None)
.OrderByDescending(pkg => pkg.Identity.Version)
.Take(1)
.Select(
pkg => new SourcePackageDependencyInfo(
id: pkg.Identity.Id,
version: pkg.Identity.Version,
dependencies: AvailablePackages
.Where(d => d.Id == pkg.Identity.Id)
.OrderByDescending(d => d.Version.Version)
.FirstOrDefault()
?.Dependencies ?? new List <PackageDependency>(),
listed: true,
source: GlobalPackagesSource))
);
return(uniqueAvailablePackages);
}
public static async Task Main()
{
var packageId = "cake.nuget";
var packageVersion = NuGetVersion.Parse("0.30.0");
var nuGetFramework = NuGetFramework.ParseFolder("net46");
var settings = Settings.LoadDefaultSettings(root: null);
var packageSourceProvider = new PackageSourceProvider(
settings, new PackageSource[] { new PackageSource("https://api.nuget.org/v3/index.json") });
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages"));
var packageExtractionContext =
new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
var libItems = packageReader.GetLibItems();
var nearest = frameworkReducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
var frameworkItems = packageReader.GetFrameworkItems();
nearest = frameworkReducer.GetNearest(nuGetFramework, frameworkItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", frameworkItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
}
}
async Task GetPackageDependencies(PackageIdentity package,
NuGetFramework framework,
SourceCacheContext cacheContext,
ILogger logger,
IEnumerable <SourceRepository> repositories,
ISet <SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.Contains(package))
{
return;
}
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, framework, cacheContext, logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
foreach (var dependency in dependencyInfo.Dependencies)
{
await GetPackageDependencies(
new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion),
framework, cacheContext, logger, repositories, availablePackages);
}
}
}
}
public virtual NuGetPackage InstallPackage(string packageName, string version, string targetDirectory)
{
if (!Directory.Exists(targetDirectory))
{
Directory.CreateDirectory(targetDirectory);
}
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.AnyFramework;
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(
new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
GetPackageDependencies(
new PackageIdentity(packageName, packageVersion),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageName },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Path.GetFullPath(targetDirectory));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Nuspec | PackageSaveMode.Files | PackageSaveMode.Nupkg,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var downloadContext = new PackageDownloadContext(cacheContext);
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath != null)
{
continue;
}
var downloadResource = packageToInstall.Source
.GetResourceAsync <DownloadResource>(CancellationToken.None).GetAwaiter().GetResult();
var downloadResult = downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
downloadContext,
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance, CancellationToken.None).GetAwaiter().GetResult();
PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None).GetAwaiter().GetResult();
}
}
return(new NuGetPackage(Path.Combine(targetDirectory, $"{packageName}.{version}")));
}
public void ResolveDependenciesForInstallPackageWithUnknownDependencyThrows()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() {
{ "B", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependency 'B'.", message);
}
