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}");
}
}
private static async Task FindUpdates(Dictionary <string, string> packageReferences)
{
var logger = new Logger();
var packages = new Dictionary <string, NuGetVersion>(StringComparer.OrdinalIgnoreCase);
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3());
PackageSource packageSource = new PackageSource("https://api.nuget.org/v3/index.json");
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>();
foreach (var packageReference in packageReferences)
{
await GetDependencies(packageReference.Key, NuGetVersion.Parse(packageReference.Value), packages, packageMetadataResource, logger, GetTargetFrameworks());
}
var updates = await GetUpdates(packages, packageMetadataResource, logger);
Console.WriteLine();
Console.WriteLine("-------------------------");
Console.WriteLine("--- Available updates ---");
Console.WriteLine("-------------------------");
Console.WriteLine();
foreach (var update in updates.OrderBy(u => u.Item1))
{
Console.WriteLine("{0}: {1} -> {2}", update.Item1, update.Item2, update.Item3);
}
}
public UpdatePackageFeedTests()
{
// dependencies and data
_metadataResource = Mock.Of <PackageMetadataResource>();
var provider = Mock.Of <INuGetResourceProvider>();
Mock.Get(provider)
.Setup(x => x.TryCreate(It.IsAny <SourceRepository>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(Tuple.Create(true, (INuGetResource)_metadataResource)));
Mock.Get(provider)
.Setup(x => x.ResourceType)
.Returns(typeof(PackageMetadataResource));
var logger = new TestLogger();
var packageSource = new Configuration.PackageSource("http://fake-source");
var source = new SourceRepository(packageSource, new[] { provider });
// target
_metadataProvider = new MultiSourcePackageMetadataProvider(
new[] { source },
optionalLocalRepository: null,
optionalGlobalLocalRepositories: null,
logger: logger);
}
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);
}
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);
}
private void AddPackageSource(List <Lazy <INuGetResourceProvider> > providers, PackageSource packageSource)
{
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
try
{
PackageMetadataResource packageMetadataResource = sourceRepository.GetResource <PackageMetadataResource>();
MetadataResourceList.Add(packageMetadataResource);
}
catch (Exception e)
{
Console.WriteLine("Error loading NuGet Package Meta Data Resource resoure for url: " + packageSource.SourceUri);
if (e.InnerException != null)
{
Console.WriteLine(e.InnerException.Message);
}
}
try
{
DependencyInfoResource dependencyInfoResource = sourceRepository.GetResource <DependencyInfoResource>();
DependencyInfoResourceList.Add(dependencyInfoResource);
Console.WriteLine("Succesfully added dependency info resource: " + sourceRepository.PackageSource.SourceUri);
}
catch (Exception e)
{
Console.WriteLine("Error loading NuGet Dependency Resource resoure for url: " + packageSource.SourceUri);
if (e.InnerException != null)
{
Console.WriteLine(e.InnerException.Message);
}
}
}
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
}
public IEnumerable <PSResourceInfo> SearchAcrossNamesInRepository(
string repositoryName,
PackageSearchResource pkgSearchResource,
PackageMetadataResource pkgMetadataResource,
SearchFilter searchFilter,
SourceCacheContext sourceContext)
{
foreach (string pkgName in _pkgsLeftToFind.ToArray())
{
if (String.IsNullOrWhiteSpace(pkgName))
{
_cmdletPassedIn.WriteDebug(String.Format("Package name: {0} provided was null or whitespace, so name was skipped in search.",
pkgName == null ? "null string" : pkgName));
continue;
}
foreach (PSResourceInfo pkg in FindFromPackageSourceSearchAPI(
repositoryName: repositoryName,
pkgName: pkgName,
pkgSearchResource: pkgSearchResource,
pkgMetadataResource: pkgMetadataResource,
searchFilter: searchFilter,
sourceContext: sourceContext))
{
yield return(pkg);
}
}
}
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 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 <PackageMetadataResource> GetPackageMetadataResource()
{
if (_packageMetadataResource == null)
{
_packageMetadataResource = await SourceRepository.GetResourceAsync <PackageMetadataResource>();
}
return(_packageMetadataResource);
}
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));
}
}
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 List <PSResourceInfo> FindDependencyPackages(
PSResourceInfo currentPkg,
PackageMetadataResource packageMetadataResource,
SourceCacheContext sourceCacheContext
)
{
List <PSResourceInfo> thoseToAdd = new List <PSResourceInfo>();
FindDependencyPackagesHelper(currentPkg, thoseToAdd, packageMetadataResource, sourceCacheContext);
return(thoseToAdd);
}
public void foo()
{
const string packageId = "NUnit";
TestLogger logger = new TestLogger(s => TestContext.WriteLine(s));
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
PackageSource packageSource = new PackageSource("https://api.nuget.org/v3/index.json");
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = GetTaskResult(() => sourceRepository.GetResourceAsync <PackageMetadataResource>(), "repository does not respond on time");
IEnumerable <IPackageSearchMetadata> searchMetadata = GetTaskResult(() => packageMetadataResource.GetMetadataAsync(packageId, true, true, logger, CancellationToken.None), "cannot retrieve packages on time");
}
public override bool Execute()
{
MSBuildLogger logger = new MSBuildLogger(Log);
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
PackageSource packageSource = new PackageSource("https://api.nuget.org/v3/index.json");
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = GetTaskResult(() => sourceRepository.GetResourceAsync <PackageMetadataResource>(), "repository does not respond on time");
IEnumerable <IPackageSearchMetadata> searchMetadata = GetTaskResult(() => packageMetadataResource.GetMetadataAsync(PackageId, true, true, logger, CancellationToken.None), "cannot retrieve packages on time");
return(true);
}
public LocalProviderTests()
{
_localMetadataResource = Mock.Of <PackageMetadataResource>();
_localSource = SetupSourceRepository(_localMetadataResource);
_globalMetadataResource = Mock.Of <PackageMetadataResource>();
_globalSource = SetupSourceRepository(_globalMetadataResource);
_target = new MultiSourcePackageMetadataProvider(
new[] { _source },
optionalLocalRepository: _localSource,
optionalGlobalLocalRepositories: new[] { _globalSource },
logger: _logger);
}
public ProjectReaderNugetDependencyDecorator(IProjectReader @base,
PackageMetadataResource metadataProvider,
DependencyInfoResource dependencyResolver,
SourceCacheContext cacheContext,
ILogger logger)
{
_base = @base ?? throw new ArgumentNullException(nameof(@base));
_metadataProvider = metadataProvider ?? throw new ArgumentNullException(nameof(metadataProvider));
_dependencyResolver = dependencyResolver ?? throw new ArgumentNullException(nameof(dependencyResolver));
_cacheContext = cacheContext ?? throw new ArgumentNullException(nameof(cacheContext));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_cancellationToken = CancellationToken.None;
}
/// <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());
}
protected static SourceRepository SetupSourceRepository(PackageMetadataResource resource)
{
var provider = Mock.Of <INuGetResourceProvider>();
Mock.Get(provider)
.Setup(x => x.TryCreate(It.IsAny <SourceRepository>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(Tuple.Create(true, (INuGetResource)resource)));
Mock.Get(provider)
.Setup(x => x.ResourceType)
.Returns(typeof(PackageMetadataResource));
var packageSource = new Configuration.PackageSource("http://fake-source");
return(new SourceRepository(packageSource, new[] { provider }));
}
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());
}
/// <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 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());
}
public NuGetToNpmWorker(
IPackageNameMapper nameMapper,
IPackageFilter filter,
FindPackageByIdResource findPackageByIdResource,
PackageMetadataResource metadataResource,
IConfiguration configuration,
ILogger <NuGetToNpmWorker> logger,
NuGet.Common.ILogger nugetLogger,
SourceCacheContext cacheContext)
{
_nameMapper = nameMapper;
_filter = filter;
_findPackageByIdResource = findPackageByIdResource;
_metadataResource = metadataResource;
_configuration = configuration;
_logger = logger;
_nugetLogger = nugetLogger;
_cacheContext = cacheContext;
}
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());
}
private List <PackageMetadataResource> CreateMetaDataResourceList(List <Lazy <INuGetResourceProvider> > providers)
{
List <PackageMetadataResource> list = new List <PackageMetadataResource>();
string[] splitRepoUrls = PackagesRepoUrl.Split(new char[] { ',' });
foreach (string repoUrl in splitRepoUrls)
{
string url = repoUrl.Trim();
if (!String.IsNullOrWhiteSpace(url))
{
PackageSource packageSource = new PackageSource(url);
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = sourceRepository.GetResource <PackageMetadataResource>();
list.Add(packageMetadataResource);
}
}
return(list);
}
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 BdioContent BuildBOM()
{
// Load the packages.config file into a list of Packages
NuGet.PackageReferenceFile configFile = new NuGet.PackageReferenceFile(PackagesConfigPath);
// Setup NuGet API
// Snippets taken from https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-2 with modifications
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
// we may need more code here around handling package sources.
PackageSource packageSource = new PackageSource(PackagesRepoUrl);
SourceRepository sourceRepository = new SourceRepository(packageSource, providers);
PackageMetadataResource packageMetadataResource = sourceRepository.GetResource <PackageMetadataResource>();
// Create BDIO
BdioContent bdioContent = BuildBOMFromMetadata(new List <NuGet.PackageReference>(configFile.GetPackageReferences()), packageMetadataResource);
return(bdioContent);
}
