public IPackageSearchMetadata GetPackageFromRepoWithVersion(string packageName,
string version,
PackageMetadataResource packageMetadataResource,
SourceCacheContext sourceCacheContext,
SourceRepository sourceRepository)
{
IPackageSearchMetadata rootPackage = null;
if (NuGetVersion.TryParse(version, out var _nugetversion))
{
var packageIdentity = new PackageIdentity(packageName, NuGetVersion.Parse(version));
var exacactsearchMetadata = packageMetadataResource.GetMetadataAsync(packageIdentity, sourceCacheContext, Logger, CancellationToken.None)
.Result;
if (exacactsearchMetadata == null)
{
Logger.LogDebug("GetPackageFromRepoWithVersion - No Package found in Repo " + $"{sourceRepository.PackageSource.Source} for package : {packageName} with version {version}");
}
else
{
rootPackage = exacactsearchMetadata;
}
}
return(rootPackage);
}
public List <PackageIdentity> GetChildPackageIdentities(IPackageSearchMetadata rootPackage)
{
List <PackageIdentity> childPackageIdentities = new List <PackageIdentity>();
//
//load child package identity , if there is any dependency set
if (rootPackage.DependencySets != null && rootPackage.DependencySets.Count() > 0)
{
//check specific dependency set for this version only //note our _targetFramwork is .NETCoreApp,Version=v2.0
//while the deps may be for .NETStandard,Version=v2.0 or .NETCoreApp,Version = v2.0 as well.
var nugetFramwork = NuGetFramework.ParseFrameworkName(NugetHelper.Instance.GetTargetFramwork(), new DefaultFrameworkNameProvider());
var mostCompatibleFramework = NugetHelper.Instance.GetMostCompatibleFramework(nugetFramwork, rootPackage.DependencySets);
if (rootPackage.DependencySets.Any(x => x.TargetFramework == mostCompatibleFramework))
{
var depsForTargetFramwork = rootPackage.DependencySets.Where(x => x.TargetFramework == mostCompatibleFramework).FirstOrDefault();
if (depsForTargetFramwork.Packages.Count() > 0)
{
foreach (var package in depsForTargetFramwork.Packages)
{
PackageIdentity _identity = new PackageIdentity(package.Id, package.VersionRange.MinVersion);
if (_identity != null)
{
childPackageIdentities.Add(_identity);
}
}
}
}
}
//
return(childPackageIdentities);
}
/// <summary>
/// Downloads a specified NuGet package.
/// </summary>
/// <param name="packageMetadata">The package to download.</param>
/// <param name="token">A cancellation token to allow cancellation of the task.</param>
public async Task <DownloadResourceResult> DownloadPackageAsync(IPackageSearchMetadata packageMetadata, CancellationToken token = default)
{
var packageIdentity = new PackageIdentity(packageMetadata.Identity.Id, packageMetadata.Identity.Version);
var downloadContext = new PackageDownloadContext(new SourceCacheContext(), Environment.CurrentDirectory, true);
return(await _downloadResource.GetDownloadResourceResultAsync(packageIdentity, downloadContext, Path.GetTempPath(), _nullLogger, token));
}
public CatalogEntry(IPackageSearchMetadata package, string catalogUri, string packageContent, Func <string, Uri> getRegistrationUrl)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
CatalogUri = catalogUri ?? throw new ArgumentNullException(nameof(catalogUri));
PackageId = package.Identity.Id;
Version = package.Identity.Version.ToFullString();
Authors = string.Join(", ", package.Authors);
Description = package.Description;
Downloads = package.DownloadCount.GetValueOrDefault(0);
HasReadme = false; //
IconUrl = NullSafeToString(package.IconUrl);
Language = null; //
LicenseUrl = NullSafeToString(package.LicenseUrl);
Listed = package.IsListed;
//MinClientVersion =
PackageContent = packageContent;
ProjectUrl = NullSafeToString(package.ProjectUrl);
//RepositoryUrl = package.RepositoryUrlString;
//RepositoryType = package.RepositoryType;
//Published = package.Published.GetValueOrDefault(DateTimeOffset.MinValue);
RequireLicenseAcceptance = package.RequireLicenseAcceptance;
Summary = package.Summary;
Tags = package.Tags == null ? null : package.Tags.Split(',');
Title = package.Title;
DependencyGroups = ToDependencyGroups(package.DependencySets, catalogUri, getRegistrationUrl);
}
private Package ConstructPackage(IPackageSearchMetadata packageMetaData, string downloadUrl, byte[] content)
{
if ((packageMetaData == null) || (content == null))
{
return(null);
}
var package = new Package()
{
Authors = packageMetaData.Authors,
Content = content,
Description = packageMetaData.Description,
DownloadCount = packageMetaData.DownloadCount,
IconUrl = packageMetaData.IconUrl,
Id = packageMetaData.Identity.Id,
IsListed = packageMetaData.IsListed,
LicenseNames = packageMetaData?.LicenseMetadata?.License,
LicenseUrl = packageMetaData.LicenseUrl,
Owners = packageMetaData.Owners,
PackageDownloadUrl = downloadUrl,
PackageUrl = GetPackageUrl(packageMetaData),
ProjectUrl = packageMetaData.ProjectUrl,
Published = packageMetaData.Published,
ReportAbuseUrl = packageMetaData.ReportAbuseUrl,
RequireLicenseAcceptance = packageMetaData.RequireLicenseAcceptance,
Summary = packageMetaData.Summary,
Tags = packageMetaData.Tags,
Title = packageMetaData.Title,
Version = packageMetaData.Identity.Version.OriginalVersion,
};
return(package);
}
public NugetDetailsViewModel(IPackageSearchMetadata metadata) : base()
{
this.metadata = metadata;
url = new Uri("https://git.io/fAlfh");
OpenPageCommand = ReactiveCommand.Create(OpenPage);
}
public async Task <(IPackageSearchMetadata metadata, PackageSource source)> GetLatestPackage(
string packageName, IEnumerable <SourceRepository> sourceRepositories,
bool includePrerelease, bool includeUnlisted,
bool disableCache)
{
IPackageSearchMetadata packageMetadata = null;
PackageSource sourceRepo = null;
// var sourceRepos = NugetHelper.Instance.GetSourceRepos(repositories);
foreach (var sourceRepository in sourceRepositories)
{
var metadata = await GetLatestPackage(packageName, sourceRepository, includePrerelease, includeUnlisted,
disableCache);
if (packageMetadata == null ||
metadata != null && metadata.Identity.HasVersion && !packageMetadata.Identity.HasVersion ||
metadata != null && metadata.Identity.HasVersion &&
packageMetadata.Identity.HasVersion &&
metadata.Identity.Version > packageMetadata.Identity.Version)
{
packageMetadata = metadata;
sourceRepo = sourceRepository.PackageSource;
}
}
return(packageMetadata, sourceRepo);
}
public async ValueTask <PackageDeprecationMetadataContextInfo?> GetDeprecationMetadataAsync(
PackageIdentity identity,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
bool includePrerelease,
CancellationToken cancellationToken)
{
Assumes.NotNull(identity);
Assumes.NotNullOrEmpty(packageSources);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(identity.Id, includePrerelease, packageSources);
PackageSearchMetadataCacheItem?backgroundDataCache = PackageSearchMetadataMemoryCache.Get(cacheId) as PackageSearchMetadataCacheItem;
if (backgroundDataCache != null)
{
PackageSearchMetadataCacheItemEntry cacheItem = await backgroundDataCache.GetPackageSearchMetadataCacheVersionedItemAsync(identity, cancellationToken);
return(await cacheItem.PackageDeprecationMetadataContextInfo);
}
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IPackageSearchMetadata packageMetadata = await packageMetadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
PackageDeprecationMetadata deprecationMetadata = await packageMetadata.GetDeprecationMetadataAsync();
if (deprecationMetadata == null)
{
return(null);
}
return(PackageDeprecationMetadataContextInfo.Create(deprecationMetadata));
}
/// <summary>
/// Creates a web downloadable package from a NuGet source.
/// </summary>
/// <param name="pkg">The search result.</param>
/// <param name="repository">The NuGet repository to use.</param>
/// <param name="getReadme">If true, tries to pull readme from the server.</param>
/// <param name="getReleaseNotes">If true, tries to pull release notes from the server.</param>
public static async Task <WebDownloadablePackage> FromNuGetAsync(IPackageSearchMetadata pkg, INugetRepository repository, bool getReadme = false, bool getReleaseNotes = false)
{
var result = new WebDownloadablePackage()
{
Name = !string.IsNullOrEmpty(pkg.Title) ? pkg.Title : pkg.Identity.Id,
Source = repository.FriendlyName,
Id = pkg.Identity.Id,
Authors = pkg.Authors,
Submitter = new Submitter()
{
UserName = pkg.Authors
},
Description = pkg.Description,
Version = pkg.Identity.Version,
ProjectUri = pkg.ProjectUrl,
DownloadCount = pkg.DownloadCount,
Tags = pkg.Tags?.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
};
var resolver = GetNuGetUpdateResolver(pkg, repository);
result._url = new Uri((await resolver.GetDownloadUrlAsync(pkg.Identity.Version, new ReleaseMetadataVerificationInfo(), CancellationToken.None)) !);
_ = InitNuGetAsyncData(result, pkg, repository, resolver, getReadme, getReleaseNotes);
if (pkg.IconUrl != null)
{
result.Images = new[] { new DownloadableImage()
{
Uri = pkg.IconUrl
} }
}
;
return(result);
}
private static PackageInfo CreatePackageInfo(IPackageSearchMetadata packageSearchMetadata, FeedType feedType, IEnumerable <VersionInfo>?versionInfos, PackageDeprecationMetadata?deprecationMetadata)
{
DateTimeOffset?published = null;
if (packageSearchMetadata.Published.HasValue && packageSearchMetadata.Published.Value.Year > 1900)
{
// Note nuget.org reports 1900 for unlisted packages. Pretty sure it's was published later ;)
published = packageSearchMetadata.Published;
}
var versionInfo = versionInfos?.FirstOrDefault(v => v.Version == packageSearchMetadata.Identity.Version);
var downloadCount = (int?)(versionInfo?.DownloadCount ?? packageSearchMetadata.DownloadCount);
return(new PackageInfo(packageSearchMetadata.Identity)
{
Authors = packageSearchMetadata.Authors,
Published = published,
DownloadCount = downloadCount,
DeprecationInfo = ConvertPackageDeprecationMetadata(deprecationMetadata),
IsRemotePackage = (feedType == FeedType.HttpV3 || feedType == FeedType.HttpV2),
IsPrefixReserved = packageSearchMetadata.PrefixReserved,
Description = packageSearchMetadata.Description,
Tags = packageSearchMetadata.Tags,
Summary = packageSearchMetadata.Summary,
LicenseUrl = packageSearchMetadata.LicenseUrl?.ToString() ?? string.Empty,
ProjectUrl = packageSearchMetadata.ProjectUrl?.ToString() ?? string.Empty,
ReportAbuseUrl = packageSearchMetadata.ReportAbuseUrl?.ToString() ?? string.Empty,
IconUrl = packageSearchMetadata.IconUrl?.ToString() ?? string.Empty,
ReadmeUrl = packageSearchMetadata.ReadmeUrl?.ToString() ?? string.Empty
});
}
public static IPackageSearchMetadata WithVersions(this IPackageSearchMetadata metadata, Func <IEnumerable <VersionInfo> > valueFactory)
{
return(PackageSearchMetadataBuilder
.FromMetadata(metadata)
.WithVersions(AsyncLazy.New(valueFactory))
.Build());
}
internal override async Task <IPackageSearchMetadata> GetPackageMetadataAsync <T>(T identity, bool includePrerelease, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (identity is PackageCollectionItem pkgColItem)
{
IEnumerable <ITransitivePackageReferenceContextInfo> transitivePRs = pkgColItem.PackageReferences.OfType <ITransitivePackageReferenceContextInfo>();
ITransitivePackageReferenceContextInfo transitivePR = transitivePRs.OrderByDescending(x => x.Identity.Version).FirstOrDefault();
IReadOnlyCollection <PackageIdentity> transitiveOrigins = transitivePR?.TransitiveOrigins?.Select(to => to.Identity).ToArray() ?? Array.Empty <PackageIdentity>();
if (transitiveOrigins.Any())
{
// Get only local metadata. We don't want Deprecation and Vulnerabilities Metadata on Transitive packages
IPackageSearchMetadata packageMetadata = await _metadataProvider.GetOnlyLocalPackageMetadataAsync(pkgColItem, cancellationToken);
if (packageMetadata == null) // Edge case: local metadata not found
{
packageMetadata = PackageSearchMetadataBuilder.FromIdentity(pkgColItem).Build(); // create metadata object only with ID
}
return(new TransitivePackageSearchMetadata(packageMetadata, transitiveOrigins));
}
}
return(await base.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken));
}
private PackageLicenseInfo GeneratePackageLicenseInfo(IPackageSearchMetadata metadata)
{
return(new PackageLicenseInfo(
metadata.Identity.Id,
PackageLicenseUtilities.GenerateLicenseLinks(metadata),
metadata.Authors));
}
public void CanDownloadNewestVersion()
{
Version actualNewestVersion;
string message;
List <IPackageSearchMetadata> availablePackages = new List <IPackageSearchMetadata>()
{
this.GeneratePackageSeachMetadata(new Version(CurrentVersion)),
this.GeneratePackageSeachMetadata(new Version(NewerVersion)),
};
string testDownloadPath = Path.Combine(this.downloadDirectoryPath, "testNuget.zip");
IPackageSearchMetadata newestAvailableVersion = availablePackages.Last();
this.mockNuGetFeed.Setup(foo => foo.QueryFeedAsync(NuGetFeedName)).ReturnsAsync(availablePackages);
this.mockNuGetFeed.Setup(foo => foo.DownloadPackageAsync(It.Is <PackageIdentity>(packageIdentity => packageIdentity == newestAvailableVersion.Identity))).ReturnsAsync(testDownloadPath);
this.mockNuGetFeed.Setup(foo => foo.VerifyPackage(It.IsAny <string>())).Returns(true);
bool success = this.upgrader.TryQueryNewestVersion(out actualNewestVersion, out message);
// Assert that no new version was returned
success.ShouldBeTrue($"Expecting TryQueryNewestVersion to have completed sucessfully. Error: {message}");
actualNewestVersion.ShouldEqual(newestAvailableVersion.Identity.Version.Version, "Actual new version does not match expected new version.");
bool downloadSuccessful = this.upgrader.TryDownloadNewestVersion(out message);
downloadSuccessful.ShouldBeTrue();
this.upgrader.DownloadedPackagePath.ShouldEqual(testDownloadPath);
this.mockNuGetFeed.Verify(nuGetFeed => nuGetFeed.VerifyPackage(It.IsAny <string>()), Times.Once());
}
public void DownloadFailsOnNuGetPackageVerificationFailure()
{
Version actualNewestVersion;
string message;
List <IPackageSearchMetadata> availablePackages = new List <IPackageSearchMetadata>()
{
this.GeneratePackageSeachMetadata(new Version(CurrentVersion)),
this.GeneratePackageSeachMetadata(new Version(NewerVersion)),
};
IPackageSearchMetadata newestAvailableVersion = availablePackages.Last();
string testDownloadPath = Path.Combine(this.downloadDirectoryPath, "testNuget.zip");
this.mockNuGetFeed.Setup(foo => foo.QueryFeedAsync(NuGetFeedName)).ReturnsAsync(availablePackages);
this.mockNuGetFeed.Setup(foo => foo.DownloadPackageAsync(It.Is <PackageIdentity>(packageIdentity => packageIdentity == newestAvailableVersion.Identity)))
.Callback(new DownloadPackageAsyncCallback(
(packageIdentity) => this.mockFileSystem.WriteAllText(testDownloadPath, "Package contents that will fail validation")))
.ReturnsAsync(testDownloadPath);
this.mockNuGetFeed.Setup(foo => foo.VerifyPackage(It.IsAny <string>())).Returns(false);
bool success = this.upgrader.TryQueryNewestVersion(out actualNewestVersion, out message);
success.ShouldBeTrue($"Expecting TryQueryNewestVersion to have completed sucessfully. Error: {message}");
actualNewestVersion.ShouldEqual(newestAvailableVersion.Identity.Version.Version, "Actual new version does not match expected new version.");
bool downloadSuccessful = this.upgrader.TryDownloadNewestVersion(out message);
this.mockNuGetFeed.Verify(nuGetFeed => nuGetFeed.VerifyPackage(this.upgrader.DownloadedPackagePath), Times.Once());
downloadSuccessful.ShouldBeFalse("Failure to verify NuGet package should cause download to fail.");
this.mockFileSystem.FileExists(testDownloadPath).ShouldBeFalse("VerifyPackage should delete invalid packages");
}
private IReadOnlyList <DependencyGroupItem> GetDependencies(IPackageSearchMetadata package)
{
var groupItems = new List <DependencyGroupItem>();
foreach (var set in package.DependencySets)
{
var item = new DependencyGroupItem
{
TargetFramework = set.TargetFramework.Framework,
Dependencies = new List <DependencyItem>()
};
foreach (var dependency in set.Packages)
{
item.Dependencies.Add(new DependencyItem
{
Id = dependency.Id,
Range = dependency.VersionRange.ToNormalizedString(),
});
}
groupItems.Add(item);
}
return(groupItems);
}
/// <summary>
/// Finds all of the dependencies of a given package, including dependencies not available in the target repository.
/// </summary>
/// <param name="packageSearchMetadata">The package for which to obtain the dependencies for.</param>
/// <param name="includeUnlisted">Include unlisted packages.</param>
/// <param name="dependenciesAccumulator">A set which will contain all packages that are dependencies of the current package.</param>
/// <param name="packagesNotFoundAccumulator">A set which will contain all dependencies of the package that were not found in the NuGet feed.</param>
/// <param name="includePrerelease">Include pre-release packages.</param>
/// <param name="token">A cancellation token to allow cancellation of the task.</param>
private async Task FindDependenciesRecursiveAsync(IPackageSearchMetadata packageSearchMetadata, bool includePrerelease, bool includeUnlisted, HashSet <IPackageSearchMetadata> dependenciesAccumulator, HashSet <string> packagesNotFoundAccumulator, CancellationToken token = default)
{
// Check if package metadata resolved or has dependencies.
if (packageSearchMetadata?.DependencySets == null)
{
return;
}
// Go over all agnostic dependency sets.
foreach (var dependencySet in packageSearchMetadata.DependencySets)
{
foreach (var package in dependencySet.Packages)
{
var metadata = (await GetPackageDetails(package.Id, includePrerelease, includeUnlisted, token)).ToArray();
if (metadata.Any())
{
var lastVersion = Nuget.GetNewestVersion(metadata);
if (dependenciesAccumulator.Contains(lastVersion))
{
continue;
}
dependenciesAccumulator.Add(lastVersion);
await FindDependenciesRecursiveAsync(lastVersion, includePrerelease, includeUnlisted, dependenciesAccumulator, packagesNotFoundAccumulator, token);
}
else
{
packagesNotFoundAccumulator.Add(package.Id);
}
}
}
}
public async ValueTask <IReadOnlyCollection <VersionInfoContextInfo> > GetPackageVersionsAsync(
PackageIdentity identity,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
bool includePrerelease,
CancellationToken cancellationToken)
{
Assumes.NotNull(identity);
Assumes.NotNullOrEmpty(packageSources);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(identity.Id, includePrerelease, packageSources);
PackageSearchMetadataCacheItem?backgroundDataCache = PackageSearchMetadataMemoryCache.Get(cacheId) as PackageSearchMetadataCacheItem;
if (backgroundDataCache != null)
{
return(await backgroundDataCache.AllVersionsContextInfo);
}
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IPackageSearchMetadata packageMetadata = await packageMetadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
// Update the cache
var cacheEntry = new PackageSearchMetadataCacheItem(packageMetadata, packageMetadataProvider);
cacheEntry.UpdateSearchMetadata(packageMetadata);
PackageSearchMetadataMemoryCache.AddOrGetExisting(cacheId, cacheEntry, CacheItemPolicy);
return(await cacheEntry.AllVersionsContextInfo);
}
private Package ToPackage(IPackageSearchMetadata package)
{
return(new Package
{
Id = package.Identity.Id,
Version = package.Identity.Version,
Authors = ParseAuthors(package.Authors),
Description = package.Description,
Downloads = 0,
HasReadme = false,
Language = null,
Listed = package.IsListed,
MinClientVersion = null,
Published = package.Published?.UtcDateTime ?? DateTime.MinValue,
RequireLicenseAcceptance = package.RequireLicenseAcceptance,
Summary = package.Summary,
Title = package.Title,
IconUrl = package.IconUrl,
LicenseUrl = package.LicenseUrl,
ProjectUrl = package.ProjectUrl,
PackageTypes = new List <PackageType>(),
RepositoryUrl = null,
RepositoryType = null,
Tags = package.Tags?.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries),
Dependencies = ToDependencies(package)
});
}
private List <PackageDependency> ToDependencies(IPackageSearchMetadata package)
{
return(package
.DependencySets
.SelectMany(ToDependencies)
.ToList());
}
public async Task <IReadOnlyList <IPackage> > GetListAsync(int resultCount, IPackageSearchMetadata package, SourceRepository repository, Func <IPackageSearchMetadata, IPackageSearchMetadata, bool> versionFilter = null, bool isPrereleaseIncluded = false, CancellationToken cancellationToken = default)
{
if (versionFilter == null)
{
versionFilter = (source, target) => true;
}
try
{
List <IPackage> result = new List <IPackage>();
if (await SearchOlderVersionsDirectly(result, resultCount, package, repository, versionFilter))
{
return(result);
}
if (await SearchOlderVersionsUsingMetadataResource(result, resultCount, package, repository, versionFilter, isPrereleaseIncluded, cancellationToken))
{
return(result);
}
return(new List <IPackage>());
}
catch (FatalProtocolException e) when(e.InnerException is TaskCanceledException)
{
cancellationToken.ThrowIfCancellationRequested();
throw e;
}
}
/// <summary>
/// Get the view of PowerShellPackage. Used for Get-Package -Updates command.
/// </summary>
internal static PowerShellUpdatePackage GetPowerShellPackageUpdateView(IPackageSearchMetadata data, NuGetVersion version, VersionType versionType, NuGetProject project)
{
var package = new PowerShellUpdatePackage()
{
Id = data.Identity.Id,
Description = data.Summary,
ProjectName = project.GetMetadata <string> (NuGetProjectMetadataKeys.Name),
AsyncLazyVersions = new AsyncLazy <IEnumerable <NuGetVersion> > (async delegate {
var versions = (await data.GetVersionsAsync()) ?? Enumerable.Empty <VersionInfo> ();
var results = versions.Select(v => v.Version).OrderByDescending(v => v)
.Where(r => r > version)
.ToArray();
return(results);
}),
LicenseUrl = data.LicenseUrl?.AbsoluteUri
};
switch (versionType)
{
case VersionType.Updates:
package.AllVersions = true;
break;
case VersionType.Latest:
package.AllVersions = false;
break;
default:
Debug.Fail("Unexpected version type passed.");
break;
}
return(package);
}
private static Dependency[] ParseMetadataDependencies(IPackageSearchMetadata pkg)
{
List <Dependency> dependencies = new List <Dependency>();
foreach (var pkgDependencyGroup in pkg.DependencySets)
{
foreach (var pkgDependencyItem in pkgDependencyGroup.Packages)
{
// check if version range is not null. In case we have package with dependency but no version specified
VersionRange depVersionRange;
if (pkgDependencyItem.VersionRange == null)
{
depVersionRange = VersionRange.All;
}
else
{
depVersionRange = pkgDependencyItem.VersionRange;
}
dependencies.Add(
new Dependency(pkgDependencyItem.Id, depVersionRange));
}
}
return(dependencies.ToArray());
}
private static async Task <string?> InitNuGetReleaseNotes(IPackageSearchMetadata packageSearchMetadata,
INugetRepository repository)
{
var reader = await repository.DownloadNuspecReaderAsync(packageSearchMetadata.Identity);
return(reader?.GetReleaseNotes());
}
public override bool TryQueryNewestVersion(out Version newVersion, out string message)
{
try
{
if (!this.EnsureNuGetFeedInitialized(out message))
{
newVersion = null;
return(false);
}
IList <IPackageSearchMetadata> queryResults = this.QueryFeed(firstAttempt: true);
// Find the package with the highest version
IPackageSearchMetadata highestVersionAvailable = null;
foreach (IPackageSearchMetadata result in queryResults)
{
if (highestVersionAvailable == null || result.Identity.Version > highestVersionAvailable.Identity.Version)
{
highestVersionAvailable = result;
}
}
if (highestVersionAvailable != null &&
highestVersionAvailable.Identity.Version.Version > this.installedVersion)
{
this.highestVersionAvailable = highestVersionAvailable;
}
newVersion = this.highestVersionAvailable?.Identity?.Version?.Version;
if (newVersion != null)
{
this.tracer.RelatedInfo($"{nameof(this.TryQueryNewestVersion)} - new version available: installedVersion: {this.installedVersion}, highestVersionAvailable: {newVersion}");
message = $"New version {highestVersionAvailable.Identity.Version} is available.";
return(true);
}
else if (highestVersionAvailable != null)
{
this.tracer.RelatedInfo($"{nameof(this.TryQueryNewestVersion)} - up-to-date");
message = $"highest version available is {highestVersionAvailable.Identity.Version}, you are up-to-date";
return(true);
}
else
{
this.tracer.RelatedInfo($"{nameof(this.TryQueryNewestVersion)} - no versions available from feed.");
message = $"No versions available via feed.";
}
}
catch (Exception ex)
{
this.TraceException(
ex,
nameof(this.TryQueryNewestVersion),
"Exception encountered querying for newest version of upgrade package.");
message = ex.Message;
newVersion = null;
}
return(false);
}
public async ValueTask <IReadOnlyCollection <VersionInfoContextInfo> > GetPackageVersionsAsync(
PackageIdentity identity,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
bool includePrerelease,
CancellationToken cancellationToken)
{
Assumes.NotNull(identity);
Assumes.NotNullOrEmpty(packageSources);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(identity.Id, includePrerelease, packageSources);
PackageSearchMetadataCacheItem?backgroundDataCache = PackageSearchMetadataMemoryCache.Get(cacheId) as PackageSearchMetadataCacheItem;
if (backgroundDataCache != null)
{
return(await backgroundDataCache.AllVersionsContextInfo);
}
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IPackageSearchMetadata packageMetadata = await packageMetadataProvider.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken);
IEnumerable <VersionInfo> versions = await packageMetadata.GetVersionsAsync();
return(await Task.WhenAll(versions.Select(v => VersionInfoContextInfo.CreateAsync(v).AsTask())));
}
public NuGetPackage(IPackageSearchMetadata packageMetadata, MetadataOrigin fromPage)
{
FromPage = fromPage;
_packageMetadata = packageMetadata;
Title = packageMetadata.Title;
Description = packageMetadata.Description;
IconUrl = packageMetadata.IconUrl;
Authors = packageMetadata.Authors;
DownloadCount = (int?)packageMetadata.DownloadCount;
Summary = packageMetadata.Summary;
LastVersion = packageMetadata.Identity.Version;
ValidationContext = new ValidationContext();
switch (fromPage)
{
case MetadataOrigin.Browse:
InstalledVersion = null;
break;
case MetadataOrigin.Installed:
InstalledVersion = LastVersion;
break;
case MetadataOrigin.Updates when packageMetadata is UpdatePackageSearchMetadata updatePackageSearchMetadata:
InstalledVersion = updatePackageSearchMetadata.FromVersion.Version;
Status = PackageStatus.UpdateAvailable;
break;
}
}
public NugetPackageDto(IPackageSearchMetadata metadata)
{
IconUrl = metadata.IconUrl ?? new Uri("https://git.io/fAlfh");
Description = metadata.Description;
ProjectUrl = metadata.ProjectUrl;
Title = metadata.Title;
}
public void QueryNewestVersionReacquiresCredentialsOnAuthFailure(Exception exception)
{
Version actualNewestVersion;
string message;
List <IPackageSearchMetadata> availablePackages = new List <IPackageSearchMetadata>()
{
this.GeneratePackageSeachMetadata(new Version(CurrentVersion)),
this.GeneratePackageSeachMetadata(new Version(NewerVersion)),
};
string testDownloadPath = Path.Combine(this.downloadDirectoryPath, "testNuget.zip");
IPackageSearchMetadata newestAvailableVersion = availablePackages.Last();
this.mockNuGetFeed.SetupSequence(foo => foo.QueryFeedAsync(It.IsAny <string>()))
.Throws(exception)
.ReturnsAsync(availablePackages);
// Setup the credential manager
string emptyString = string.Empty;
this.mockCredentialManager.Setup(foo => foo.TryDeleteCredential(It.IsAny <ITracer>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), out emptyString)).Returns(true);
bool success = this.upgrader.TryQueryNewestVersion(out actualNewestVersion, out message);
// Verify expectations
success.ShouldBeTrue($"Expecting TryQueryNewestVersion to have completed sucessfully. Error: {message}");
actualNewestVersion.ShouldEqual(newestAvailableVersion.Identity.Version.Version, "Actual new version does not match expected new version.");
this.mockNuGetFeed.Verify(nuGetFeed => nuGetFeed.QueryFeedAsync(It.IsAny <string>()), Times.Exactly(2));
string outString = string.Empty;
this.mockCredentialManager.Verify(credentialManager => credentialManager.TryGetCredential(It.IsAny <ITracer>(), It.IsAny <string>(), out outString, out outString, out outString), Times.Exactly(2));
this.mockCredentialManager.Verify(credentialManager => credentialManager.TryDeleteCredential(It.IsAny <ITracer>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), out outString), Times.Exactly(1));
}
public static IPackageSearchMetadata WithVersions(this IPackageSearchMetadata metadata, IEnumerable <VersionInfo> versions)
{
return(PackageSearchMetadataBuilder
.FromMetadata(metadata)
.WithVersions(AsyncLazy.New(versions))
.Build());
}
public NuGetPackageLicense (IPackageSearchMetadata metadata)
{
PackageIdentity = metadata.Identity;
PackageId = metadata.Identity.Id;
PackageTitle = metadata.Title;
PackageAuthor = metadata.Authors;
LicenseUrl = metadata.LicenseUrl;
}
static bool IsMatch (IPackageSearchMetadata package, string packageId, bool includePrerelease)
{
if (package.Identity.Id == packageId) {
if (package.Identity.Version.IsPrerelease) {
return includePrerelease;
}
return true;
}
return false;
}
public DetailedPackageMetadata(IPackageSearchMetadata serverData, long? downloadCount)
{
Version = serverData.Identity.Version;
Summary = serverData.Summary;
Description = serverData.Description;
Authors = serverData.Authors;
Owners = serverData.Owners;
IconUrl = serverData.IconUrl;
LicenseUrl = serverData.LicenseUrl;
ProjectUrl = serverData.ProjectUrl;
ReportAbuseUrl = serverData.ReportAbuseUrl;
Tags = serverData.Tags;
DownloadCount = downloadCount;
Published = serverData.Published;
DependencySets = serverData.DependencySets?
.Select(e => new PackageDependencySetMetadata(e))
?? new PackageDependencySetMetadata[] { };
HasDependencies = DependencySets.Any(
dependencySet => dependencySet.Dependencies != null && dependencySet.Dependencies.Count > 0);
}
bool IsPackageVersionAllowed (IPackageSearchMetadata package, PackageReference packageReference)
{
if (!packageReference.HasAllowedVersions)
return true;
return packageReference.AllowedVersions.Satisfies (package.Identity.Version);
}
public PackageData(IPackageSearchMetadata package)
{
_package = package;
Id = package.Identity.Id;
Version = package.Identity.Version;
}
