public AbstractToolset(string baseDir)
{
this.cache = new SourceCacheContext();
this.repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
this.resource = repository.GetResource <FindPackageByIdResource>();
this.baseDir = baseDir;
}
public RoslynToolset()
{
this.cache = new SourceCacheContext();
this.repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
this.resource = repository.GetResource <FindPackageByIdResource>();
this.nugetDir = Path.Combine(Path.GetDirectoryName(typeof(RoslynToolset).Assembly.Location), "roslyn");
}
internal NuGetPackProvider(string name, string query, DirectoryInfo packageTempBasePath, int pageSize, bool runOnlyOnePage, bool includePreviewPacks)
{
Name = name;
_pageSize = pageSize;
_runOnlyOnePage = runOnlyOnePage;
_packageTempPath = Path.GetFullPath(Path.Combine(packageTempBasePath.FullName, DownloadedPacksDir, Name));
_repository = Repository.Factory.GetCoreV3(NuGetOrgFeed);
ServiceIndexResourceV3 indexResource = _repository.GetResource <ServiceIndexResourceV3>();
IReadOnlyList <ServiceIndexEntry> searchResources = indexResource.GetServiceEntries("SearchQueryService");
_downloadResource = _repository.GetResource <FindPackageByIdResource>();
_includePreview = includePreviewPacks;
if (!searchResources.Any())
{
throw new Exception($"{NuGetOrgFeed} does not support search API (SearchQueryService)");
}
_searchUriFormat = $"{searchResources[0].Uri}?{query}&skip={{0}}&take={{1}}&prerelease={includePreviewPacks}&semVerLevel=2.0.0";
if (Directory.Exists(_packageTempPath))
{
throw new Exception($"temp storage path for NuGet packages already exists: {_packageTempPath}");
}
else
{
Directory.CreateDirectory(_packageTempPath);
}
}
/// <summary>
/// Initializes a new <see cref="RemotePackageArchiveDownloader" /> class.
/// </summary>
/// <param name="resource">A <see cref="FindPackageByIdResource" /> resource.</param>
/// <param name="packageIdentity">A package identity.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="logger">A logger.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="resource" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> is <c>null</c>.</exception>
public RemotePackageArchiveDownloader(
FindPackageByIdResource resource,
PackageIdentity packageIdentity,
SourceCacheContext cacheContext,
ILogger logger)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_resource = resource;
_packageIdentity = packageIdentity;
_cacheContext = cacheContext;
_logger = logger;
_packageReader = new Lazy <PackageArchiveReader>(GetPackageReader);
}
/// <summary>
/// Get all versions of a nuget package, sort by version in descending order
/// </summary>
/// <param name="resource">Resource</param>
/// <param name="packageId">Package ID</param>
/// <param name="includePrerelease">Include Prerelease</param>
/// <param name="limit">Limit</param>
/// <returns></returns>
public static async Task <IList <NuGetVersion> > GetAllVersionsAsync(
this FindPackageByIdResource resource,
string packageId,
bool includePrerelease = false,
int?limit = null)
{
var logger = NullLogger.Instance;
var cancellationToken = CancellationToken.None;
var cache = new SourceCacheContext
{
NoCache = true
};
var versions = await resource.GetAllVersionsAsync(
packageId,
cache,
logger,
cancellationToken);
if (!includePrerelease)
{
versions = versions.Where(v => !v.IsPrerelease);
}
versions = versions.OrderByDescending(v => v.Version);
if (limit.HasValue)
{
versions = versions.Take(limit.Value);
}
return(versions
.ToList());
}
protected override void ExecuteCore()
{
NuGetVersion currentPackageVersion = new NuGetVersion(PackageVersion);
NuGetVersion version = null;
foreach (string nugetFeed in NugetFeeds)
{
SourceRepository repository = Repository.Factory.GetCoreV3(nugetFeed);
FindPackageByIdResource resource = repository.GetResource <FindPackageByIdResource>();
SourceCacheContext cache = new SourceCacheContext();
IEnumerable <NuGetVersion> versions = resource.GetAllVersionsAsync(PackageId, cache, NullLogger.Instance, CancellationToken.None).Result;
NuGetVersion packageVersion = versions?.Where(t => !t.IsPrerelease && t != currentPackageVersion).OrderByDescending(t => t.Version).FirstOrDefault();
if (packageVersion != null)
{
if ((version == null || packageVersion > version) && packageVersion.Version < currentPackageVersion.Version)
{
version = packageVersion;
}
}
}
if (version == null)
{
throw new Exception(string.Format(Resources.BaselinePackageNotFound, PackageId, Environment.NewLine + string.Join(Environment.NewLine + " - ", NugetFeeds)));
}
LastStableVersion = version?.ToNormalizedString();
}
/// <summary>
/// Installs Packages on any project that uses the PackageReference method to reference packages.
/// Uses the dotnet Cli
/// </summary>
/// <param name="packageName">The name of the package to install</param>
/// <param name="messageLogger">An instance of <see cref="IMessageLogger"> to use in logging</param>
internal async Task InstallPackagesOnDotNetCoreFrameworks(string packageName, IMessageLogger messageLogger, string projectTargetFramework)
{
ILogger logger = new Logger(this.messageLogger);
CancellationToken cancellationToken = CancellationToken.None;
FindPackageByIdResource resource = await this.SourceRepository.GetResourceAsync <FindPackageByIdResource>();
NuGetFramework nuGetFramework = NuGetFramework.ParseFolder(projectTargetFramework?.Split('=')[1]);
NuGetVersion packageVersion = await GetPackageLatestNugetVersionAsync(packageName, this.SourceRepository, nuGetFramework.DotNetFrameworkName);
using (MemoryStream packageStream = new MemoryStream())
{
await resource.CopyNupkgToStreamAsync(
packageName,
packageVersion,
packageStream,
new SourceCacheContext(),
logger,
cancellationToken);
}
ProjectItem checkIfItemExists = this.project.GetItems("PackageReference").FirstOrDefault(a => a.EvaluatedInclude.Contains(packageName));
if (checkIfItemExists == null)
{
ProjectItem item = this.project.AddItem("PackageReference", packageName).FirstOrDefault();
item.Xml.AddMetadata("Version", packageVersion.OriginalVersion, true);
this.project.Save();
}
}
public static async Task DownloadPackage(string packageId, string version, string packageLocation, string packageName, string feed)
{
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3(feed);
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
NuGetVersion packageVersion = new NuGetVersion(version);
using (MemoryStream packageStream = new MemoryStream()) {
bool success = await resource.CopyNupkgToStreamAsync(
packageId,
packageVersion,
packageStream,
cache,
logger,
cancellationToken);
var path = Path.Combine(packageLocation, packageName + ".nupkg");
using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
packageStream.WriteTo(fileStream);
}
}
}
private async Task <IEnumerable <string> > GetPackageFileListAsync(DefaultConfigUpdater defaultConfigUpdater, PackageUpdateResult packageUpdate, CancellationToken?cancellationToken = null)
{
string?link = defaultConfigUpdater.GetPackageLink(packageUpdate.PackageId);
if (link == null)
{
// We don't know where nuget package should be extracted to.
return(Enumerable.Empty <string>());
}
SourceCacheContext cache = new SourceCacheContext();
NuGetVersion packageVersion = new NuGetVersion(packageUpdate.NewVersion);
// We have to specify some cancellation token, if caller doesn't provide one
CancellationTokenSource?ownedCancellationToken = cancellationToken == null ? new CancellationTokenSource() : null;
// Stream that will receive the package bytes
using MemoryStream packageStream = new MemoryStream();
try
{
SourceRepository rep = Repository.Factory.GetCoreV3(_feed, FeedType.HttpV3);
if (_credentials != null)
{
rep.PackageSource.Credentials = _credentials;
}
FindPackageByIdResource resource = await rep.GetResourceAsync <FindPackageByIdResource>().ConfigureAwait(false);
Trace.WriteLine($"Downloading package {packageUpdate.PackageId}-{packageUpdate.NewVersion} into memory.");
bool downloadResult = await resource.CopyNupkgToStreamAsync(
packageUpdate.PackageId,
packageVersion,
packageStream,
cache,
NullLogger.Instance,
cancellationToken ?? ownedCancellationToken !.Token)
.ConfigureAwait(false);
if (!downloadResult)
{
Trace.WriteLine($"There is an issue downloading nuget package: {packageUpdate.PackageId}");
return(Enumerable.Empty <string>());
}
Trace.WriteLine($"Downloading complete for package {packageUpdate.PackageId}.");
return(GetNugetFileList(packageStream, link));
}
catch (Exception e)
{
Trace.WriteLine($"There is an issue downloading nuget package.");
Trace.WriteLine(e.ToString());
return(Enumerable.Empty <string>());
}
finally
{
ownedCancellationToken?.Dispose();
}
}
/// <summary>
/// Initializes a new <see cref="RemotePackageArchiveDownloader" /> class.
/// </summary>
/// <param name="source">A package source.</param>
/// <param name="resource">A <see cref="FindPackageByIdResource" /> resource.</param>
/// <param name="packageIdentity">A package identity.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="logger">A logger.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="resource" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> is <c>null</c>.</exception>
public RemotePackageArchiveDownloader(
string source,
FindPackageByIdResource resource,
PackageIdentity packageIdentity,
SourceCacheContext cacheContext,
ILogger logger)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_resource = resource;
_packageIdentity = packageIdentity;
_cacheContext = cacheContext;
_logger = logger;
_packageReader = new Lazy <PackageArchiveReader>(GetPackageReader);
_handleExceptionAsync = exception => Task.FromResult(false);
Source = source;
}
public static async Task DownloadPackageAsync()
{
// 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 DownloadPackage
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
string packageId = "Newtonsoft.Json";
NuGetVersion packageVersion = new NuGetVersion("12.0.1");
using MemoryStream packageStream = new MemoryStream();
await resource.CopyNupkgToStreamAsync(
packageId,
packageVersion,
packageStream,
cache,
logger,
cancellationToken);
Console.WriteLine($"Downloaded package {packageId} {packageVersion}");
using PackageArchiveReader packageReader = new PackageArchiveReader(packageStream);
NuspecReader nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken);
Console.WriteLine($"Tags: {nuspecReader.GetTags()}");
Console.WriteLine($"Description: {nuspecReader.GetDescription()}");
#endregion
}
public async Task DownloadPackageAsync(string packagename, string version)
{
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
string packageId = packagename;
NuGetVersion packageVersion = new NuGetVersion(version);
MemoryStream packageStream = new MemoryStream();
await resource.CopyNupkgToStreamAsync(
packageId,
packageVersion,
packageStream,
cache,
logger,
cancellationToken);
Console.WriteLine($"Downloaded package {packageId} {packageVersion}");
PackageArchiveReader packageReader = new PackageArchiveReader(packageStream);
NuspecReader nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken);
Console.WriteLine($"Tags: {nuspecReader.GetTags()}");
Console.WriteLine($"Description: {nuspecReader.GetDescription()}");
}
private static async Task Run(Options options)
{
// Set up NuGet stuff
sourceCache = new();
sourceRepository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
searchResource = await sourceRepository.GetResourceAsync <PackageSearchResource>();
updateResource = await sourceRepository.GetResourceAsync <PackageUpdateResource>();
findByIdResource = await sourceRepository.GetResourceAsync <FindPackageByIdResource>();
// Search for the nightly package IDs that were just built
var localPackageIds = GetLocalNightlyPackageIds(options);
// Search for the remotely published packages
var remotePackageIds = await GetRemotePackageIds(options);
// If there are differences, that means we removed/renmed something
// In those cases, unist/deprecate all versions
var toCompletelyUnlist = remotePackageIds.Except(localPackageIds).ToList();
foreach (var packageId in toCompletelyUnlist)
{
await DeleteAllVersionsOfPackage(options, packageId);
}
// Now for each package that exists on remote, we want to unlish the nightly versions
// These are packages that are both present locally and on remote
var toUnlistNightly = localPackageIds.Intersect(remotePackageIds).ToList();
foreach (var packageId in toUnlistNightly)
{
await DeleteAllNightlyVersionsOfPackage(options, packageId);
}
}
public async Task <string> DownloadCoreToolsAsync()
{
//ID of the package to be looked
string coreToolsId = "Microsoft.CrmSdk.CoreTools";
string dir = Path.GetDirectoryName(typeof(MyPluginControl).Assembly.Location).ToUpperInvariant();
string folder = Path.GetFileNameWithoutExtension(typeof(MyPluginControl).Assembly.Location);
dir = Path.Combine(dir, folder);
Directory.CreateDirectory(dir);
//Connect to the official package repository IPackageRepository
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3(myPlugin.options.NuGetFeed);
PackageSearchResource packageSearch = await repository.GetResourceAsync <PackageSearchResource>();
FindPackageByIdResource findPackageById = await repository.GetResourceAsync <FindPackageByIdResource>();
var metadata = (await packageSearch.SearchAsync(coreToolsId, new SearchFilter(false, SearchFilterType.IsLatestVersion), 0, 1, logger, cancellationToken)).FirstOrDefault();
var version = (await metadata.GetVersionsAsync()).Max(v => v.Version);
System.Diagnostics.Debug.WriteLine($"Version {version}");
using (MemoryStream packageStream = new MemoryStream())
{
if (!await findPackageById.CopyNupkgToStreamAsync(
coreToolsId,
version,
packageStream,
cache,
logger,
cancellationToken))
{
return(string.Format(Resources.Culture, Resources.CORE_TOOLS_NOT_FOUND, coreToolsId, myPlugin.options.NuGetFeed));
}
using (PackageArchiveReader packageReader = new PackageArchiveReader(packageStream))
{
foreach (var packageFile in await packageReader.GetFilesAsync(cancellationToken))
{
System.Diagnostics.Debug.WriteLine($"{packageFile} {Path.GetDirectoryName(packageFile)} {Path.GetFileName(Path.GetDirectoryName(packageFile))}");
if (Path.GetFileName(Path.GetDirectoryName(packageFile)) == "coretools")
{
using (var fileStream = File.OpenWrite(Path.Combine(dir, Path.GetFileName(packageFile))))
using (var stream = await packageReader.GetStreamAsync(packageFile, cancellationToken))
{
await stream.CopyToAsync(fileStream);
}
}
}
}
}
return(null);
}
public async Task <string> DownloadPackageAsync(PackageId packageId,
NuGetVersion packageVersion = null,
PackageSourceLocation packageSourceLocation = null,
bool includePreview = false,
DirectoryPath?downloadFolder = null)
{
CancellationToken cancellationToken = CancellationToken.None;
if (_restoreActionConfig.Interactive)
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(_verboseLogger,
_restoreActionConfig.Interactive);
}
(var source, var resolvedPackageVersion) = await GetPackageSourceAndVerion(packageId, packageVersion,
packageSourceLocation, includePreview);
FindPackageByIdResource resource = null;
SourceRepository repository = Repository.Factory.GetCoreV3(source);
resource = await repository.GetResourceAsync <FindPackageByIdResource>(cancellationToken)
.ConfigureAwait(false);
if (resource == null)
{
throw new NuGetPackageNotFoundException(
string.Format(LocalizableStrings.FailedToLoadNuGetSource, source.Source));
}
string nupkgPath = downloadFolder == null || !downloadFolder.HasValue
? Path.Combine(_packageInstallDir.Value, packageId.ToString(),
resolvedPackageVersion.ToNormalizedString(),
$"{packageId}.{resolvedPackageVersion.ToNormalizedString()}.nupkg")
: Path.Combine(downloadFolder.Value.Value,
$"{packageId}.{resolvedPackageVersion.ToNormalizedString()}.nupkg");
Directory.CreateDirectory(Path.GetDirectoryName(nupkgPath));
using FileStream destinationStream = File.Create(nupkgPath);
bool success = await resource.CopyNupkgToStreamAsync(
packageId.ToString(),
resolvedPackageVersion,
destinationStream,
_cacheSettings,
_verboseLogger,
cancellationToken);
destinationStream.Close();
if (!success)
{
throw new NuGetPackageInstallerException(
string.Format("Downloading {0} version {1} failed", packageId,
packageVersion.ToNormalizedString()));
}
VerifySigning(nupkgPath);
return(nupkgPath);
}
public async Task LoadNuget()
{
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
packageSearch = await repository.GetResourceAsync <PackageSearchResource>();
findPackageById = await repository.GetResourceAsync <FindPackageByIdResource>();
}
public static async Task Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Two arguments required: <local nuget directory> <remote nuget feed>");
Environment.Exit(1);
}
// Local directory
string localRepositoryPath = args[0];
// Remote nuget feed
string nugetFeedAddress = args[1];
// Won't log a thing, sorry
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
// Setup our repos
SourceCacheContext cache = new SourceCacheContext();
SourceRepository localRepository = Repository.Factory.GetCoreV3(localRepositoryPath, FeedType.FileSystemV2);
SourceRepository nugetFeed = Repository.Factory.GetCoreV3(nugetFeedAddress);
// Get a package searcher by ID on remote
FindPackageByIdResource remotePackageByIdResource =
await nugetFeed.GetResourceAsync <FindPackageByIdResource>();
// Get a local pacakges searcher on local
FindLocalPackagesResource localPackagesResource =
await localRepository.GetResourceAsync <FindLocalPackagesResource>();
// List all local packages
IEnumerable <LocalPackageInfo> localPacakges = localPackagesResource.GetPackages(logger, cancellationToken);
//For each of them
foreach (LocalPackageInfo packageInfo in localPacakges)
{
Console.WriteLine($"Found package {packageInfo.Nuspec.GetId()} {packageInfo.Nuspec.GetVersion()}");
// Check if the package exists at that version on remote
if (await remotePackageByIdResource.DoesPackageExistAsync(
packageInfo.Nuspec.GetId(),
packageInfo.Nuspec.GetVersion(),
cache,
logger,
cancellationToken))
{
Console.WriteLine(
$"WARNING: Package {packageInfo.Nuspec.GetId()} already deployed at version {packageInfo.Nuspec.GetVersion()}");
// Set return code to 128 so CI can fail
Environment.ExitCode = 128;
}
else
{
Console.WriteLine(
$"Package {packageInfo.Nuspec.GetId()} can be deployed at {packageInfo.Nuspec.GetVersion()}");
}
}
}
public static async Task <IEnumerable <NuGetVersion> > GetPackageVersions(FindPackageByIdResource resource, string packageId)
{
IEnumerable <NuGetVersion> versions = await resource.GetAllVersionsAsync(
packageId,
Cache,
NullLogger.Instance,
CancellationToken.None);
return(versions.ToArray());
}
private async Task EnsureResource()
{
if (_findPackagesByIdResource == null)
{
_findPackagesByIdResource = await _sourceRepository.GetResourceAsync <FindPackageByIdResource>();
_findPackagesByIdResource.Logger = _logger;
_findPackagesByIdResource.NoCache = _noCache;
}
}
private async Task <NuspecModel> GetNuspec(string name, string version, string nuspecFilename,
FindPackageByIdResource resource)
{
var nuspecModel = new NuspecModel();
if (nuspecFilename == null)
{
var packageVersion = new NuGetVersion(version);
await using MemoryStream packageStream = new MemoryStream();
await resource.CopyNupkgToStreamAsync(name, packageVersion, packageStream, _sourceCacheContext,
_logger, _cancellationToken);
using PackageArchiveReader packageReader = new PackageArchiveReader(packageStream);
nuspecModel.nuspecReader = await packageReader.GetNuspecReaderAsync(_cancellationToken);
if (!_disableHashComputation)
{
nuspecModel.hashBytes = ComputeSha215Hash(packageStream);
}
}
else
{
await using (var xmlStream = _fileSystem.File.OpenRead(nuspecFilename))
{
nuspecModel.nuspecReader = new NuspecReader(xmlStream);
}
// reference: https://docs.microsoft.com/en-us/nuget/reference/cli-reference/cli-ref-add
// and: https://github.com/NuGet/Home/wiki/Nupkg-Metadata-File
// └─<packageID>
// └─<version>
// ├─<packageID>.<version>.nupkg
// ├─<packageID>.<version>.nupkg.sha512
// └─<packageID>.nuspec
string shaFilename = Path.ChangeExtension(nuspecFilename, version + _sha512Extension);
string nupkgFilename = Path.ChangeExtension(nuspecFilename, version + _nupkgExtension);
if (_fileSystem.File.Exists(shaFilename))
{
string base64Hash = _fileSystem.File.ReadAllText(shaFilename);
nuspecModel.hashBytes = Convert.FromBase64String(base64Hash);
}
else if (!_disableHashComputation && _fileSystem.File.Exists(nupkgFilename))
{
await using (var nupkgStream = _fileSystem.File.OpenRead(nupkgFilename))
{
nuspecModel.hashBytes = ComputeSha215Hash(nupkgStream);
}
}
}
return(nuspecModel);
}
/// <summary>
/// Accesses Nuget's registry via index.json file(entry point) and fetches latest package release versions
/// </summary>
/// <param name="packageName"></param>
/// <returns>Latest version</returns>
public async Task <IEnumerable <NuGetVersion> > GetPackageVersions(string packageName)
{
using (SourceCacheContext cache = new SourceCacheContext())
{
FindPackageByIdResource resource = await _nugetRepository.GetResourceAsync <FindPackageByIdResource>();
IEnumerable <NuGetVersion> versions = await resource.GetAllVersionsAsync(packageName, cache, NullLogger.Instance, CancellationToken.None);
return(versions);
}
}
private void AddNuspecCache(FindPackageByIdResource resource)
{
// Link the nuspec cache to the new resource if it exists.
if (_nuspecCache != null)
{
var localV3 = resource as LocalV3FindPackageByIdResource;
if (localV3 != null)
{
localV3.NuspecCache = _nuspecCache;
}
}
}
private IEnumerable <NuGetVersion> GetVersions(string packageId, string sourceUrl = "https://chocolatey.org/api/v2/")
{
NuGet.Common.ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
PackageSource ps = new PackageSource(sourceUrl);
var sourceRepository = Repository.Factory.GetCoreV2(ps);
FindPackageByIdResource resource = sourceRepository.GetResourceAsync <FindPackageByIdResource>().GetAwaiter().GetResult();
IEnumerable <NuGetVersion> versions = resource.GetAllVersionsAsync(packageId, cache, logger, cancellationToken).GetAwaiter().GetResult();
return(versions);
}
public static async Task <FindPackageByIdResource> GetPackageByIdResource(SourceRepository repository)
{
try
{
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
return(resource);
}
catch
{
return(null);
}
}
public async Task <object> DownloadCoreToolsAsync(string nugetSource)
{
//ID of the package to be looked
string coreToolsId = "Microsoft.CrmSdk.CoreTools";
string dir = GetToolDirectory();
//Connect to the official package repository IPackageRepository
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3(nugetSource);
PackageSearchResource packageSearch = await repository.GetResourceAsync <PackageSearchResource>();
FindPackageByIdResource findPackageById = await repository.GetResourceAsync <FindPackageByIdResource>();
var metadata = (await packageSearch.SearchAsync(coreToolsId, new SearchFilter(false, SearchFilterType.IsLatestVersion), 0, 1, logger, cancellationToken)).FirstOrDefault();
var version = (await metadata.GetVersionsAsync()).Max(v => v.Version);
using (MemoryStream packageStream = new MemoryStream())
{
if (!await findPackageById.CopyNupkgToStreamAsync(
coreToolsId,
version,
packageStream,
cache,
logger,
cancellationToken))
{
return(string.Format(Resources.Culture, Resources.CORE_TOOLS_NOT_FOUND, coreToolsId, nugetSource));
}
using (PackageArchiveReader packageReader = new PackageArchiveReader(packageStream))
{
foreach (var packageFile in await packageReader.GetFilesAsync(cancellationToken))
{
if (Path.GetFileName(Path.GetDirectoryName(packageFile)) == "coretools")
{
using (var fileStream = File.OpenWrite(Path.Combine(dir, Path.GetFileName(packageFile))))
using (var stream = await packageReader.GetStreamAsync(packageFile, cancellationToken))
{
await stream.CopyToAsync(fileStream);
}
}
}
}
}
return(GetSolutionPackagerVersion(dir));
}
static async Task <HashSet <NuGetVersion> > GetVersionsAsync(FindPackageByIdResource findPackageById, string id, object consoleLock)
{
lock (consoleLock)
{
Console.WriteLine($" Checking pushed versions of {id}...");
}
using var cacheContext = Helper.GetCacheContext();
return((await findPackageById.GetAllVersionsAsync(
id,
cacheContext,
NullLogger.Instance, // new ConsoleLogger(),
CancellationToken.None)).ToHashSet());
}
private void AddLocalV3ResourceOptions(FindPackageByIdResource resource)
{
var localV3 = resource as LocalV3FindPackageByIdResource;
if (localV3 != null)
{
// Link the nuspec cache to the new resource if it exists.
if (_packageFileCache != null)
{
localV3.PackageFileCache = _packageFileCache;
}
localV3.IsFallbackFolder = _isFallbackFolderSource;
}
}
private async Task EnsureResource()
{
if (_findPackagesByIdResource == null)
{
var resource = await _sourceRepository.GetResourceAsync <FindPackageByIdResource>();
lock (_lock)
{
if (_findPackagesByIdResource == null)
{
_findPackagesByIdResource = resource;
}
}
}
}
GetPackageVersionsAsync
(
string nuget_id
)
{
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
IEnumerable <NuGetVersion> versions = await resource.GetAllVersionsAsync
(
nuget_id,
source_cache,
logger,
cancellationToken
);
return(versions);
}
private async Task <FindPackageByIdResource> GetFindPackageByIdResource()
{
if (_findPackageById == null)
{
_logger = new NullLogger();
_context = new SourceCacheContext()
{
NoCache = true
};
var sourceUrl = "https://api.nuget.org/v3/index.json";
var sourceRepository = Repository.Factory.GetCoreV3(sourceUrl);
_findPackageById = await sourceRepository.GetResourceAsync <FindPackageByIdResource>();
}
return(_findPackageById);
}
