public override Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(
string id,
NuGetVersion version,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken token)
{
var matchedVersion = GetVersion(id, version, logger);
FindPackageByIdDependencyInfo dependencyInfo = null;
if (matchedVersion != null)
{
dependencyInfo = ProcessNuspecReader(
id,
matchedVersion,
nuspecReader =>
{
// Populate the package identity cache while we have the .nuspec open.
var identity = nuspecReader.GetIdentity();
_packageIdentityCache.TryAdd(identity, identity);
return(GetDependencyInfo(nuspecReader));
});
}
return(Task.FromResult(dependencyInfo));
}
private static IEnumerable <LibraryDependency> GetDependencies(
FindPackageByIdDependencyInfo packageInfo,
NuGetFramework targetFramework)
{
if (packageInfo == null)
{
return(Enumerable.Empty <LibraryDependency>());
}
var dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
if (dependencyGroup == null && DeconstructFallbackFrameworks(targetFramework) is DualCompatibilityFramework dualCompatibilityFramework)
{
dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups, dualCompatibilityFramework.SecondaryFramework, item => item.TargetFramework);
}
// FrameworkReducer.GetNearest does not consider ATF since it is used for more than just compat
if (dependencyGroup == null &&
targetFramework is AssetTargetFallbackFramework assetTargetFallbackFramework)
{
dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
assetTargetFallbackFramework.AsFallbackFramework(),
item => item.TargetFramework);
}
if (dependencyGroup != null)
{
return(dependencyGroup.Packages.Select(PackagingUtility.GetLibraryDependencyFromNuspec).ToArray());
}
return(Enumerable.Empty <LibraryDependency>());
}
public async Task <IEnumerable <LibraryDependency> > GetDependenciesAsync(LibraryIdentity match, NuGetFramework targetFramework, CancellationToken cancellationToken)
{
await EnsureResource();
FindPackageByIdDependencyInfo packageInfo = null;
try
{
if (_throttle != null)
{
await _throttle.WaitAsync();
}
packageInfo = await _findPackagesByIdResource.GetDependencyInfoAsync(match.Name, match.Version, cancellationToken);
}
catch (FatalProtocolException e) when(_ignoreFailedSources)
{
if (!_ignoreWarning)
{
_logger.LogWarning(e.Message);
}
return(new List <LibraryDependency>());
}
finally
{
_throttle?.Release();
}
return(GetDependencies(packageInfo, targetFramework));
}
private IEnumerable <LibraryDependency> GetDependencies(
FindPackageByIdDependencyInfo packageInfo,
NuGetFramework targetFramework)
{
if (packageInfo == null)
{
return(Enumerable.Empty <LibraryDependency>());
}
var dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
if (dependencyGroup == null && DeconstructFallbackFrameworks(targetFramework) is DualCompatibilityFramework dualCompatibilityFramework)
{
dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups, dualCompatibilityFramework.SecondaryFramework, item => item.TargetFramework);
}
if (dependencyGroup != null)
{
return(dependencyGroup.Packages.Select(PackagingUtility.GetLibraryDependencyFromNuspec).ToArray());
}
return(Enumerable.Empty <LibraryDependency>());
}
public override Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(string id, NuGetVersion version, CancellationToken token)
{
var info = GetPackageInfo(id, version);
FindPackageByIdDependencyInfo dependencyInfo = null;
if (info != null)
{
var nuspecPath = Path.Combine(info.Path, $"{id}.nuspec");
using (var stream = File.OpenRead(nuspecPath))
{
NuspecReader nuspecReader;
try
{
nuspecReader = new NuspecReader(stream);
}
catch (XmlException ex)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Protocol_PackageMetadataError, id + "." + version, _source);
var inner = new PackagingException(message, ex);
throw new FatalProtocolException(message, inner);
}
catch (PackagingException ex)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Protocol_PackageMetadataError, id + "." + version, _source);
throw new FatalProtocolException(message, ex);
}
dependencyInfo = GetDependencyInfo(nuspecReader);
}
}
return(Task.FromResult(dependencyInfo));
}
public override Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(
string id,
NuGetVersion version,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken token)
{
var matchedVersion = GetVersion(id, version, cacheContext, logger);
FindPackageByIdDependencyInfo dependencyInfo = null;
if (matchedVersion != null)
{
var identity = new PackageIdentity(id, matchedVersion);
dependencyInfo = ProcessNuspecReader(
id,
matchedVersion,
nuspecReader =>
{
return(GetDependencyInfo(nuspecReader));
});
}
return(Task.FromResult(dependencyInfo));
}
private async Task <LibraryDependencyInfo> GetDependenciesCoreAsync(
LibraryIdentity match,
NuGetFramework targetFramework,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
await EnsureResource();
FindPackageByIdDependencyInfo packageInfo = null;
try
{
if (_throttle != null)
{
await _throttle.WaitAsync();
}
// Read package info, this will download the package if needed.
packageInfo = await _findPackagesByIdResource.GetDependencyInfoAsync(
match.Name,
match.Version,
cacheContext,
logger,
cancellationToken);
}
catch (FatalProtocolException e) when(_ignoreFailedSources && !(e is InvalidCacheProtocolException))
{
if (!_ignoreWarning)
{
await _logger.LogAsync(RestoreLogMessage.CreateWarning(NuGetLogCode.NU1801, e.Message, match.Name));
}
}
finally
{
_throttle?.Release();
}
if (packageInfo == null)
{
// Package was not found
return(LibraryDependencyInfo.CreateUnresolved(match, targetFramework));
}
else
{
// Package found
var originalIdentity = new LibraryIdentity(
packageInfo.PackageIdentity.Id,
packageInfo.PackageIdentity.Version,
match.Type);
var dependencies = GetDependencies(packageInfo, targetFramework);
return(LibraryDependencyInfo.Create(originalIdentity, targetFramework, dependencies));
}
}
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 override Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(string id, NuGetVersion version, CancellationToken token)
{
FindPackageByIdDependencyInfo dependencyInfo = null;
var info = GetPackageInfo(id, version);
if (info != null)
{
dependencyInfo = GetDependencyInfo(info.Reader);
}
return(Task.FromResult(dependencyInfo));
}
private IEnumerable <LibraryDependency> GetDependencies(FindPackageByIdDependencyInfo packageInfo, NuGetFramework targetFramework)
{
if (packageInfo == null)
{
return(new List <LibraryDependency>());
}
PackageDependencyGroup dependencies = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
return(GetDependencies(targetFramework, dependencies));
}
private IEnumerable <LibraryDependency> GetDependencies(FindPackageByIdDependencyInfo packageInfo, NuGetFramework targetFramework)
{
var dependencies = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
var frameworkAssemblies = NuGetFrameworkUtility.GetNearest(packageInfo.FrameworkReferenceGroups,
targetFramework,
item => item.TargetFramework);
return(GetDependencies(targetFramework, dependencies, frameworkAssemblies));
}
/// <summary>
/// Asynchronously gets dependency information for a specific package.
/// </summary>
/// <param name="id">A package id.</param>
/// <param name="version">A package version.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="logger">A logger.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns an
/// <see cref="IEnumerable{NuGetVersion}" />.</returns>
/// <exception cref="ArgumentException">Thrown if <paramref name="id" />
/// is either <c>null</c> or an empty string.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="version" /> <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" /> <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> <c>null</c>.</exception>
/// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" />
/// is cancelled.</exception>
public override Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(
string id,
NuGetVersion version,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException(Strings.ArgumentCannotBeNullOrEmpty, nameof(id));
}
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
var stopwatch = Stopwatch.StartNew();
try
{
cancellationToken.ThrowIfCancellationRequested();
FindPackageByIdDependencyInfo dependencyInfo = null;
var info = GetPackageInfo(id, version, cacheContext, logger);
if (info != null)
{
dependencyInfo = GetDependencyInfo(info.Nuspec);
}
return(Task.FromResult(dependencyInfo));
}
finally
{
ProtocolDiagnostics.RaiseEvent(new ProtocolDiagnosticResourceEvent(
_source,
ResourceTypeName,
ThisTypeName,
nameof(GetDependencyInfoAsync),
stopwatch.Elapsed));
}
}
/// <summary>
/// Asynchronously gets dependency information for a specific package.
/// </summary>
/// <param name="id">A package id.</param>
/// <param name="version">A package version.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="logger">A logger.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns an
/// <see cref="IEnumerable{NuGetVersion}" />.</returns>
/// <exception cref="ArgumentException">Thrown if <paramref name="id" />
/// is either <c>null</c> or an empty string.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="version" /> <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" /> <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> <c>null</c>.</exception>
/// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" />
/// is cancelled.</exception>
public override Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(
string id,
NuGetVersion version,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException(Strings.ArgumentCannotBeNullOrEmpty, nameof(id));
}
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
cancellationToken.ThrowIfCancellationRequested();
var matchedVersion = GetVersion(id, version, cacheContext, logger);
FindPackageByIdDependencyInfo dependencyInfo = null;
if (matchedVersion != null)
{
var identity = new PackageIdentity(id, matchedVersion);
dependencyInfo = ProcessNuspecReader(
id,
matchedVersion,
nuspecReader =>
{
return(GetDependencyInfo(nuspecReader));
});
}
return(Task.FromResult(dependencyInfo));
}
public override Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(
string id,
NuGetVersion version,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken token)
{
FindPackageByIdDependencyInfo dependencyInfo = null;
var info = GetPackageInfo(id, version, logger);
if (info != null)
{
dependencyInfo = GetDependencyInfo(info.Nuspec);
}
return(Task.FromResult(dependencyInfo));
}
private async Task LoadPackage(
string targetDirectory,
FindPackageByIdDependencyInfo info,
NuGetFramework targetFramework,
CancellationToken cancellationToken)
{
using var stream = new MemoryStream();
await _findPackageByIdResource.CopyNupkgToStreamAsync(
info.PackageIdentity.Id,
info.PackageIdentity.Version,
stream, _cacheContext, _nugetLogger,
cancellationToken);
using var reader = new PackageArchiveReader(stream);
var items = await reader.GetLibItemsAsync(cancellationToken);
var targetItems = items.FirstOrDefault(x => x.TargetFramework == targetFramework);
await reader.CopyFilesAsync(
targetDirectory,
targetItems.Items,
(a, b, c) =>
{
try
{
var directory = Path.GetDirectoryName(b);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
using var stream = File.Create(b);
c.CopyTo(stream);
return(b);
}
catch (Exception e)
{
_logger.LogCritical(e, "critical exception");
return(null);
}
},
_nugetLogger,
cancellationToken);
}
private IEnumerable <LibraryDependency> GetDependencies(
FindPackageByIdDependencyInfo packageInfo,
NuGetFramework targetFramework)
{
if (packageInfo == null)
{
return(Enumerable.Empty <LibraryDependency>());
}
var dependencyGroup = NuGetFrameworkUtility.GetNearest(packageInfo.DependencyGroups,
targetFramework,
item => item.TargetFramework);
if (dependencyGroup != null)
{
return(dependencyGroup.Packages.Select(PackagingUtility.GetLibraryDependencyFromNuspec).ToArray());
}
return(Enumerable.Empty <LibraryDependency>());
}
/// <summary>
/// Asynchronously gets dependency information for a specific package.
/// </summary>
/// <param name="id">A package id.</param>
/// <param name="version">A package version.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="logger">A logger.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns an
/// <see cref="IEnumerable{NuGetVersion}" />.</returns>
/// <exception cref="ArgumentException">Thrown if <paramref name="id" />
/// is either <c>null</c> or an empty string.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="version" /> <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" /> <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> <c>null</c>.</exception>
/// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" />
/// is cancelled.</exception>
public override Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(
string id,
NuGetVersion version,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException(Strings.ArgumentCannotBeNullOrEmpty, nameof(id));
}
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
cancellationToken.ThrowIfCancellationRequested();
FindPackageByIdDependencyInfo dependencyInfo = null;
var info = GetPackageInfo(id, version, cacheContext, logger);
if (info != null)
{
dependencyInfo = GetDependencyInfo(info.Nuspec);
}
return(Task.FromResult(dependencyInfo));
}
private async Task <LibraryDependencyInfo> GetDependenciesCoreAsync(
LibraryIdentity match,
NuGetFramework targetFramework,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
FindPackageByIdDependencyInfo packageInfo = null;
try
{
await EnsureResource();
if (_throttle != null)
{
await _throttle.WaitAsync();
}
// Read package info, this will download the package if needed.
packageInfo = await _findPackagesByIdResource.GetDependencyInfoAsync(
match.Name,
match.Version,
cacheContext,
logger,
cancellationToken);
}
catch (FatalProtocolException e) when(e is not InvalidCacheProtocolException)
{
if (_ignoreFailedSources)
{
await LogWarningAsync(logger, match.Name, e);
}
else
{
await LogErrorAsync(logger, match.Name, e);
throw;
}
}
finally
{
_throttle?.Release();
}
if (packageInfo == null)
{
// Package was not found
return(LibraryDependencyInfo.CreateUnresolved(match, targetFramework));
}
else
{
// Package found
var originalIdentity = new LibraryIdentity(
packageInfo.PackageIdentity.Id,
packageInfo.PackageIdentity.Version,
match.Type);
IEnumerable <LibraryDependency> dependencyGroup = GetDependencies(packageInfo, targetFramework);
return(LibraryDependencyInfo.Create(originalIdentity, targetFramework, dependencies: dependencyGroup));
}
}
