public async Task GetPackageMetaDataAsync(string packagename)
{
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
PackageMetadataResource resource = await repository.GetResourceAsync <PackageMetadataResource>();
packageMetaData = await resource.GetMetadataAsync(
packagename,
includePrerelease : true,
includeUnlisted : false,
cache,
logger,
cancellationToken);
foreach (IPackageSearchMetadata package in packageMetaData)
{
Console.WriteLine($"Version: {package.Identity.Version}");
Console.WriteLine($"Listed: {package.IsListed}");
Console.WriteLine($"Tags: {package.Tags}");
Console.WriteLine($"Description: {package.Description}");
}
}
public static async Task GetPackageMetadataAsync()
{
// This code region is referenced by the NuGet docs. Please update the docs if you rename the region
// or move it to a different file.
#region GetPackageMetadata
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
PackageMetadataResource resource = await repository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> packages = await resource.GetMetadataAsync(
"Newtonsoft.Json",
includePrerelease : true,
includeUnlisted : false,
cache,
logger,
cancellationToken);
foreach (IPackageSearchMetadata package in packages)
{
Console.WriteLine($"Version: {package.Identity.Version}");
Console.WriteLine($"Listed: {package.IsListed}");
Console.WriteLine($"Tags: {package.Tags}");
Console.WriteLine($"Description: {package.Description}");
}
#endregion
}
private static HashSet <PackageId> getDependencies(PackageId pkg)
{
HashSet <PackageId> results = new HashSet <PackageId>();
Logger logger = new Logger();
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
//providers.AddRange(Repository.Provider.GetCoreV2()); // Add v2 API support
PackageSource packageSource = new PackageSource("https://api.nuget.org/v3/index.json");
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = sourceRepository.GetResource <PackageMetadataResource>();
var task = packageMetadataResource.GetMetadataAsync(pkg.Id, true, true, logger, CancellationToken.None);
task.Wait();
IEnumerable <IPackageSearchMetadata> searchMetadata = task.Result;
foreach (IPackageSearchMetadata metadata in searchMetadata)
{
if (pkg.Version == metadata.Identity.Version)
{
foreach (PackageDependencyGroup deps in metadata.DependencySets)
{
foreach (var dep in deps.Packages)
{
results.Add(new PackageId(dep.Id, dep.VersionRange.MinVersion.ToNormalizedString()));
}
}
break;
}
}
return(results);
}
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);
}
GetPackageMetadataAsync
(
string nuget_id
)
{
PackageMetadataResource resource = await repository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> packages = await resource.GetMetadataAsync
(
nuget_id,
includePrerelease : true,
includeUnlisted : false,
source_cache,
logger,
cancellationToken
);
foreach (IPackageSearchMetadata package in packages)
{
Console.WriteLine($"Version: {package.Identity.Version}");
Console.WriteLine($"Listed: {package.IsListed}");
Console.WriteLine($"Tags: {package.Tags}");
Console.WriteLine($"Description: {package.Description}");
}
return(packages);
}
public async Task <(IPackageSearchMetadata, bool, bool)> GetMetadataAsync(string packageId, string packageVersion)
{
// Ensure initialized
if (_autocompleteResource == null || _packageMetadataResource == null)
{
(_autocompleteResource, _packageMetadataResource) = await InitializeResources();
}
var packagesMetadata = (await _packageMetadataResource.GetMetadataAsync(
packageId, true, false, CacheContext, Logger, CancellationToken.None)).ToList();
var version = NuGetVersion.Parse(packageVersion);
var packageMetadata = packagesMetadata.FirstOrDefault(md => md.Identity.Version == version);
if (packageMetadata == null)
{
return(null, false, false);
}
var isLastPreRelease = packageMetadata.Identity.Version.IsPrerelease && packagesMetadata
.Where(v => v.Identity.Version.IsPrerelease)
.OrderByDescending(v => v.Identity.Version)
.First().Identity.Version == packageMetadata.Identity.Version;
var isLastRelease = !packageMetadata.Identity.Version.IsPrerelease && packagesMetadata
.Where(v => !v.Identity.Version.IsPrerelease)
.OrderByDescending(v => v.Identity.Version)
.First().Identity.Version == packageMetadata.Identity.Version;
return(packageMetadata, isLastPreRelease, isLastRelease);
}
public async Task <IPackageSearchMetadata> GetAsync(string id, NuGetVersion version)
{
PackageMetadataResource packageMetadataResource = await GetPackageMetadataResource();
var searchMetadata = await packageMetadataResource.GetMetadataAsync(id, true, true, _nugetLogger, CancellationToken.None);
return(searchMetadata.FirstOrDefault(p => p.Identity.Version == version));;
}
private async Task <Type> RetrieveTypeAsync()
{
bool isBetaPackage = _nugetPackageName.EndsWith(_betaSuffix);
(string searchName, bool isSpecificVersion) = GetSearchablePackageName(_nugetPackageName, isBetaPackage);
IEnumerable <IPackageSearchMetadata> searchMetadata = await _packageMetadataResource.GetMetadataAsync(
searchName,
isBetaPackage,
false,
_nugetLogger,
CancellationToken.None);
if (!searchMetadata.Any())
{
throw new InvalidOperationException($"Package {_nugetPackageName} not found");
}
var packageInfo = searchMetadata
.Cast <PackageSearchMetadata>()
.OrderByDescending(p => p.Version)
.First(i => !isSpecificVersion || i.Identity.ToString() == _nugetPackageName);
var downloadResult = await _downloadResource.GetDownloadResourceResultAsync(
packageInfo.Identity,
_packageDownloadContext,
null,
_nugetLogger,
CancellationToken.None);
if (downloadResult.Status != DownloadResourceResultStatus.Available)
{
throw new InvalidOperationException($"Nuget package {_nugetPackageName} of version {packageInfo.Version} is not available for download");
}
var pathResolver = new PackagePathResolver(_downloadDirectory);
var extractContext = new PackageExtractionContext(_nugetLogger);
var extractedFiles = PackageExtractor.ExtractPackage(downloadResult.PackageStream, pathResolver, extractContext, CancellationToken.None);
var dllFiles = extractedFiles.Where(f => Path.GetExtension(f).ToLower() == _dllExtension);
if (!dllFiles.Any())
{
throw new InvalidOperationException($"Dll files not found in {_packageDownloadContext.DirectDownloadDirectory}");
}
var assembly = Assembly.LoadFile(dllFiles.First());
var type = assembly.GetType(_processingTypeName);
if (type == null)
{
throw new InvalidOperationException($"Type {_processingTypeName} not found among {assembly.ExportedTypes.Select(t => t.FullName).ToList().ToJson()}");
}
return(type);
}
private async Task GeneratePackage(
FindPackageByIdDependencyInfo info,
IImmutableList <NuGetFramework> allowedFrameworks,
CancellationToken cancellationToken,
string tab = "")
{
var key = info.PackageIdentity.Id + "@" + info.PackageIdentity.Version;
_logger.LogTrace(tab + key);
var metadata = await _metadataResource.GetMetadataAsync(
info.PackageIdentity, _cacheContext, _nugetLogger, cancellationToken);
var packageJson = new PackageJson
{
name = _nameMapper.Map(info.PackageIdentity.Id),
author = metadata.Authors,
homepage = metadata.ProjectUrl.ToString(),
description = metadata.Description,
displayName = info.PackageIdentity.Id,
version = info.PackageIdentity.Version.ToString(),
keywords = metadata.Tags?.Split(",") ?? Array.Empty <string>()
};
var dependencyGroup =
info.DependencyGroups.FirstOrDefault(
g => allowedFrameworks.FirstOrDefault(f => f == g.TargetFramework) != null);
var dependencies =
dependencyGroup is not null
? dependencyGroup.Packages
.Where(x => !_filter.IsExcluded(x))
.ToArray()
: Enumerable.Empty <PackageDependency>();
FillPackageDependencies(packageJson, dependencies);
var packageDirectory = GetPackageDirectory(info.PackageIdentity);
var placeholderDirectory = GetPlaceholderDirectory(info.PackageIdentity);
if (await CreatePackageAtDir(packageDirectory, packageJson))
{
await LoadPackage(
packageDirectory,
info, dependencyGroup.TargetFramework, cancellationToken);
}
if (_configuration.GetValue <bool>(_GeneratePlaceholders))
{
await CreatePackageAtDir(placeholderDirectory, packageJson);
}
if (_configuration.GetValue <bool>(_Recursive))
{
await TraverseDependencies(allowedFrameworks, tab, dependencies, cancellationToken);
}
}
public async Task <IEnumerable <IPackageSearchMetadata> > GetPackagesMetaDataAsync()
{
_logger.DEBUG($"started searching for packages metadata from the providers, using V3 and V2 protocols");
var sourceRepository = GetSourceRepository();
PackageMetadataResource packageMetadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>();
return(await packageMetadataResource.GetMetadataAsync(_configuration.packageID, true, true, null, CancellationToken.None));
}
private async Task <IEnumerable <IPackageSearchMetadata> > FindPackage(
PackageMetadataResource metadataResource, string packageName, bool includePrerelease)
{
using (var cacheContext = new SourceCacheContext())
{
return(await metadataResource
.GetMetadataAsync(packageName, includePrerelease, false,
cacheContext, _nuGetLogger, CancellationToken.None));
}
}
private List <IPackageSearchMetadata> FindDependenciesFromSource(IPackageSearchMetadata pkg, PackageMetadataResource pkgMetadataResource, SourceCacheContext srcContext)
{
/// dependency resolver
///
/// this function will be recursively called
///
/// call the findpackages from source helper (potentially generalize this so it's finding packages from source or cache)
///
List <IPackageSearchMetadata> foundDependencies = new List <IPackageSearchMetadata>();
// 1) check the dependencies of this pkg
// 2) for each dependency group, search for the appropriate name and version
// a dependency group are all the dependencies for a particular framework
foreach (var dependencyGroup in pkg.DependencySets)
{
//dependencyGroup.TargetFramework
//dependencyGroup.
foreach (var pkgDependency in dependencyGroup.Packages)
{
// 2.1) check that the appropriate pkg dependencies exist
// returns all versions from a single package id.
var dependencies = pkgMetadataResource.GetMetadataAsync(pkgDependency.Id, _prerelease, true, srcContext, NullLogger.Instance, cancellationToken).GetAwaiter().GetResult();
// then 2.2) check if the appropriate verion range exists (if version exists, then add it to the list to return)
VersionRange versionRange = null;
try
{
versionRange = VersionRange.Parse(pkgDependency.VersionRange.OriginalString);
}
catch
{
Console.WriteLine("Error parsing version range");
}
// if no version/version range is specified the we just return the latest version
IPackageSearchMetadata depPkgToReturn = (versionRange == null ?
dependencies.FirstOrDefault() :
dependencies.Where(v => versionRange.Satisfies(v.Identity.Version)).FirstOrDefault());
foundDependencies.Add(depPkgToReturn);
// 3) search for any dependencies the pkg has
foundDependencies.AddRange(FindDependenciesFromSource(depPkgToReturn, pkgMetadataResource, srcContext));
}
}
// flatten after returning
return(foundDependencies);
}
private async Task PopulateDependencies(Dependency dependency)
{
var dependencies = new List <Dependency>();
NuGetVersion.TryParse(dependency.Version, out var version);
var package = new PackageIdentity(dependency.Name, version);
var framework = String.IsNullOrEmpty(dependency.Framework)
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(dependency.Framework, new DefaultFrameworkNameProvider());
var dependencyInfo = await _dependencyResolver.ResolvePackage(package, framework, _cacheContext, _logger, _cancellationToken);
if (dependencyInfo == null)
{
_logger.LogWarning($"Package not available in source(s): {dependency.Name} {dependency.Version}. Required by {dependency.Project}");
return;
}
dependency.FoundInSources = true;
if (dependencyInfo?.Dependencies == null)
{
return;
}
foreach (var info in dependencyInfo.Dependencies)
{
var searchResults = await _metadataProvider.GetMetadataAsync(info.Id, includePrerelease : INCLUDE_PRERELEASE, includeUnlisted : false, sourceCacheContext : _cacheContext, _logger, _cancellationToken);
var metadata = searchResults.OrderBy(s => s.Identity.Version).LastOrDefault(r => info.VersionRange.Satisfies(r.Identity.Version));
if (metadata == null)
{
_logger.LogWarning($"Package not available in source(s): {info.Id} {info.VersionRange}. Required by {dependency.Name} from {dependency.Project}");
continue;
}
var subpackage = await _dependencyResolver.ResolvePackage(metadata.Identity, framework, _cacheContext, _logger, _cancellationToken);
var childDependency = new Dependency
{
Framework = dependency.Framework,
Name = subpackage.Id,
Version = subpackage.Version?.Version?.ToString(),
Project = dependency.Project,
VersionLimited = info.VersionRange.MaxVersion == null ? null : $"{info.VersionRange.MaxVersion.Version.ToString()} by {dependency.Name} ({dependency.Version})"
};
dependencies.Add(childDependency);
await PopulateDependencies(childDependency);
}
dependency.Dependencies = dependencies;
}
/// <summary>
/// Query a NuGet feed for list of packages that match the packageId.
/// </summary>
/// <param name="packageId"></param>
/// <returns>List of packages that match query parameters</returns>
public virtual async Task <IList <IPackageSearchMetadata> > QueryFeedAsync(string packageId)
{
PackageMetadataResource packageMetadataResource = await this.sourceRepository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> queryResults = await packageMetadataResource.GetMetadataAsync(
packageId,
includePrerelease : false,
includeUnlisted : false,
sourceCacheContext : this.sourceCacheContext,
log : this.nuGetLogger,
token : CancellationToken.None);
return(queryResults.ToList());
}
private static async Task <IEnumerable <IPackageSearchMetadata> > GetListedPackages(string packageID)
{
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
PackageSource packageSource = new PackageSource(NUGET_API_SERVICE_INDEX);
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> searchMetadata = await packageMetadataResource.GetMetadataAsync(packageID, true, true, logger, CancellationToken.None);
return(searchMetadata);
}
public static async Task <string?> FindNewestPackageVersion(string package, bool includePrerelease)
{
Logger logger = new Logger();
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
//providers.AddRange(Repository.Provider.GetCoreV2()); // Add v2 API support
PackageSource packageSource = new PackageSource("https://api.nuget.org/v3/index.json");
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> searchMetadata = await packageMetadataResource.GetMetadataAsync(package, true, true, logger, CancellationToken.None);
NuGetVersion?newest = null;
foreach (var item in searchMetadata)
{
if (item is PackageSearchMetadata itemMetadata)
{
var version = itemMetadata.Version;
if (!itemMetadata.IsListed)
{
continue;
}
if (version.IsPrerelease && !includePrerelease)
{
continue;
}
if (newest == null)
{
newest = version;
continue;
}
if (version.CompareTo(newest.Version) > 0)
{
newest = version;
}
}
}
if (newest == null)
{
return(null);
}
return(newest.ToNormalizedString());
}
private static async Task <IEnumerable <Tuple <string, NuGetVersion, NuGetVersion> > > GetUpdates(Dictionary <string, NuGetVersion> packages, PackageMetadataResource resource, ILogger logger)
{
var result = new List <Tuple <string, NuGetVersion, NuGetVersion> >();
foreach (var item in packages)
{
Console.WriteLine("Checking update for: {0} ({1})", item.Key, item.Value);
var packageMetadataList = await resource.GetMetadataAsync(item.Key, false, false, logger, CancellationToken.None);
var packageMetadata = packageMetadataList.OrderByDescending(p => p.Identity.Version).First();
if (packageMetadata.Identity.Version > item.Value)
{
result.Add(Tuple.Create(packageMetadata.Identity.Id, item.Value, packageMetadata.Identity.Version));
}
}
return(result);
}
public static async Task <List <IPackageSearchMetadata> > GetPackageMetadata(string packageId, string source, bool includePrerelease)
{
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3(source);
PackageMetadataResource resource = await repository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> packages = await resource.GetMetadataAsync(
packageId,
includePrerelease : includePrerelease,
includeUnlisted : true,
cache,
logger,
cancellationToken);
return(packages.ToList());
}
/// <summary>
/// Return the latest version of the source
/// </summary>
/// <param name="source">Source to look at</param>
/// <param name="logger">Logger</param>
/// <param name="packageId">Package to look for</param>
/// <param name="prerelease">Whether to include prerelease versions</param>
/// <returns>Returns the latest version available from a source or a null if non is found.</returns>
public static async Task <NuGetVersion> GetLatestVersionFromSourceAsync(PackageSource source, ILogger logger, string packageId, bool prerelease)
{
SourceRepository repository = Repository.Factory.GetCoreV3(source);
PackageMetadataResource resource = await repository.GetResourceAsync <PackageMetadataResource>();
using (var cache = new SourceCacheContext())
{
IEnumerable <IPackageSearchMetadata> packages = await resource.GetMetadataAsync(
packageId,
includePrerelease : prerelease,
includeUnlisted : false,
cache,
logger,
CancellationToken.None
);
return(packages?.Max(x => x.Identity.Version));
}
}
public IPackageSearchMetadata GetPackageFromRepoWithoutVersion(string packageName, PackageMetadataResource packageMetadataResource, SourceCacheContext sourceCacheContext, SourceRepository sourceRepository)
{
IPackageSearchMetadata rootPackage = null;
var exacactsearchMetadata = packageMetadataResource.GetMetadataAsync(packageName, true, true, sourceCacheContext, Logger, CancellationToken.None)
.Result;
if (exacactsearchMetadata.Count() == 0)
{
Logger.LogDebug("GetPackageFromRepoWithoutVersion - No Package & any version found in Repo " + $"{sourceRepository.PackageSource.Source} for package : {packageName}");
}
else //select latest version
{
rootPackage = exacactsearchMetadata.OrderByDescending(x => x.Identity.Version)
.FirstOrDefault();
}
return(rootPackage);
}
public async Task GetPackageInfo(string packageId, string packageVersion)
{
PackageMetadataResource packageMetadataResource = await _repository.GetResourceAsync <PackageMetadataResource>();
PackageIdentity id = new PackageIdentity(packageId, new NuGetVersion(packageVersion));
IPackageSearchMetadata data = await packageMetadataResource.GetMetadataAsync(id, _logger, CancellationToken.None);
Console.WriteLine("{0} {1}", data.Identity.Id, data.Identity.Version);
IEnumerable <PackageDependencyGroup> dependencyGroups = data.DependencySets;
foreach (var group in dependencyGroups)
{
Console.WriteLine(" {0}:", group.TargetFramework);
foreach (PackageDependency package in group.Packages)
{
Console.WriteLine(" {0} {1}", package.Id, package.VersionRange);
}
}
}
static async Task <string> GetLatestNugetVersion(string PackageName)
{
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
PackageMetadataResource resource = await repository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> packages = await resource.GetMetadataAsync(
PackageName,
includePrerelease : false,
includeUnlisted : false,
cache,
logger,
cancellationToken);
return(packages.Last().Identity.Version.ToString());
}
private static async Task GetDependencies(string packageId, NuGetVersion version, Dictionary <string, NuGetVersion> packages, PackageMetadataResource resource, ILogger logger, Dictionary <string, int> frameworks)
{
NuGetVersion existingVersion = null;
if (packages.TryGetValue(packageId, out existingVersion))
{
if (version > existingVersion)
{
packages[packageId] = version;
}
else
{
return;
}
}
Console.WriteLine("Exploring package: {0} ({1})", packageId, version);
var identity = new PackageIdentity(packageId, version);
var packageMetadata = await resource.GetMetadataAsync(identity, logger, CancellationToken.None);
if (packageMetadata != null)
{
packages[packageMetadata.Identity.Id] = packageMetadata.Identity.Version;
if (packageMetadata.DependencySets.Any())
{
var dependencySet = packageMetadata.DependencySets.Where(d => frameworks.ContainsKey(d.TargetFramework.Framework))
.OrderBy(d => frameworks[d.TargetFramework.Framework]).ThenByDescending(d => d.TargetFramework.Version).First();
foreach (var dependencyPackage in dependencySet.Packages)
{
await GetDependencies(dependencyPackage.Id, dependencyPackage.VersionRange.MinVersion, packages, resource, logger, frameworks);
}
}
}
else
{
Console.WriteLine("[WARN] Package {0} ({1}) not found.", packageId, version);
packages.Remove(packageId);
}
}
private async Task <bool> SearchOlderVersionsUsingMetadataResourceAsync(List <IPackage> result, int resultCount, IPackageSearchMetadata package, SourceRepository repository, Func <IPackageSearchMetadata, IPackageSearchMetadata, bool> versionFilter, bool isPrereleaseIncluded, CancellationToken cancellationToken)
{
PackageMetadataResource metadataResource = await repository.GetResourceAsync <PackageMetadataResource>(cancellationToken);
if (metadataResource == null)
{
return(false);
}
using (var sourceCacheContext = new SourceCacheContext())
{
IEnumerable <IPackageSearchMetadata> versions = await metadataResource?.GetMetadataAsync(
package.Identity.Id,
isPrereleaseIncluded,
false,
sourceCacheContext,
nuGetLog,
cancellationToken
);
versions = versions.OrderByDescending(p => p.Identity.Version, VersionComparer.Default);
foreach (IPackageSearchMetadata version in versions)
{
if (versionFilter(package, version))
{
IPackage item = await ProcessOlderVersionAsync(repository, version, cancellationToken);
if (item != null)
{
result.Add(item);
if (result.Count == resultCount)
{
return(true);
}
}
}
}
}
return(true);
}
public async Task <string> GetLatestVersionNumberFromNugetFeedAsync(NugetPackage package)
{
try
{
Logger logger = new Logger(); //Just a class implementing the Nuget.Common.ILogger interface
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
PackageSource packageSource = new PackageSource(package.Source.ToString());
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>();
var searchMetadata = await packageMetadataResource.GetMetadataAsync(package.Name, false, false, new SourceCacheContext(), logger, new CancellationToken());
var versionNumber = searchMetadata.FirstOrDefault().Identity.Version.OriginalVersion;
return(versionNumber);
}
catch (Exception ex)
{
return(null);
}
}
public async Task <IReadOnlyCollection <IInstalledPackage> > GetInstalledAsync(IEnumerable <IPackageSource> packageSources, CancellationToken cancellationToken)
{
log.Debug($"Getting list of installed packages from '{ConfigFilePath}'.");
List <IInstalledPackage> result = new List <IInstalledPackage>();
await ReadPackageConfig(
async (package, context) =>
{
foreach (IPackageSource packageSource in packageSources)
{
log.Debug($"Looking in repository '{packageSource.Uri}'.");
SourceRepository repository = repositoryFactory.Create(packageSource);
PackageMetadataResource metadataResource = await repository.GetResourceAsync <PackageMetadataResource>(cancellationToken);
if (metadataResource != null)
{
IPackageSearchMetadata metadata = await metadataResource.GetMetadataAsync(package.PackageIdentity, context, nuGetLog, cancellationToken);
if (metadata != null)
{
log.Debug($"Package '{package.PackageIdentity}' was found.");
NuGetPackageFilterResult filterResult = await packageFilter.FilterAsync(repository, metadata, cancellationToken);
result.Add(new NuGetInstalledPackage(
new NuGetPackage(metadata, repository, contentService, versionService),
filterResult == NuGetPackageFilterResult.Ok
));
break;
}
}
}
return(false);
},
cancellationToken
);
log.Debug($"Returning '{result.Count}' installed packages.");
return(result);
}
public static async Task UseNuGetProtocolWithAnAuthenticatedFeed()
{
// This code region is referenced by the NuGet docs. Please update the docs if you rename the region
// or move it to a different file.
#region AuthenticatedFeed
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
var sourceUri = "https://contoso.privatefeed/v3/index.json";
var packageSource = new PackageSource(sourceUri)
{
Credentials = new PackageSourceCredential(
source: sourceUri,
username: "******",
passwordText: "myVerySecretPassword",
isPasswordClearText: true,
validAuthenticationTypesText: null)
};
// If the `SourceRepository` is created with a `PackageSource`, the rest of APIs will consume the credentials attached to `PackageSource.Credentials`.
SourceRepository repository = Repository.Factory.GetCoreV3(packageSource);
PackageMetadataResource resource = await repository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> packages = await resource.GetMetadataAsync(
"MyPackage",
includePrerelease : true,
includeUnlisted : false,
cache,
logger,
cancellationToken);
foreach (IPackageSearchMetadata package in packages)
{
Console.WriteLine($"Version: {package.Identity.Version}");
Console.WriteLine($"Listed: {package.IsListed}");
Console.WriteLine($"Tags: {package.Tags}");
Console.WriteLine($"Description: {package.Description}");
}
#endregion
}
private static async Task <bool> TryUpdateVersionAsync(
XAttribute versionAttribute,
string packageId,
PackageMetadataResource packageMetadataResource,
ILogger logger,
SourceCacheContext cacheContext)
{
var searchMetadata = await packageMetadataResource.GetMetadataAsync(
packageId,
includePrerelease : false,
includeUnlisted : true, // Microsoft.AspNetCore.DataOrotection.Redis package is not listed.
sourceCacheContext : cacheContext,
log : logger,
token : CancellationToken.None);
var currentVersion = NuGetVersion.Parse(versionAttribute.Value);
var versionRange = new VersionRange(
currentVersion,
new FloatRange(NuGetVersionFloatBehavior.Patch, currentVersion));
var latestVersion = versionRange.FindBestMatch(
searchMetadata.Select(metadata => metadata.Identity.Version));
if (latestVersion == null)
{
logger.LogWarning($"Unable to find latest version of '{packageId}'.");
return(false);
}
var hasChanged = false;
if (latestVersion != currentVersion)
{
hasChanged = true;
versionAttribute.Value = latestVersion.ToNormalizedString();
}
return(hasChanged);
}
/// <summary>
/// Query a NuGet feed for list of packages that match the packageId.
/// </summary>
/// <param name="packageId"></param>
/// <returns>List of packages that match query parameters</returns>
public virtual async Task <IList <IPackageSearchMetadata> > QueryFeedAsync(string packageId)
{
try
{
PackageMetadataResource packageMetadataResource = await this.sourceRepository.GetResourceAsync <PackageMetadataResource>();
IEnumerable <IPackageSearchMetadata> queryResults = await packageMetadataResource.GetMetadataAsync(
packageId,
includePrerelease : false,
includeUnlisted : false,
sourceCacheContext : this.sourceCacheContext,
log : this.nuGetLogger,
token : CancellationToken.None);
return(queryResults.ToList());
}
catch (Exception ex)
{
EventMetadata data = CreateEventMetadata(ex);
this.tracer.RelatedWarning(data, "Error encountered when querying NuGet feed");
throw new Exception($"Failed to query the NuGet package feed due to error: {ex.Message}", ex);
}
}
public async Task <(ITemplatePackageInfo PackageInfo, bool Removed)> GetPackageInfoAsync(string packageIdentifier, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(packageIdentifier))
{
throw new ArgumentException($"{nameof(packageIdentifier)} cannot be null or empty", nameof(packageIdentifier));
}
try
{
PackageMetadataResource resource = await _repository.GetResourceAsync <PackageMetadataResource>(cancellationToken).ConfigureAwait(false);
IEnumerable <IPackageSearchMetadata> foundPackages = await resource.GetMetadataAsync(
packageIdentifier,
includePrerelease : _includePreview,
includeUnlisted : true,
_cacheContext,
NullLogger.Instance,
cancellationToken).ConfigureAwait(false);
if (!foundPackages.Any())
{
Console.WriteLine($"Package {packageIdentifier} was not found.");
return(default);