/// <summary> /// This constructor is just used for testing. /// </summary> public VsPathContextProvider( ISettings settings, IVsSolutionManager solutionManager, NuGet.Common.ILogger logger, IVsProjectAdapterProvider vsProjectAdapterProvider, Func <string, LockFile> getLockFileOrNull) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (solutionManager == null) { throw new ArgumentNullException(nameof(solutionManager)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (vsProjectAdapterProvider == null) { throw new ArgumentNullException(nameof(vsProjectAdapterProvider)); } _settings = new Lazy <ISettings>(() => settings); _solutionManager = new Lazy <IVsSolutionManager>(() => solutionManager); _logger = new Lazy <NuGet.Common.ILogger>(() => logger); _vsProjectAdapterProvider = new Lazy <IVsProjectAdapterProvider>(() => vsProjectAdapterProvider); _getLockFileOrNull = getLockFileOrNull ?? BuildIntegratedProjectUtility.GetLockFileOrNull; }
public VsSolutionRestoreService( IProjectSystemCache projectSystemCache, ISolutionRestoreWorker restoreWorker, [Import("VisualStudioActivityLogger")] NuGet.Common.ILogger logger) { if (projectSystemCache == null) { throw new ArgumentNullException(nameof(projectSystemCache)); } if (restoreWorker == null) { throw new ArgumentNullException(nameof(restoreWorker)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _projectSystemCache = projectSystemCache; _restoreWorker = restoreWorker; _logger = logger; }
/// <summary> /// This constructor is just used for testing. /// </summary> public VsPathContextProvider( ISettings settings, IVsSolutionManager solutionManager, NuGet.Common.ILogger logger, Func <BuildIntegratedNuGetProject, Task <LockFile> > getLockFileOrNullAsync) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (solutionManager == null) { throw new ArgumentNullException(nameof(solutionManager)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _settings = new Lazy <ISettings>(() => settings); _solutionManager = new Lazy <IVsSolutionManager>(() => solutionManager); _logger = new Lazy <NuGet.Common.ILogger>(() => logger); _getLockFileOrNullAsync = getLockFileOrNullAsync ?? BuildIntegratedProjectUtility.GetLockFileOrNull; }
public SolutionManagerProvider(ISolutionDiretoryManager solutionDiretoryManager, NuGetProjectFactory nuGetProjectFactory, IProjectAdapterProvider projectAdapterProvider, INuGetSettingsAccessor nuGetSettingsAccessor, NuGet.Common.ILogger logger) { _solutionDiretoryManager = solutionDiretoryManager; _nuGetProjectFactory = nuGetProjectFactory; _projectAdapterProvider = projectAdapterProvider; _nuGetSettingsAccessor = nuGetSettingsAccessor; _logger = logger; }
public static async IAsyncEnumerable <IPackageSearchMetadata> SearchPackagesByIdAsync( this SourceRepository repository, string packageId, bool includePrerelease, NuGet.Common.ILogger logger, int batchSize = 50, [EnumeratorCancellation] CancellationToken cancellationToken = default ) { var searchResource = await repository.GetResourceAsync <PackageSearchResource>(); await foreach (var metadata in searchResource .SearchPackagesByIdAsync(packageId, includePrerelease, logger) .WithCancellation(cancellationToken)) { yield return(metadata); } }
private async Task ResolvePackage(PackageIdentity package, NuGetFramework framework, SourceCacheContext cacheContext, NuGet.Common.ILogger logger, IEnumerable <SourceRepository> repositories, ConcurrentDictionary <PackageIdentity, SourcePackageDependencyInfo> availablePackages) { if (availablePackages.ContainsKey(package)) { return; } // TODO // Avoid getting info for e.g. netstandard1.x if our framework is highet (e.g. netstandard2.0) //if (framework.IsPackageBased && // package.Id.Equals("netstandard.library", StringComparison.OrdinalIgnoreCase) && // NuGetFrameworkUtility.IsCompatibleWithFallbackCheck(framework, // NuGetFramework.Parse($"netstandard{package.Version.Major}.{package.Version.Minor}"))) //{ // return; //} foreach (var sourceRepository in repositories) { var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>(); var dependencyInfo = await dependencyInfoResource.ResolvePackage( package, framework, cacheContext, logger, CancellationToken.None); if (dependencyInfo == null) { continue; } if (availablePackages.TryAdd(new PackageIdentity(dependencyInfo.Id, dependencyInfo.Version), dependencyInfo)) { await Task.WhenAll(dependencyInfo.Dependencies.Select(dependency => { return(ResolvePackage(new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion), framework, cacheContext, logger, repositories, availablePackages)); })); } } }
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; }
private async Task <bool> DownloadPackageAsync( PackageDownloadRequest request, IEnumerable <SourceRepository> repositories, SourceCacheContext cacheContext, SemaphoreSlim throttle, NuGet.Common.ILogger logger, CancellationToken cancellationToken) { foreach (var repo in repositories) { var findPackageByIdResource = await repo.GetResourceAsync <FindPackageByIdResource>(cancellationToken); if (findPackageByIdResource == null) { logger.LogError($"{nameof(FindPackageByIdResource)} for '{repo}' could not be loaded."); return(false); } using (var downloader = await findPackageByIdResource.GetPackageDownloaderAsync(request.Identity, cacheContext, logger, cancellationToken)) { if (downloader == null) { logger.LogInformation($"Package {request.Identity.Id} {request.Identity.Version} is not available on '{repo}'"); // Skip to the next source if a package cannot be found in a given source. continue; } downloader.SetThrottle(throttle); if (!await downloader.CopyNupkgFileToAsync(request.OutputPath, cancellationToken)) { logger.LogError($"Could not download {request.Identity.Id} {request.Identity.Version} from {repo}."); return(false); } } return(true); } logger.LogError($"{request.Identity.Id} {request.Identity.Version} is not available.'"); return(false); }
public NuGetClientIntegrationTests(ITestOutputHelper output) { _app = new BaGetApplication(output); _client = _app.CreateDefaultClient(); _packageStream = TestResources.GetResourceStream(TestResources.Package); var sourceUri = new Uri(_app.Server.BaseAddress, "v3/index.json"); var packageSource = new PackageSource(sourceUri.AbsoluteUri); var providers = new List <Lazy <INuGetResourceProvider> >(); providers.Add(new Lazy <INuGetResourceProvider>(() => new HttpSourceResourceProviderTestHost(_client))); providers.AddRange(Repository.Provider.GetCoreV3()); _repository = new SourceRepository(packageSource, providers); _cache = new SourceCacheContext { NoCache = true, MaxAge = new DateTimeOffset(), DirectDownload = true }; _logger = NuGet.Common.NullLogger.Instance; _cancellationToken = CancellationToken.None; }
public void Commit(NuGet.Common.ILogger log) { if (!Success) { var name = $"{ProjectName}.nuget.targets"; var path = Path.Combine(ProjectDirectory, name); log.LogMinimal(GettextCatalog.GetString("Generating MSBuild file {0}.", name)); GenerateMSBuildErrorFile(path); } else { // Generate the files as needed var targetsName = $"{ProjectName}.nuget.targets"; var propsName = $"{ProjectName}.nuget.props"; var targetsPath = Path.Combine(ProjectDirectory, targetsName); var propsPath = Path.Combine(ProjectDirectory, propsName); if (Targets.Any()) { log.LogMinimal(GettextCatalog.GetString("Generating MSBuild file {0}.", targetsName)); GenerateImportsFile(targetsPath, Targets); } else if (File.Exists(targetsPath)) { File.Delete(targetsPath); } if (Props.Any()) { log.LogMinimal(GettextCatalog.GetString("Generating MSBuild file {0}.", propsName)); GenerateImportsFile(propsPath, Props); } else if (File.Exists(propsPath)) { File.Delete(propsPath); } } }
public PackageLoader(UpgradeOptions options, ILogger <PackageLoader> logger) { if (options is null) { throw new ArgumentNullException(nameof(options)); } if (options.ProjectPath is null) { throw new ArgumentException("Project path must be set in UpgradeOptions", nameof(options)); } _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _nugetLogger = new NuGetLogger(logger); _cache = new SourceCacheContext(); _packageSources = GetPackageSources(Path.GetDirectoryName(options.ProjectPath)); _sourceRepositoryCache = new Dictionary <PackageSource, SourceRepository>(); var settings = Settings.LoadDefaultSettings(null); _cachePath = SettingsUtility.GetGlobalPackagesFolder(settings); }
public static async IAsyncEnumerable <IPackageSearchMetadata> SearchPackagesByIdAsync( this PackageSearchResource searchResource, string packageId, bool includePrerelease, NuGet.Common.ILogger logger, int batchSize = 50, [EnumeratorCancellation] CancellationToken cancellationToken = default ) { var skip = 0; while (true) { var metadataBatch = (await searchResource.SearchAsync( $"packageId:{packageId}", filters: new SearchFilter(includePrerelease: includePrerelease), skip: skip, take: batchSize, logger, cancellationToken )) .ToList(); foreach (var metadata in metadataBatch) { yield return(metadata); } if (metadataBatch.Count == batchSize) { // There may be more... skip += batchSize; } else { yield break; } } }
public abstract System.Threading.Tasks.Task <NuGet.Protocol.Core.Types.DownloadResourceResult> GetDownloadResourceResultAsync(NuGet.Packaging.Core.PackageIdentity identity, NuGet.Configuration.ISettings settings, NuGet.Common.ILogger logger, System.Threading.CancellationToken token);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Protocol.Core.Types.SourcePackageDependencyInfo> > ResolvePackages(string packageId, NuGet.Frameworks.NuGetFramework projectFramework, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public virtual System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Protocol.Core.Types.RemoteSourceDependencyInfo> > ResolvePackages(string packageId, NuGet.Common.ILogger log, System.Threading.CancellationToken token) { throw null; }
public abstract System.Threading.Tasks.Task <NuGet.Protocol.Core.Types.SourcePackageDependencyInfo> ResolvePackage(NuGet.Packaging.Core.PackageIdentity package, NuGet.Frameworks.NuGetFramework projectFramework, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Versioning.NuGetVersion> > VersionStartsWith(string packageId, string versionPrefix, bool includePrerelease, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Protocol.Core.Types.IPackageSearchMetadata> > SearchAsync(string searchTerm, NuGet.Protocol.Core.Types.SearchFilter filters, int skip, int take, NuGet.Common.ILogger log, System.Threading.CancellationToken cancellationToken);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Versioning.NuGetVersion> > GetVersions(string packageId, bool includePrerelease, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public override Task <bool> Exists(string packageId, bool includePrerelease, bool includeUnlisted, SourceCacheContext sourceCacheContext, NuGet.Common.ILogger log, CancellationToken token) { return(Task.FromResult(Packages .Exists((p) => p.Id.Equals(packageId, StringComparison.InvariantCultureIgnoreCase) && (!p.Version.IsPrerelease || includePrerelease) && (p.Listed || includeUnlisted)) )); }
public System.Threading.Tasks.Task <bool> Exists(string packageId, NuGet.Common.ILogger log, System.Threading.CancellationToken token) { throw null; }
public abstract System.Threading.Tasks.Task <bool> Exists(NuGet.Packaging.Core.PackageIdentity identity, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public System.Threading.Tasks.Task <bool> Exists(NuGet.Packaging.Core.PackageIdentity identity, NuGet.Common.ILogger log, System.Threading.CancellationToken token) { throw null; }
/// <summary> /// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json). /// </summary> /// <param name="projectPath">The full path to the project.</param> /// <param name="id">The ID of the package.</param> /// <param name="version">The version of the package.</param> /// <param name="settings">The NuGet settings to use.</param> /// <param name="logger">An <see cref="ILogger"/> to use for logging.</param> /// <returns></returns> public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit(string projectPath, string id, string version, ISettings settings, ILogger logger) { using (SourceCacheContext sourceCacheContext = new SourceCacheContext { IgnoreFailedSources = true, }) { // The package spec details what packages to restore PackageSpec packageSpec = new PackageSpec(TargetFrameworks.Select(i => new TargetFrameworkInformation { FrameworkName = i, }).ToList()) { Dependencies = new List <LibraryDependency> { new LibraryDependency { LibraryRange = new LibraryRange(id, new VersionRange(NuGetVersion.Parse(version)), LibraryDependencyTarget.Package), SuppressParent = LibraryIncludeFlags.All, AutoReferenced = true, IncludeType = LibraryIncludeFlags.None, Type = LibraryDependencyType.Build } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectPath, ProjectName = Path.GetFileNameWithoutExtension(projectPath), ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectPath, OutputPath = Path.GetTempPath(), OriginalTargetFrameworks = TargetFrameworks.Select(i => i.ToString()).ToList(), ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToList(), PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings), Sources = SettingsUtility.GetEnabledSources(settings).ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, FilePath = projectPath, Name = Path.GetFileNameWithoutExtension(projectPath), }; DependencyGraphSpec dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(packageSpec); dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); RestoreArgs restoreArgs = new RestoreArgs { AllowNoOp = true, CacheContext = sourceCacheContext, CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)), Log = logger, }; // Create requests from the arguments IReadOnlyList <RestoreSummaryRequest> requests = requestProvider.CreateRequests(restoreArgs).Result; // Restore the package without generating extra files return(RestoreRunner.RunWithoutCommit(requests, restoreArgs)); } }
public abstract System.Threading.Tasks.Task <bool> Exists(string packageId, bool includePrerelease, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Protocol.Core.Types.IPackageSearchMetadata> > GetMetadataAsync(string packageId, bool includePrerelease, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public override Task <bool> Exists(PackageIdentity identity, bool includeUnlisted, SourceCacheContext sourceCacheContext, NuGet.Common.ILogger log, CancellationToken token) { return(Task.FromResult(Packages .Exists(p => ((PackageIdentity)p).Equals(identity) && (p.Listed || includeUnlisted)) )); }
public System.Threading.Tasks.Task <NuGet.Versioning.NuGetVersion> GetLatestVersion(string packageId, bool includePrerelease, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token) { throw null; }
public async override Task <IEnumerable <KeyValuePair <string, NuGetVersion> > > GetLatestVersions(IEnumerable <string> packageIds, bool includePrerelease, bool includeUnlisted, SourceCacheContext sourceCacheContext, NuGet.Common.ILogger log, CancellationToken token) { var results = new List <KeyValuePair <string, NuGetVersion> >(); foreach (var id in packageIds) { var versions = await GetVersions(id, sourceCacheContext, log, token); var latest = versions.OrderByDescending(p => p, VersionComparer.VersionRelease).FirstOrDefault(); if (latest != null) { results.Add(new KeyValuePair <string, NuGetVersion>(id, latest)); } } return(results); }
public System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Versioning.NuGetVersion> > GetVersions(string packageId, NuGet.Common.ILogger log, System.Threading.CancellationToken token) { throw null; }