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)); } }