private async Task <PackageReaderBase> DownloadPackage(
SourcePackageDependencyInfo packageToInstall,
PackageExtractionContext packageExtractionContext,
ILogger nugetLogger)
{
nugetLogger.LogInformationSummary($"Downloading {Display(packageToInstall)}");
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
using (var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(nugetCache),
globalPackageFolder,
nugetLogger, CancellationToken.None))
{
nugetLogger.LogInformationSummary($"Extracting {Display(packageToInstall)}");
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
return(downloadResult.PackageReader);
}
}
private async Task GetPackageDependenciesAsync(PackageIdentity package,
NuGetFramework framework,
SourceCacheContext cacheContext,
ILogger logger,
IEnumerable <SourceRepository> repositories,
ISet <SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.Contains(package))
{
return;
}
foreach (SourceRepository sourceRepository in repositories)
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
SourcePackageDependencyInfo dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, framework, cacheContext, logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
foreach (PackageDependency dependency in dependencyInfo.Dependencies)
{
await GetPackageDependenciesAsync(
new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion),
framework, cacheContext, logger, repositories, availablePackages);
}
}
}
/// <summary>
/// Retrieve dependency info for a single package.
/// </summary>
/// <param name="package">package id and version</param>
/// <param name="projectFramework">project target framework. This is used for finding the dependency group</param>
/// <param name="token">cancellation token</param>
/// <returns>
/// Returns dependency info for the given package if it exists. If the package is not found null is
/// returned.
/// </returns>
public override async Task <SourcePackageDependencyInfo> ResolvePackage(PackageIdentity package, NuGetFramework projectFramework, Common.ILogger log, CancellationToken token)
{
try
{
SourcePackageDependencyInfo result = null;
// Construct the registration index url
var uri = _regResource.GetUri(package.Id);
// Retrieve the registration blob
var singleVersion = new VersionRange(minVersion: package.Version, includeMinVersion: true, maxVersion: package.Version, includeMaxVersion: true);
var regInfo = await ResolverMetadataClient.GetRegistrationInfo(_client, uri, singleVersion, projectFramework, log, token);
// regInfo is null if the server returns a 404 for the package to indicate that it does not exist
if (regInfo != null)
{
// Parse package and dependeny info from the blob
result = GetPackagesFromRegistration(regInfo, token).FirstOrDefault();
}
return(result);
}
catch (Exception ex)
{
// Wrap exceptions coming from the server with a user friendly message
var error = String.Format(CultureInfo.CurrentUICulture, Strings.Protocol_PackageMetadataError, package, _source);
throw new FatalProtocolException(error, ex);
}
}
public async Task DownloadResourceFromUrl()
{
// Arrange
var repo = Repository.Factory.GetCoreV3(TestSources.NuGetV2Uri);
var downloadResource = await repo.GetResourceAsync <DownloadResource>();
var package = new SourcePackageDependencyInfo("WindowsAzure.Storage", new NuGetVersion("6.2.0"), null, true, repo, new Uri($@"{TestSources.NuGetV2Uri}/package/WindowsAzure.Storage/6.2.0"), "");
// Act & Assert
using (var packagesFolder = TestDirectory.Create())
using (var cacheContext = new SourceCacheContext())
using (var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
package,
new PackageDownloadContext(cacheContext),
packagesFolder,
NullLogger.Instance,
CancellationToken.None))
{
var packageReader = downloadResult.PackageReader;
var files = packageReader.GetFiles();
Assert.Equal(13, files.Count());
}
}
public async Task GetPackageDependencies(PackageIdentity package, SourceCacheContext cacheContext, ISet <SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.Contains(package))
{
return;
}
var repositories = GetSortedRepositories();
foreach (var sourceRepository in repositories)
{
SourcePackageDependencyInfo dependencyInfo = null;
try
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, NuGetFramework, cacheContext, NullLogger.Instance, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
}
catch (Exception ex)
{
}
foreach (var dependency in dependencyInfo.Dependencies)
{
var identity = new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion);
await GetPackageDependencies(identity, cacheContext, availablePackages);
}
break;
}
}
private async Task <DownloadResourceResult> DownloadPackageResourceAsync(
SourcePackageDependencyInfo package, SourceCacheContext cacheContext, CancellationToken cancellationToken, string globalFolder = "")
{
if (string.Equals(globalFolder, ""))
{
globalFolder = DefaultNuGetFolders.GetGlobalPackagesFolder();
}
using (var progressToken = await _downloadingProgressTrackerService?.TrackDownloadOperationAsync(this, package))
{
var downloadResource = await package.Source.GetResourceAsync <DownloadResource>(cancellationToken);
var packageDownloadContext = new PackageDownloadContext(cacheContext);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync
(
package,
new PackageDownloadContext(cacheContext),
globalFolder,
_nugetLogger,
cancellationToken
);
return(downloadResult);
}
}
/// <summary>
/// Convert a V2 feed package into a V3 PackageDependencyInfo
/// </summary>
private SourcePackageDependencyInfo CreateDependencyInfo(
V2FeedPackageInfo packageVersion,
NuGetFramework projectFramework)
{
var deps = Enumerable.Empty <PackageDependency>();
var identity = new PackageIdentity(packageVersion.Id, NuGetVersion.Parse(packageVersion.Version.ToString()));
if (packageVersion.DependencySets != null &&
packageVersion.DependencySets.Any())
{
// Take only the dependency group valid for the project TFM
var nearestFramework = _frameworkReducer.GetNearest(
projectFramework,
packageVersion.DependencySets.Select(group => group.TargetFramework));
if (nearestFramework != null)
{
var matches = packageVersion.DependencySets.Where(e => (e.TargetFramework.Equals(nearestFramework)));
deps = matches.First().Packages;
}
}
var result = new SourcePackageDependencyInfo(
identity,
deps,
packageVersion.IsListed,
_source,
new Uri(packageVersion.DownloadUrl),
packageVersion.PackageHash);
return(result);
}
public async Task DownloadResourceFromInvalidIdInUrl()
{
// Arrange
var repo = Repository.Factory.GetCoreV3(TestSources.NuGetV2Uri);
var downloadResource = await repo.GetResourceAsync <DownloadResource>();
var package = new SourcePackageDependencyInfo("not-found", new NuGetVersion("6.2.0"), null, true, repo, new Uri($@"{TestSources.NuGetV2Uri}/package/not-found/6.2.0"), "");
// Act
using (var packagesFolder = TestDirectory.Create())
using (var cacheContext = new SourceCacheContext())
{
var actual = await downloadResource.GetDownloadResourceResultAsync(
package,
new PackageDownloadContext(cacheContext),
packagesFolder,
NullLogger.Instance,
CancellationToken.None);
// Assert
Assert.NotNull(actual);
Assert.Equal(DownloadResourceResultStatus.NotFound, actual.Status);
}
}
private static string FormatDependencyConstraint(SourcePackageDependencyInfo package, PackageDependency dependency)
{
var range = dependency.VersionRange;
var dependencyString = $"{dependency.Id} {range?.ToNonSnapshotRange().PrettyPrint() ?? string.Empty}";
// A 1.0.0 dependency: B (= 1.5)
return($"'{package.Id} {package.Version.ToNormalizedString()} {Strings.DependencyConstraint}: {dependencyString}'");
}
GetDependencies
(
string id,
string version
)
{
DependencyInfoResource resource = await repository.GetResourceAsync <DependencyInfoResource>(CancellationToken.None);
SourcePackageDependencyInfo package = await resource.ResolvePackage
(
new PackageIdentity(id, new NuGetVersion(version)),
NuGetFramework.AnyFramework,
source_cache,
logger,
cancellationToken
);
if (package == null)
{
throw new InvalidOperationException("Could not locate dependency!");
}
//System.Collections.Concurrent.ConcurrentBag<string> dependency_collection;
//dependency_collection = new System.Collections.Concurrent.ConcurrentBag<string>();
Graph <string, string> dependency_graph = new Graph <string, string>();
foreach (var dependency in package.Dependencies)
{
Node <string> dependency_node = new Node <string>()
{
};
//dependency_collection.Add(dependency.Id + " " + dependency.VersionRange.MinVersion);
}
await Task.WhenAll
(
package.Dependencies.Select
(
async(d) =>
{
var rec = await GetDependencies
(
d.Id,
d.VersionRange.MinVersion.ToNormalizedString()
);
foreach (string s in rec)
{
dependency_collection.Add(s);
}
}
)
);
return(dependency_collection);
}
/// <summary>
/// Add a single package
/// </summary>
public void AddPackageFromSingleVersionLookup(
Configuration.PackageSource source,
PackageIdentity identity,
NuGetFramework framework,
SourcePackageDependencyInfo package)
{
var key = new GatherSingleCacheKey(identity, source, framework);
_singleVersion.TryAdd(key, package);
}
public async Task <IEnumerable <SourcePackageDependencyInfo> > GetPackageAndDependencies(
PackageIdentity packageId,
NuGetFramework packageFramework,
string[] omitDependencies)
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await DoGetPackageDependencies(packageId);
return(availablePackages);
async Task DoGetPackageDependencies(PackageIdentity p)
{
if (availablePackages.Contains(p))
{
return;
}
foreach (var sourceRepository in _repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(p, packageFramework,
_sourceCacheContext, _logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
if (omitDependencies.Any() && dependencyInfo.Dependencies.Any(d => omitDependencies.Contains(d.Id)))
{
var packageDependencies =
dependencyInfo.Dependencies
.Where(d => !omitDependencies.Contains(d.Id))
.Select(d => d);
dependencyInfo = new SourcePackageDependencyInfo(
dependencyInfo.Id,
dependencyInfo.Version,
packageDependencies,
dependencyInfo.Listed,
dependencyInfo.Source);
}
availablePackages.Add(dependencyInfo);
foreach (var dependency in dependencyInfo.Dependencies)
{
var packageIdentity = new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion);
await DoGetPackageDependencies(packageIdentity);
}
}
}
}
/// <summary>
/// This methods updates the project's .csproj file. It adds all the installed packages to the .csproj file.
/// </summary>
/// <param name="packageReader">The <see cref="PackageReaderBase"/> to use in reading the nuget package</param>
/// <param name="installedPath">The folder path where the package was installed or downloaded to</param>
/// <param name="packageToInstall">The package to install with all its dependencies.</param>
/// <param name="nuGetFramework">The <see cref="NuGetFramework"/></param>
private void UpdateProjectFile(
PackageReaderBase packageReader,
string installedPath,
SourcePackageDependencyInfo packageToInstall,
NuGetFramework nuGetFramework)
{
IEnumerable <FrameworkSpecificGroup> dllItems = packageReader.GetLibItems();
if (dllItems != null)
{
FrameworkReducer frameworkReducer = new FrameworkReducer();
NuGetFramework nearest = frameworkReducer.GetNearest(nuGetFramework, dllItems.Select(x => x.TargetFramework));
string targetDllFramework = dllItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).Where(x => x.Contains(".dll")).FirstOrDefault();
if (!string.IsNullOrEmpty(targetDllFramework) && !string.IsNullOrEmpty(installedPath))
{
string targetDllFrameworkPath = Path.Combine(installedPath, targetDllFramework.ToString());
string dllName = Assembly.LoadFile(targetDllFrameworkPath).FullName;
string dllNameWithProcessArchitecture = dllName + "," + " processorArchitecture=MSIL";
ProjectItem item = this.project.GetItems("Reference").FirstOrDefault(a => a.EvaluatedInclude.Contains(packageToInstall.Id));
if (item == null)
{
if (ProjectHelper.CheckIfSolutionAndProjectFilesAreInSameFolder(this.project.DirectoryPath))
{
ProjectItem projectItem = this.project.AddItem("Reference", dllNameWithProcessArchitecture).FirstOrDefault();
projectItem.HasMetadata("HintPath");
projectItem.SetMetadataValue("HintPath", $"packages\\{packageToInstall.Id}.{ packageToInstall.Version}\\{targetDllFramework.Replace(@"/", "\\")}".Replace(@"\\", "//"));
}
else
{
ProjectItem projectItem = this.project.AddItem("Reference", dllNameWithProcessArchitecture).FirstOrDefault();
projectItem.SetMetadataValue("HintPath", $"..\\packages\\{packageToInstall.Id}.{ packageToInstall.Version}\\{targetDllFramework.Replace(@"/", "\\")}".Replace(@"\\", "//"));
}
this.project.Save();
}
ProjectItem dataAnnotationsRef = this.project.GetItems("Reference").FirstOrDefault(a => a.EvaluatedInclude.Contains("System.ComponentModel.DataAnnotations"));
if (dataAnnotationsRef == null)
{
ProjectHelper.AddProjectItem(this.project, "Reference", "System.ComponentModel.DataAnnotations");
}
ProjectItem packageConfigRef = this.project.GetItems("None").FirstOrDefault(a => a.EvaluatedInclude.Contains("packages.config"));
if (packageConfigRef == null)
{
ProjectHelper.AddProjectItem(this.project, "None", "packages.config");
}
}
}
}
SourcePackageDependencyInfo ApplySource(SourcePackageDependencyInfo original)
{
if (original == null)
{
return(null);
}
return(new SourcePackageDependencyInfo(
original.Id,
original.Version,
original.Dependencies,
original.Listed,
Source));
}
private DownloadResourceResult DownloadFromUrl(
SourcePackageDependencyInfo package,
DataServicePackageRepository repository,
NuGet.Common.ILogger logger,
CancellationToken token)
{
IPackage newPackage = null;
var version = SemanticVersion.Parse(package.Version.ToString());
var cacheRepository = MachineCache.Default;
try
{
// Try finding the package in the machine cache
var localPackage = cacheRepository.FindPackage(package.Id, version)
as OptimizedZipPackage;
// Validate the package matches the hash
if (localPackage != null &&
localPackage.IsValid &&
MatchPackageHash(localPackage, package.PackageHash))
{
newPackage = localPackage;
}
}
catch
{
// Ignore cache failures here to match NuGet.Core
// The bad package will be deleted and replaced during the download.
}
// If the local package does not exist in the cache download it from the source
if (newPackage == null)
{
newPackage = DownloadToMachineCache(
cacheRepository,
package,
repository,
package.DownloadUri,
logger,
token);
}
// Read the package from the machine cache
if (newPackage != null)
{
return(new DownloadResourceResult(newPackage.GetStream()));
}
return(null);
}
private static IEnumerable <PackageDependency> GetBrokenDependencies(SourcePackageDependencyInfo package, IEnumerable <PackageIdentity> packages)
{
foreach (var dependency in package.Dependencies)
{
var target = packages.FirstOrDefault(targetPackage => StringComparer.OrdinalIgnoreCase.Equals(targetPackage.Id, dependency.Id));
if (!ResolverUtility.IsDependencySatisfied(dependency, target))
{
yield return(dependency);
}
}
yield break;
}
public static async Task <PackageInformation> DetermineNewestPackage(List <SourceRepository> sourceRepositories, string packageId)
{
SourcePackageDependencyInfo latestPackage = null;
SourceRepository selectedSourceRepository = null;
foreach (var sourceRepository in sourceRepositories)
{
if (sourceRepository.PackageSource?.Credentials?.Password != null)
{
await sourceRepository.GetResourceAsync <HttpHandlerResource>();
}
var resource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
if (resource != null)
{
var results = await resource.ResolvePackages(packageId, NuGetFramework.AnyFramework, new Common.NullLogger(), CancellationToken.None);
if (results.Count() > 0)
{
foreach (var result in results)
{
if (latestPackage == null)
{
latestPackage = result;
selectedSourceRepository = sourceRepository;
}
else
{
if (result.Version.CompareTo(latestPackage.Version) > 0)
{
latestPackage = result;
selectedSourceRepository = sourceRepository;
}
}
}
break;
}
}
}
if (latestPackage == null && selectedSourceRepository == null)
{
return(null);
}
else
{
return(new PackageInformation(latestPackage, selectedSourceRepository));
}
}
/// <summary>
/// Convert a V2 IPackage into a V3 PackageDependencyInfo
/// </summary>
private SourcePackageDependencyInfo CreateDependencyInfo(IPackage packageVersion, NuGetFramework projectFramework)
{
var deps = Enumerable.Empty <V3PackageDependency>();
var identity = new PackageIdentity(packageVersion.Id, NuGetVersion.Parse(packageVersion.Version.ToString()));
if (packageVersion.DependencySets != null &&
packageVersion.DependencySets.Any())
{
// Take only the dependency group valid for the project TFM
var nearestFramework = _frameworkReducer.GetNearest(projectFramework, packageVersion.DependencySets.Select(GetFramework));
if (nearestFramework != null)
{
var matches = packageVersion.DependencySets.Where(e => (GetFramework(e).Equals(nearestFramework)));
IEnumerable <PackageDependency> dependencies = matches.First().Dependencies;
deps = dependencies.Select(item => GetPackageDependency(item));
}
}
SourcePackageDependencyInfo result = null;
var dataPackage = packageVersion as DataServicePackage;
if (dataPackage != null)
{
// Online package
result = new SourcePackageDependencyInfo(
identity,
deps,
PackageExtensions.IsListed(packageVersion),
_source,
dataPackage.DownloadUrl,
dataPackage.PackageHash);
}
else
{
// Offline package
result = new SourcePackageDependencyInfo(
identity,
deps,
PackageExtensions.IsListed(packageVersion),
_source,
downloadUri: null,
packageHash: null);
}
return(result);
}
/// <summary>
/// Convert a package into a PackageDependencyInfo
/// </summary>
private SourcePackageDependencyInfo CreateDependencyInfo(LocalPackageInfo package, NuGetFramework projectFramework)
{
// Take only the dependency group valid for the project TFM
var group = NuGetFrameworkUtility.GetNearest <PackageDependencyGroup>(package.Nuspec.GetDependencyGroups(), projectFramework);
var dependencies = group?.Packages ?? Enumerable.Empty <PackageDependency>();
var result = new SourcePackageDependencyInfo(
package.Identity,
dependencies,
listed: true,
source: _source,
downloadUri: UriUtility.CreateSourceUri(package.Path, UriKind.Absolute),
packageHash: null);
return(result);
}
public async Task <NuGetPackageFilterResult> FilterAsync(SourceRepository repository, IPackageSearchMetadata package, CancellationToken cancellationToken)
{
if (!dependencies.Any())
{
return(NuGetPackageFilterResult.Ok);
}
DependencyInfoResource resource = await repository.GetResourceAsync <DependencyInfoResource>();
if (resource == null)
{
return(NuGetPackageFilterResult.NotCompatible);
}
NuGetPackageFilterResult result = NuGetPackageFilterResult.Ok;
foreach (NuGetFramework framework in frameworks)
{
SourcePackageDependencyInfo dependencyInfo = await resource.ResolvePackage(package.Identity, framework, new SourceCacheContext(), nuGetLogger, cancellationToken);
if (dependencyInfo != null)
{
// Dependency filtering:
// - When incompatible dependency version is found there is a chance that previous version has the right one.
// - When all dependencies are missing, don't even try previous versions.
foreach (var dependency in dependencies)
{
PackageDependency packageDependency = dependencyInfo.Dependencies.FirstOrDefault(p => string.Equals(p.Id, dependency.Id, StringComparison.CurrentCultureIgnoreCase));
if (packageDependency == null)
{
log.Info($"Package '{package.Identity}' skipped: missing dependency '{dependency.Id}'.");
result = NuGetPackageFilterResult.NotCompatible;
}
if (dependency.Version != null && !packageDependency.VersionRange.Satisfies(new NuGetVersion(dependency.Version)))
{
log.Info($"Package '{package.Identity}' skipped: not compatible version '{dependency.Version}' on dependency '{dependency.Id}'.");
return(NuGetPackageFilterResult.NotCompatibleVersion);
}
}
return(result);
}
}
return(NuGetPackageFilterResult.NotCompatible);
}
private async Task DoSearch(NuGetFactory factory, D3DependencyChild current,
int maxLevel,
PackageIdentity package, NuGetFramework fx)
{
if (current.Level > maxLevel)
{
return;
}
// same package may be traversed multiple times, so we can cache it
// don't cache the tree as depth may change for the same package
SourcePackageDependencyInfo packageDependencyInfo = await CacheResolvePackage(factory, package, fx);
if (packageDependencyInfo.Dependencies.Any())
{
if (current.children == null)
{
current.children = new List <D3DependencyChild>();
}
foreach (var dependency in packageDependencyInfo.Dependencies)
{
// unlikely that the version of a particular dependency will change in 30 minutes
// so we can cache it
IEnumerable <NuGetVersion> allVersions = await CacheGetAllVersionsOfDependency(factory, dependency);
if (allVersions.Any())
{
var bestMatch = dependency.VersionRange.FindBestMatch(allVersions);
var child = new D3DependencyChild
{
key = dependency.Id,
version = bestMatch.Version.ToString(),
parent = current.key,
Level = current.Level + 1
};
current.children.Add(child);
var nextPackage = new PackageIdentity(child.key, bestMatch);
await DoSearch(factory, child, maxLevel, nextPackage, fx);
}
}
}
}
/// <summary>
/// Retrieve dependency info for a single package.
/// </summary>
/// <param name="package">package id and version</param>
/// <param name="projectFramework">project target framework. This is used for finding the dependency group</param>
/// <param name="token">cancellation token</param>
/// <returns>
/// Returns dependency info for the given package if it exists. If the package is not found null is
/// returned.
/// </returns>
public override Task <SourcePackageDependencyInfo> ResolvePackage(PackageIdentity package, NuGetFramework projectFramework, Common.ILogger log, CancellationToken token)
{
if (package == null)
{
throw new ArgumentNullException(null, nameof(package));
}
if (projectFramework == null)
{
throw new ArgumentNullException(nameof(projectFramework));
}
SourcePackageDependencyInfo result = null;
SemanticVersion legacyVersion;
// attempt to parse the semver into semver 1.0.0, if this fails then the v2 client would
// not be able to find it anyways and we should return null
if (SemanticVersion.TryParse(package.Version.ToString(), out legacyVersion))
{
try
{
// Retrieve all packages
var repoPackage = GetRepository().FindPackage(
package.Id,
legacyVersion,
allowPrereleaseVersions: true,
allowUnlisted: true);
if (repoPackage != null)
{
// convert to v3 type
result = CreateDependencyInfo(repoPackage, projectFramework);
}
}
catch (Exception ex)
{
// Wrap exceptions coming from the server with a user friendly message
var error = String.Format(CultureInfo.CurrentUICulture, Strings.Protocol_PackageMetadataError, package, V2Client.Source);
throw new FatalProtocolException(error, ex);
}
}
return(Task.FromResult(result));
}
public async Task <string> GetLatestVersionAsync(string packageId)
{
using (SourceCacheContext cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = _sourceRepositoryProvider.GetRepositories();
foreach (var repo in repositories)
{
DependencyInfoResource dependencyInfoResource = repo.GetResource <DependencyInfoResource>();
IEnumerable <SourcePackageDependencyInfo> packages = await dependencyInfoResource.ResolvePackages(packageId, _nuGetFramework, cacheContext, _logger, CancellationToken.None);
if (packages != null && packages.Count() > 0)
{
SourcePackageDependencyInfo version = packages.Where(p => p.Listed && !p.Version.IsPrerelease).OrderByDescending(x => x.Version).First();
return(version.Version.ToNormalizedString());
}
}
return(null);
}
}
public async Task DownloadResourceFromInvalidIdInUrl()
{
// Arrange
var repo = Repository.Factory.GetCoreV3(TestServers.NuGetV2);
var downloadResource = await repo.GetResourceAsync <DownloadResource>();
var package = new SourcePackageDependencyInfo("not-found", new NuGetVersion("6.2.0"), null, true, repo, new Uri($@"{TestServers.NuGetV2}/package/not-found/6.2.0"), "");
// Act
var actual = await downloadResource.GetDownloadResourceResultAsync(
package,
NullSettings.Instance,
NullLogger.Instance,
CancellationToken.None);
// Assert
Assert.NotNull(actual);
Assert.Equal(DownloadResourceResultStatus.NotFound, actual.Status);
}
public async Task DownloadResourceFromUrl()
{
// Arrange
var repo = Repository.Factory.GetCoreV3(TestServers.NuGetV2);
var downloadResource = await repo.GetResourceAsync <DownloadResource>();
var package = new SourcePackageDependencyInfo("WindowsAzure.Storage", new NuGetVersion("6.2.0"), null, true, repo, new Uri($@"{TestServers.NuGetV2}/package/WindowsAzure.Storage/6.2.0"), "");
// Act & Assert
using (var downloadResult = await downloadResource.GetDownloadResourceResultAsync(package,
NullSettings.Instance,
NullLogger.Instance,
CancellationToken.None))
{
var packageReader = downloadResult.PackageReader;
var files = packageReader.GetFiles();
Assert.Equal(11, files.Count());
}
}
/// <summary>
/// Retrieve dependency info for a single package.
/// </summary>
/// <param name="package">package id and version</param>
/// <param name="projectFramework">project target framework. This is used for finding the dependency group</param>
/// <param name="token">cancellation token</param>
public override Task <SourcePackageDependencyInfo> ResolvePackage(
PackageIdentity package,
NuGetFramework projectFramework,
SourceCacheContext sourceCacheContext,
ILogger log,
CancellationToken token)
{
if (package == null)
{
throw new ArgumentNullException(null, nameof(package));
}
if (projectFramework == null)
{
throw new ArgumentNullException(nameof(projectFramework));
}
SourcePackageDependencyInfo result = null;
try
{
// Retrieve all packages
var repoPackage = _localResource.GetPackage(package, log, token);
if (repoPackage != null)
{
// convert to v3 type
result = CreateDependencyInfo(repoPackage, projectFramework);
}
}
catch (Exception ex)
{
// Wrap exceptions coming from the server with a user friendly message
var error = string.Format(CultureInfo.CurrentUICulture, Strings.Protocol_PackageMetadataError, package, _localResource.Root);
throw new FatalProtocolException(error, ex);
}
return(Task.FromResult(result));
}
public async Task <(PackageReaderBase package, string installPath)> DownloadPackage(
SourcePackageDependencyInfo packageToInstall)
{
var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages"));
var packageExtractionContext =
new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(_settings, _logger),
_logger);
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath != null)
{
return(new PackageFolderReader(installedPath), installedPath);
}
var downloadResource =
await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(_sourceCacheContext),
SettingsUtility.GetGlobalPackagesFolder(_settings),
_logger,
CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
return(downloadResult.PackageReader, installedPath);
}
public async Task GetPackageDependencies(PackageIdentity package, SourceCacheContext cacheContext, ISet <SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.Contains(package))
{
return;
}
//var repositories = SourceRepositoryProvider.GetRepositories();
var repositories = GetSortedRepositories();
foreach (var sourceRepository in repositories)
{
SourcePackageDependencyInfo dependencyInfo = null;
// #11 Tighten the try-catch scope due to localization probrem.
try
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, NuGetFramework, Logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
}
catch (Exception err)
{
}
foreach (var dependency in dependencyInfo.Dependencies)
{
var identity = new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion);
await GetPackageDependencies(identity, cacheContext, availablePackages);
}
break;//只要有一个源能搜索到就不再往下搜索了
}
}
private async Task<PackageReaderBase> ExtractPackage(
SourcePackageDependencyInfo packageInfo,
NuGetFramework projectFramework,
SourceCacheContext cacheContext,
PackageExtractionContext packageExtractionContext,
ILogger logger,
CancellationToken token)
{
logger.LogInformation($"Installing package '{packageInfo.Id} {packageInfo.Version}'.");
var downloadResource = await packageInfo.Source.GetResourceAsync<DownloadResource>(token);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageInfo,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(Settings),
logger, token);
var installPath = PathResolver.GetInstallPath(packageInfo);
foreach (var plugin in PackageManagerPlugins)
{
var accepted = await plugin.OnPackageInstallingAsync(packageInfo, projectFramework, downloadResult.PackageReader, installPath);
if (!accepted) return downloadResult.PackageReader;
}
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
PathResolver,
packageExtractionContext,
token);
installPath = PathResolver.GetInstalledPath(packageInfo);
foreach (var plugin in PackageManagerPlugins)
{
await plugin.OnPackageInstalledAsync(packageInfo, projectFramework, downloadResult.PackageReader, installPath);
}
return downloadResult.PackageReader;
}
public static IEnumerable <SourcePackageDependencyInfo> PruneAllButHighest(IEnumerable <SourcePackageDependencyInfo> packages, string packageId)
{
SourcePackageDependencyInfo highest = null;
foreach (var package in packages)
{
if (string.Equals(package.Id, packageId, StringComparison.OrdinalIgnoreCase))
{
if (highest == null || highest.Version < package.Version)
{
highest = package;
}
}
}
if (highest == null)
{
return(packages);
}
else
{
return(packages.Where(p => !p.Id.Equals(packageId, StringComparison.OrdinalIgnoreCase) || p == highest));
}
}