public virtual async Task <IEnumerable <SourcePackageDependencyInfo> > GetDependenciesAsync(PackageIdentity identity, SourceCacheContext cacheContext)
{
var packageSourceProvider = new PackageSourceProvider(m_NugetSettings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, m_Providers);
var sourceRepositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependenciesAsync(identity, cacheContext, sourceRepositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
Logger);
return(m_PackageResolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x
=> PackageIdentityComparer.Default.Equals(x, p))));
}
/// Flattens the list of dependency packages to a single list of packages to be installed.
public IEnumerable <SourcePackageDependencyInfo> ResolveDependencyGraph(PackageIdentity pkgId, IEnumerable <SourcePackageDependencyInfo> dependencies)
{
// 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_0, true)),
preferredVersions: Enumerable.Empty <PackageIdentity>(),
availablePackages: dependencies,
packageSources: Repositories.Select(s => s.PackageSource),
log: Logger);
var resolver = new PackageResolver();
return(resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => dependencies.Single(x => PackageIdentityComparer.Default.Equals(x, p))));
}
public void ResolverInputSort_TreeFlatten_EmptyList()
{
// Arrange
var targets = new List <string> {
"a"
};
var installed = CreateInstalledReferences("b");
var packages = new List <SourcePackageDependencyInfo>();
var context = new PackageResolverContext(DependencyBehavior.Lowest,
targets,
installed.Select(package => package.PackageIdentity.Id),
installed,
Enumerable.Empty <PackageIdentity>(),
packages,
Enumerable.Empty <PackageSource>(),
Common.NullLogger.Instance);
var grouped = GroupPackages(packages);
// Act
var sorted = ResolverInputSort.TreeFlatten(grouped, context);
var order = sorted.Select(group => group.First().Id.ToLowerInvariant()).ToList();
// Assert
Assert.Equal(0, order.Count);
}
public async Task DownloadAndInstall(PackageIdentity identity)
{
//包源靠前的地址已经找到和安装了包的时候不要再继续下面的包源操作了
try
{
using (var cacheContext = new SourceCacheContext())
{
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(PackagesInstallFolder);
var packageExtractionContext = new PackageExtractionContext(Logger);
packageExtractionContext.PackageSaveMode = PackageSaveMode.Defaultv3;
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),
Logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
}
InstallPackage(packageToInstall);
}
}
}
catch (Exception ex)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "下载和安装nupkg包过程中出错", ex);
}
}
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());
}
/// <summary>
/// This method looks for the requestedPackage and downloads it.
/// If requested, it also installs the dependencies associated with the requestedPackage
/// </summary>
/// <param name="requestedPackage"></param>
/// <param name="autoInstallDependencis"></param>
/// <returns></returns>
static async Task PerformPackageActionAsync(NugetPackage requestedPackage, bool autoInstallDependencis, List <NugetPackage> installedPackages, Func <NugetPackage, SourcePackageDependencyInfo, ISettings, SourceCacheContext, List <NugetPackage>, Task> action)
{
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
var packageId = requestedPackage.Id;
var packageVersion = requestedPackage.VersionRange.MinVersion;
var nuGetFramework = NuGetFramework.ParseFolder(requestedPackage.TargetFramework);
var settings = Settings.LoadDefaultSettings(root: requestedPackage.RootPath);
var providers = Repository.Provider.GetCoreV3();
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers);
var repositories = new List <SourceRepository>();
if (requestedPackage.Source != null)
{
repositories.Add(Repository.CreateSource(providers, new PackageSource(requestedPackage.Source.ToString())));
}
foreach (var depSource in requestedPackage.DependencySources)
{
repositories.Add(Repository.CreateSource(providers, new PackageSource(depSource.ToString())));
}
repositories.AddRange(sourceRepositoryProvider.GetRepositories());
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
var dependencyWalkLevel = autoInstallDependencis? -1 : 0;
await GetPackageDependencyInfo(dependencyWalkLevel,
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, _logger, repositories, availablePackages, installedPackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
repositories.Select(s => s.PackageSource),
_logger);
IEnumerable <SourcePackageDependencyInfo> packagesToInstall = null;
if (autoInstallDependencis)
{
packagesToInstall = availablePackages;
}
else
{
packagesToInstall = availablePackages.Take(1);
}
foreach (var packageToInstall in packagesToInstall)
{
await action(requestedPackage, packageToInstall, settings, cacheContext, installedPackages);
}
}
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(Project project, PackageIdentity identity, bool LoadDlls)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = DefaultSourceRepositoryProvider.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,
DefaultSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
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(PackagesInstallFolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, NullLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
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,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(PackagesInstallFolder,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
}
// per project or joined ?
// string TargetFolder = System.IO.Path.Combine(project.Path, "extensions");
string TargetFolder = System.IO.Path.Combine(Interfaces.Extensions.ProjectsDirectory, "extensions");
InstallPackage(TargetFolder, packageToInstall, LoadDlls);
}
}
return(result);
}
public void ResolveDependenciesForVeryDeepGraph()
{
// 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);
var next = 1;
// make lots of packages
for (var j = 1; j < 1000; j++)
{
next = j + 1;
sourceRepository.Add(CreatePackage($"Package{j}", "1.0.0", new Dictionary <string, string>()
{
{ $"Package{next}", "1.0.0" }
}));
}
sourceRepository.Add(CreatePackage($"Package{next}", "1.0.0"));
var resolver = new PackageResolver();
var context = new PackageResolverContext(DependencyBehavior.Lowest,
new[] { target.Id }, Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
new[] { target },
sourceRepository,
Enumerable.Empty <PackageSource>(),
Common.NullLogger.Instance);
// Act
var packages = resolver.Resolve(context, CancellationToken.None);
// Assert
Assert.Equal(1001, packages.Count());
}
public static async Task InstallWithDependencies(string packageId, string version, string frameworkVersion, ILogger logger)
{
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.ParseFolder(frameworkVersion);
var settings = Settings.LoadDefaultSettings(root: null);
var feed = new Uri("https://api.nuget.org/v3/index.json");
var repositoryList = new List <SourceRepository>();
repositoryList.Add(Repository.Factory.GetCoreV3(feed.AbsoluteUri, FeedType.HttpV3));
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, logger, repositoryList, 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),
logger);
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, logger),
logger);
//new PackageSignatureVerifier(
// signatureVerification.GetSignatureVerificationProviders()),
//SignedPackageVerifierSettings.GetDefault());
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
InstallPackages(packagePathResolver, packageToInstall, cacheContext, packageExtractionContext,
frameworkReducer, nuGetFramework, settings, logger);
}
}
}
public void ResolverInputSort_TreeFlatten_OverlappingTree()
{
// Arrange
var targets = new List <string> {
"a"
};
var installed = CreateInstalledReferences();
var packages = new List <SourcePackageDependencyInfo>();
packages.Add(CreatePackage("a", "1.0.0", new Dictionary <string, string>()
{
{ "b", "1.0.0" }, { "c", "1.0.0" }
}));
packages.Add(CreatePackage("b", "1.0.0", new Dictionary <string, string>()
{
{ "d", "1.0.0" }, { "e", "1.0.0" }
}));
packages.Add(CreatePackage("c", "1.0.0", new Dictionary <string, string>()
{
{ "d", "2.0.0" }
}));
packages.Add(CreatePackage("d", "1.0.0"));
packages.Add(CreatePackage("e", "1.0.0"));
packages.Add(CreatePackage("d", "2.0.0"));
var context = new PackageResolverContext(DependencyBehavior.Lowest,
targets,
installed.Select(package => package.PackageIdentity.Id),
installed,
Enumerable.Empty <PackageIdentity>(),
packages,
Enumerable.Empty <PackageSource>(),
Common.NullLogger.Instance);
var grouped = GroupPackages(packages);
// Act
var sorted = ResolverInputSort.TreeFlatten(grouped, context);
var order = sorted.Select(group => group.First().Id.ToLowerInvariant()).ToList();
// Assert
Assert.Equal(5, order.Count);
Assert.Equal("a", order[0]);
Assert.Equal("b", order[1]);
Assert.Equal("e", order[2]);
Assert.Equal("c", order[3]);
Assert.Equal("d", order[4]);
}
public async Task <List <PackageSearchItem> > GetLocal(Project project, PackageIdentity identity)
{
var result = new List <PackageSearchItem>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = DefaultSourceRepositoryProvider.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,
DefaultSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
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(PackagesInstallFolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, NullLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath != null)
{
// per project or joined ?
// string TargetFolder = System.IO.Path.Combine(project.Path, "extensions");
string TargetFolder = System.IO.Path.Combine(Interfaces.Extensions.ProjectsDirectory, "extensions");
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
result.Add(new PackageSearchItem(project, packageReader));
}
}
}
return(result);
}
public static async Task <List <NuGetPackage> > GetAllPackageDependencies(List <NuGetPackage> pkgs,
string framework)
{
var allPkgs = new List <NuGetPackage>();
var packagesToInstall = new List <SourcePackageDependencyInfo>();
var settings = Settings.LoadDefaultSettings(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);
foreach (var package in pkgs)
{
var packageId = package.Id;
await GetPackageDependencies(
new PackageIdentity(package.Id, NuGetVersion.Parse(package.Version)),
NuGetFramework.ParseFolder(framework), cacheContext, NullLogger.Instance, repositories,
availablePackages);
}
var resolverContext = new PackageResolverContext(
DependencyBehavior.Highest,
pkgs.Select(p => p.Id).ToArray(),
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
packagesToInstall.AddRange(resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))));
foreach (var package in pkgs)
{
package.Dependencies = packagesToInstall.First(p => p.Id == package.Id).Dependencies.Select(dep => dep.Id).ToArray();
}
return(pkgs);
}
public void ResolverInputSort_TreeFlatten_Priority()
{
// Arrange
var targets = new List <string> {
"m"
};
var installed = CreateInstalledReferences("x");
var packages = new List <SourcePackageDependencyInfo>();
packages.Add(CreatePackage("m", "1.0.0"));
packages.Add(CreatePackage("x", "1.0.0"));
packages.Add(CreatePackage("a", "1.0.0"));
packages.Add(CreatePackage("b", "1.0.0"));
var context = new PackageResolverContext(DependencyBehavior.Lowest,
targets,
installed.Select(package => package.PackageIdentity.Id),
installed,
Enumerable.Empty <PackageIdentity>(),
packages,
Enumerable.Empty <PackageSource>(),
Common.NullLogger.Instance);
var grouped = GroupPackages(packages);
// Act
var sorted = ResolverInputSort.TreeFlatten(grouped, context);
var order = sorted.Select(group => group.First().Id.ToLowerInvariant()).ToList();
// Assert
Assert.Equal(4, order.Count);
// installed first
Assert.Equal("x", order[0]);
// targets
Assert.Equal("m", order[1]);
// new target dependencies
Assert.Equal("a", order[2]);
Assert.Equal("b", order[3]);
}
private IEnumerable <SourcePackageDependencyInfo> ResolvePackages(
PackageIdentity package,
ISet <SourcePackageDependencyInfo> dependencies,
ILogger nugetLogger)
{
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { package.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
dependencies,
repositories.Select(s => s.PackageSource),
nugetLogger);
return(new PackageResolver()
.Resolve(resolverContext, CancellationToken.None)
.Select(packageIdentity => dependencies
.Single(dependency => PackageIdentityComparer.Default.Equals(dependency, packageIdentity))
));
}
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 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 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 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}")));
}
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 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 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 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 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());
}
}
}
}
}
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);
}
}
}
}
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 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);
}
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());
}
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 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());
}
public async Task Download(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
if (identity.HasVersion && !string.IsNullOrEmpty(installedPath))
{
var idstring = identity.Id + "." + identity.Version;
if (installedPath.Contains(idstring))
{
return;
}
}
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageWithoutDependencies(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 packageToInstall = availablePackages.Where(p => p.Id == identity.Id).FirstOrDefault();
if (packageToInstall == null)
{
throw new Exception("Failed finding package " + identitystring(identity));
}
// 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();
// PackageReaderBase packageReader;
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),
Logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
// packageReader = downloadResult.PackageReader;
// }
//else
//{
// packageReader = new PackageFolderReader(installedPath);
//}
}
return;
}
/// <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);
}
}
}
