public NugetPackage(ILogger logger) { _logger = logger; try { ISettings settings; try { settings = Settings.LoadDefaultSettings( root: null, configFileName: null, machineWideSettings: new XPlatMachineWideSetting()); } catch (NuGetConfigurationException ex) { // create default settings using a non-existent config file settings = new Settings(nameof(Script.ScriptRunner)); } GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings); _configFilePaths = new List <string>(); //SettingsUtility.GetConfigFilePaths(settings); _packageSources = SettingsUtility.GetEnabledSources(settings); DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false); var sourceProvider = new PackageSourceProvider(settings); } catch (Exception e) { _logger?.LogError(e.Message + e.StackTrace); _initializationException = ExceptionDispatchInfo.Capture(e); } }
/// <summary> /// Configure NuGet's credential providers (i.e. support for authenticated package feeds). /// </summary> static void ConfigureNuGetCredentialProviders() { DefaultCredentialServiceUtility.SetupDefaultCredentialService( logger: NuGetNullLogger.Instance, nonInteractive: true ); }
public async Task Run(SettingsContainer settings, bool write) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } DefaultCredentialServiceUtility.SetupDefaultCredentialService(_nugetLogger, true); var folder = TargetFolder(settings.UserSettings); var sources = _nuGetSourcesReader.Read(folder, settings.UserSettings.NuGetSources); var sortedUpdates = await GetSortedUpdates( folder, sources, settings.UserSettings.AllowedChange, settings.UserSettings.UsePrerelease, settings.PackageFilters?.Includes, settings.PackageFilters?.Excludes); Report(settings.UserSettings, sortedUpdates); if (write) { await _updater.ApplyUpdates(sortedUpdates, folder, sources, settings); } }
public NuGetPackageDownloader(DirectoryPath packageInstallDir, IFilePermissionSetter filePermissionSetter = null, IFirstPartyNuGetPackageSigningVerifier firstPartyNuGetPackageSigningVerifier = null, ILogger verboseLogger = null, IReporter reporter = null, RestoreActionConfig restoreActionConfig = null, Func <IEnumerable <Task> > timer = null) { _packageInstallDir = packageInstallDir; _reporter = reporter ?? Reporter.Output; _verboseLogger = verboseLogger ?? new NuGetConsoleLogger(); _firstPartyNuGetPackageSigningVerifier = firstPartyNuGetPackageSigningVerifier ?? new FirstPartyNuGetPackageSigningVerifier( tempDirectory: packageInstallDir, logger: _verboseLogger); _filePermissionSetter = filePermissionSetter ?? new FilePermissionSetter(); _restoreActionConfig = restoreActionConfig ?? new RestoreActionConfig(); _retryTimer = timer; _sourceRepositories = new Dictionary <PackageSource, SourceRepository>(); _cacheSettings = new SourceCacheContext { NoCache = _restoreActionConfig.NoCache, DirectDownload = true, IgnoreFailedSources = _restoreActionConfig.IgnoreFailedSources, }; DefaultCredentialServiceUtility.SetupDefaultCredentialService(new NuGetConsoleLogger(), !_restoreActionConfig.Interactive); }
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 override bool Execute() { #if DEBUG var debugRestoreTask = Environment.GetEnvironmentVariable("DEBUG_RESTORE_TASK"); if (!string.IsNullOrEmpty(debugRestoreTask) && debugRestoreTask.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase)) { #if IS_CORECLR Console.WriteLine("Waiting for debugger to attach."); Console.WriteLine($"Process ID: {Process.GetCurrentProcess().Id}"); while (!Debugger.IsAttached) { System.Threading.Thread.Sleep(100); } Debugger.Break(); #else Debugger.Launch(); #endif } #endif var log = new MSBuildLogger(Log); // Log inputs log.LogDebug($"(in) RestoreGraphItems Count '{RestoreGraphItems?.Count() ?? 0}'"); log.LogDebug($"(in) RestoreDisableParallel '{RestoreDisableParallel}'"); log.LogDebug($"(in) RestoreNoCache '{RestoreNoCache}'"); log.LogDebug($"(in) RestoreIgnoreFailedSources '{RestoreIgnoreFailedSources}'"); log.LogDebug($"(in) RestoreRecursive '{RestoreRecursive}'"); log.LogDebug($"(in) RestoreForce '{RestoreForce}'"); log.LogDebug($"(in) HideWarningsAndErrors '{HideWarningsAndErrors}'"); log.LogDebug($"(in) RestoreForceEvaluate '{RestoreForceEvaluate}'"); try { DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !Interactive); return(ExecuteAsync(log).Result); } catch (AggregateException ex) when(_cts.Token.IsCancellationRequested && ex.InnerException is TaskCanceledException) { // Canceled by user log.LogError(Strings.RestoreCanceled); return(false); } catch (Exception e) { ExceptionUtilities.LogException(e, log); return(false); } finally { // The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger. // We need to update the delegating logger with a null instance // because the tear downs of the plugins and similar rely on idleness and process exit. DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance); } }
private static void InitializeNuGetCredentialService(INewCommandInput commandInput) { _ = commandInput ?? throw new ArgumentNullException(nameof(commandInput)); try { DefaultCredentialServiceUtility.SetupDefaultCredentialService(new CliNuGetLogger(), !commandInput.IsInteractiveFlagSpecified); } catch (Exception ex) { Reporter.Verbose.WriteLine( string.Format( LocalizableStrings.TemplatePackageCoordinator_Verbose_NuGetCredentialServiceError, ex.ToString())); } }
public NuGetViewModel([Import(AllowDefault = true)] IExceptionManager?exceptionManager, IApplicationSettings appSettings) { try { var settings = LoadSettings(); ConfigPath = settings.GetConfigFilePaths().First(); GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings); DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false); var sourceProvider = new PackageSourceProvider(settings); _sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider); } catch (Exception e) { _initializationException = ExceptionDispatchInfo.Capture(e); ConfigPath = string.Empty; GlobalPackageFolder = string.Empty; } Settings LoadSettings() { Settings?settings = null; const int retries = 3; for (var i = 1; i <= retries; i++) { try { settings = new Settings(appSettings.GetDefaultDocumentPath(), "RoslynPad.nuget.config"); } catch (NuGetConfigurationException ex) { if (i == retries) { exceptionManager?.ReportError(ex); throw; } } } return(settings !); } }
private static async Task <RestoreResultPair> PreviewAddPackageReferenceAsync(PackageReferenceArgs packageReferenceArgs, DependencyGraphSpec dgSpec) { // Set user agent and connection settings. XPlatUtility.ConfigureProtocol(); var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = false; cacheContext.IgnoreFailedSources = false; // Pre-loaded request provider containing the graph file var providers = new List <IPreLoadedRestoreRequestProvider> { new DependencyGraphSpecRequestProvider(providerCache, dgSpec) }; var restoreContext = new RestoreArgs() { CacheContext = cacheContext, LockFileVersion = LockFileFormat.Version, Log = packageReferenceArgs.Logger, MachineWideSettings = new XPlatMachineWideSetting(), GlobalPackagesFolder = packageReferenceArgs.PackageDirectory, PreLoadedRequestProviders = providers, Sources = packageReferenceArgs.Sources?.ToList() }; // Generate Restore Requests. There will always be 1 request here since we are restoring for 1 project. var restoreRequests = await RestoreRunner.GetRequests(restoreContext); //Setup the Credential Service DefaultCredentialServiceUtility.SetupDefaultCredentialService(restoreContext.Log, !packageReferenceArgs.Interactive); // Run restore without commit. This will always return 1 Result pair since we are restoring for 1 request. var restoreResult = await RestoreRunner.RunWithoutCommit(restoreRequests, restoreContext); return(restoreResult.Single()); } }
#pragma warning disable CS8618 // Non-nullable field is uninitialized. public NuGetViewModel() #pragma warning restore CS8618 // Non-nullable field is uninitialized. { try { var settings = Settings.LoadDefaultSettings( root: null, configFileName: null, machineWideSettings: new XPlatMachineWideSetting()); GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings); _configFilePaths = settings.GetConfigFilePaths(); _packageSources = SettingsUtility.GetEnabledSources(settings); DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false); var sourceProvider = new PackageSourceProvider(settings); _sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider); } catch (Exception e) { _initializationException = ExceptionDispatchInfo.Capture(e); } }
public NugetPackage(ILogger logger, NugetManager manager) { _manager = manager; _logger = logger; try { ISettings settings; try { settings = Settings.LoadDefaultSettings( root: null, configFileName: null, machineWideSettings: new XPlatMachineWideSetting()); } catch (NuGetConfigurationException) { // create default settings using a non-existent config file settings = new Settings(nameof(NugetPackage)); } GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings); _configFilePaths = new List <string>(); //SettingsUtility.GetConfigFilePaths(settings); var sources = SettingsUtility.GetEnabledSources(settings); _packageSources = _manager.AdditionalSources.Select(p => new PackageSource(p.source, p.name)).Concat(sources).ToList(); DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false); var sourceProvider = new PackageSourceProvider(settings); var providers = new List <Lazy <INuGetResourceProvider> >(); providers.AddRange(Repository.Provider.GetCoreV3()); _sourceRepositories = _packageSources.Select(s => new SourceRepository(s, providers)).ToList(); } catch (Exception e) { _logger?.LogError(e.Message + e.StackTrace); _initializationException = ExceptionDispatchInfo.Capture(e); } }
public Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild) { packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture, Strings.Info_RemovePkgRemovingReference, packageReferenceArgs.PackageId, packageReferenceArgs.ProjectPath)); //Setup the Credential Service - This allows the msbuild sdk resolver to auth if needed. DefaultCredentialServiceUtility.SetupDefaultCredentialService(packageReferenceArgs.Logger, !packageReferenceArgs.Interactive); var libraryDependency = new LibraryDependency { LibraryRange = new LibraryRange( name: packageReferenceArgs.PackageId, versionRange: VersionRange.All, typeConstraint: LibraryDependencyTarget.Package) }; // Remove reference from the project var result = msBuild.RemovePackageReference(packageReferenceArgs.ProjectPath, libraryDependency); return(Task.FromResult(result)); }
public async Task Run(SettingsContainer settings, bool write) { DefaultCredentialServiceUtility.SetupDefaultCredentialService(new NuGet.Common.NullLogger(), true); var folder = TargetFolder(settings.UserSettings); var sources = _nuGetSourcesReader.Read(folder, settings.UserSettings.NuGetSources); var sortedUpdates = await GetSortedUpdates( folder, sources, settings.UserSettings.AllowedChange, settings.UserSettings.UsePrerelease, settings.PackageFilters?.Includes, settings.PackageFilters?.Excludes); Report(settings.UserSettings, sortedUpdates); if (write) { await _updater.ApplyUpdates(sortedUpdates, folder, sources, settings); } }
public NuGetViewModel(ITelemetryProvider telemetryProvider) #pragma warning restore CS8618 // Non-nullable field is uninitialized. { try { ISettings settings; try { settings = Settings.LoadDefaultSettings( root: null, configFileName: null, machineWideSettings: new XPlatMachineWideSetting()); } catch (NuGetConfigurationException ex) { telemetryProvider.ReportError(ex); // create default settings using a non-existent config file settings = new Settings(nameof(RoslynPad)); } GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings); _configFilePaths = SettingsUtility.GetConfigFilePaths(settings); _packageSources = SettingsUtility.GetEnabledSources(settings); DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false); var sourceProvider = new PackageSourceProvider(settings); _sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider); } catch (Exception e) { _initializationException = ExceptionDispatchInfo.Capture(e); } }
private async Task <bool> ExecuteAsync(Common.ILogger log) { if (RestoreGraphItems.Length < 1) { log.LogWarning(Strings.NoProjectsProvidedToTask); return(true); } // Set user agent and connection settings. ConfigureProtocol(); // Convert to the internal wrapper var wrappedItems = RestoreGraphItems.Select(MSBuildUtility.WrapMSBuildItem); //var graphLines = RestoreGraphItems; var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = RestoreNoCache; cacheContext.IgnoreFailedSources = RestoreIgnoreFailedSources; // Pre-loaded request provider containing the graph file var providers = new List <IPreLoadedRestoreRequestProvider>(); var dgFile = MSBuildRestoreUtility.GetDependencySpec(wrappedItems); if (dgFile.Restore.Count < 1) { // Restore will fail if given no inputs, but here we should skip it and provide a friendly message. log.LogMinimal(Strings.NoProjectsToRestore); return(true); } // Add all child projects if (RestoreRecursive) { BuildTasksUtility.AddAllProjectsForRestore(dgFile); } providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dgFile)); var restoreContext = new RestoreArgs() { CacheContext = cacheContext, LockFileVersion = LockFileFormat.Version, DisableParallel = RestoreDisableParallel, Log = log, MachineWideSettings = new XPlatMachineWideSetting(), PreLoadedRequestProviders = providers, AllowNoOp = !RestoreForce, HideWarningsAndErrors = HideWarningsAndErrors, RestoreForceEvaluate = RestoreForceEvaluate }; // 'dotnet restore' fails on slow machines (https://github.com/NuGet/Home/issues/6742) // The workaround is to pass the '--disable-parallel' option. // We apply the workaround by default when the system has 1 cpu. // This will fix restore failures on VMs with 1 CPU and containers with less or equal to 1 CPU assigned. if (Environment.ProcessorCount == 1) { restoreContext.DisableParallel = true; } if (restoreContext.DisableParallel) { HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore(); } DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !Interactive); _cts.Token.ThrowIfCancellationRequested(); var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, _cts.Token); // Summary RestoreSummary.Log(log, restoreSummaries); return(restoreSummaries.All(x => x.Success)); } }
private async Task <bool> DownloadAndExtractAsync(bool global, string id, string version, CancellationToken cancellationToken) { var logger = NullLogger.Instance; DefaultCredentialServiceUtility.SetupDefaultCredentialService(logger, nonInteractive: false); var settings = Settings.LoadDefaultSettings(root: Environment.CurrentDirectory); var sources = PackageSourceProvider.LoadPackageSources(settings).Where(s => s.IsEnabled); using (var cache = new SourceCacheContext()) { PackageSource versionSource = null; var nugetVersion = String.IsNullOrEmpty(version) ? null : new NuGetVersion(version); if (nugetVersion is null) { foreach (var source in sources) { var repository = Repository.Factory.GetCoreV3(source.Source); var resource = await repository.GetResourceAsync <FindPackageByIdResource>(); var availableVersions = await resource.GetAllVersionsAsync(id, cache, logger, cancellationToken); foreach (var availableVersion in availableVersions) { if (nugetVersion is null || nugetVersion < availableVersion) { nugetVersion = availableVersion; versionSource = source; } } } if (nugetVersion is null) { return(false); } } var searchSources = versionSource is null ? sources : new[] { versionSource }; var extensionFolder = Path.Combine(this.CacheFolder(global), id, nugetVersion.ToString()); foreach (var source in searchSources) { var repository = Repository.Factory.GetCoreV3(source.Source); var resource = await repository.GetResourceAsync <FindPackageByIdResource>(); using (var stream = new MemoryStream()) { var downloaded = await resource.CopyNupkgToStreamAsync(id, nugetVersion, stream, cache, logger, cancellationToken); if (downloaded) { stream.Position = 0; using (var archive = new PackageArchiveReader(stream)) { var files = PackagingConstants.Folders.Known.SelectMany(folder => archive.GetFiles(folder)).Distinct(StringComparer.OrdinalIgnoreCase); await archive.CopyFilesAsync(extensionFolder, files, this.ExtractProgress, logger, cancellationToken); } return(true); } } } } return(false); }
private async Task <bool> ExecuteAsync(Common.ILogger log) { if (RestoreGraphItems.Length < 1) { log.LogWarning(Strings.NoProjectsProvidedToTask); return(true); } // Set user agent and connection settings. ConfigureProtocol(); // Convert to the internal wrapper var wrappedItems = RestoreGraphItems.Select(MSBuildUtility.WrapMSBuildItem); //var graphLines = RestoreGraphItems; var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = RestoreNoCache; cacheContext.IgnoreFailedSources = RestoreIgnoreFailedSources; // Pre-loaded request provider containing the graph file var providers = new List <IPreLoadedRestoreRequestProvider>(); var dgFile = MSBuildRestoreUtility.GetDependencySpec(wrappedItems); if (dgFile.Restore.Count < 1) { // Restore will fail if given no inputs, but here we should skip it and provide a friendly message. log.LogMinimal(Strings.NoProjectsToRestore); return(true); } // Add all child projects if (RestoreRecursive) { BuildTasksUtility.AddAllProjectsForRestore(dgFile); } providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dgFile)); var defaultSettings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null); var sourceProvider = new CachingSourceProvider(new PackageSourceProvider(defaultSettings)); var restoreContext = new RestoreArgs() { CacheContext = cacheContext, LockFileVersion = LockFileFormat.Version, DisableParallel = RestoreDisableParallel, Log = log, MachineWideSettings = new XPlatMachineWideSetting(), PreLoadedRequestProviders = providers, CachingSourceProvider = sourceProvider, AllowNoOp = !RestoreForce, HideWarningsAndErrors = HideWarningsAndErrors, RestoreForceEvaluate = RestoreForceEvaluate }; if (restoreContext.DisableParallel) { HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore(); } DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !Interactive); _cts.Token.ThrowIfCancellationRequested(); var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, _cts.Token); // Summary RestoreSummary.Log(log, restoreSummaries); return(restoreSummaries.All(x => x.Success)); } }
public Task <bool> StartupAsync(CancellationToken token) { DefaultCredentialServiceUtility.SetupDefaultCredentialService(new NuGetLogger(_logger), !_userInput.IsInteractive); return(Task.FromResult(true)); }
public static void Register(CommandLineApplication app, Func <ILogger> getLogger) { app.Command("delete", delete => { delete.Description = Strings.Delete_Description; delete.HelpOption(XPlatUtility.HelpOption); delete.Option( CommandConstants.ForceEnglishOutputOption, Strings.ForceEnglishOutput_Description, CommandOptionType.NoValue); var source = delete.Option( "-s|--source <source>", Strings.Source_Description, CommandOptionType.SingleValue); var nonInteractive = delete.Option( "--non-interactive", Strings.NonInteractive_Description, CommandOptionType.NoValue); var apikey = delete.Option( "-k|--api-key <apiKey>", Strings.ApiKey_Description, CommandOptionType.SingleValue); var arguments = delete.Argument( "[root]", Strings.Delete_PackageIdAndVersion_Description, multipleValues: true); var noServiceEndpointDescription = delete.Option( "--no-service-endpoint", Strings.NoServiceEndpoint_Description, CommandOptionType.NoValue); var interactive = delete.Option( "--interactive", Strings.PushDeleteCommand_Interactive, CommandOptionType.SingleValue); delete.OnExecute(async() => { if (arguments.Values.Count < 2) { throw new ArgumentException(Strings.Delete_MissingArguments); } string packageId = arguments.Values[0]; string packageVersion = arguments.Values[1]; string sourcePath = source.Value(); string apiKeyValue = apikey.Value(); bool nonInteractiveValue = nonInteractive.HasValue(); bool noServiceEndpoint = noServiceEndpointDescription.HasValue(); DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactive.HasValue()); PackageSourceProvider sourceProvider = new PackageSourceProvider(XPlatUtility.CreateDefaultSettings()); await DeleteRunner.Run( sourceProvider.Settings, sourceProvider, packageId, packageVersion, sourcePath, apiKeyValue, nonInteractiveValue, noServiceEndpoint, Confirm, getLogger()); return(0); }); }); }
public static void Register(CommandLineApplication app, Func <ILogger> getLogger, Func <IListPackageCommandRunner> getCommandRunner) { app.Command("list", listpkg => { listpkg.Description = Strings.ListPkg_Description; listpkg.HelpOption(XPlatUtility.HelpOption); listpkg.Option( CommandConstants.ForceEnglishOutputOption, Strings.ForceEnglishOutput_Description, CommandOptionType.NoValue); var path = listpkg.Argument( "<PROJECT | SOLUTION>", Strings.ListPkg_PathDescription, multipleValues: false); var framework = listpkg.Option( "--framework", Strings.ListPkg_FrameworkDescription, CommandOptionType.MultipleValue); var includeOutdated = listpkg.Option( "--outdated", Strings.ListPkg_OutdatedDescription, CommandOptionType.NoValue); var includeDeprecated = listpkg.Option( "--deprecated", Strings.ListPkg_DeprecatedDescription, CommandOptionType.NoValue); var includeTransitive = listpkg.Option( "--include-transitive", Strings.ListPkg_TransitiveDescription, CommandOptionType.NoValue); var prerelease = listpkg.Option( "--include-prerelease", Strings.ListPkg_PrereleaseDescription, CommandOptionType.NoValue); var highestPatch = listpkg.Option( "--highest-patch", Strings.ListPkg_HighestPatchDescription, CommandOptionType.NoValue); var highestMinor = listpkg.Option( "--highest-minor", Strings.ListPkg_HighestMinorDescription, CommandOptionType.NoValue); var source = listpkg.Option( "--source", Strings.ListPkg_SourceDescription, CommandOptionType.MultipleValue); var config = listpkg.Option( "--config", Strings.ListPkg_ConfigDescription, CommandOptionType.SingleValue); var interactive = listpkg.Option( "--interactive", Strings.NuGetXplatCommand_Interactive, CommandOptionType.NoValue); listpkg.OnExecute(async() => { var logger = getLogger(); var settings = ProcessConfigFile(config.Value(), path.Value); var sources = source.Values; var packageSources = GetPackageSources(settings, sources, config); VerifyValidFrameworks(framework); var packageRefArgs = new ListPackageArgs( path.Value, packageSources, framework.Values, includeOutdated.HasValue(), includeDeprecated.HasValue(), includeTransitive.HasValue(), prerelease.HasValue(), highestPatch.HasValue(), highestMinor.HasValue(), logger, CancellationToken.None); DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactive.HasValue()); var listPackageCommandRunner = getCommandRunner(); await listPackageCommandRunner.ExecuteCommandAsync(packageRefArgs); return(0); }); }); }
public static async Task <bool> RestoreAsync( DependencyGraphSpec dependencyGraphSpec, bool interactive, bool recursive, bool noCache, bool ignoreFailedSources, bool disableParallel, bool force, bool forceEvaluate, bool hideWarningsAndErrors, bool restorePC, bool cleanupAssetsForUnsupportedProjects, Common.ILogger log, CancellationToken cancellationToken) { if (dependencyGraphSpec == null) { throw new ArgumentNullException(nameof(dependencyGraphSpec)); } if (log == null) { throw new ArgumentNullException(nameof(log)); } try { DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !interactive); // Set connection limit NetworkProtocolUtility.SetConnectionLimit(); // Set user agent string used for network calls #if IS_CORECLR UserAgent.SetUserAgentString(new UserAgentStringBuilder("NuGet .NET Core MSBuild Task") .WithOSDescription(RuntimeInformation.OSDescription)); #else // OS description is set by default on Desktop UserAgent.SetUserAgentString(new UserAgentStringBuilder("NuGet Desktop MSBuild Task")); #endif X509TrustStore.InitializeForDotNetSdk(log); var restoreSummaries = new List <RestoreSummary>(); var providerCache = new RestoreCommandProvidersCache(); #if IS_DESKTOP if (restorePC && dependencyGraphSpec.Projects.Any(i => i.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig)) { var v2RestoreResult = await PerformNuGetV2RestoreAsync(log, dependencyGraphSpec, noCache, disableParallel, interactive); restoreSummaries.Add(v2RestoreResult); if (restoreSummaries.Count < 1) { var message = string.Format( Strings.InstallCommandNothingToInstall, "packages.config" ); log.LogMinimal(message); } if (!v2RestoreResult.Success) { v2RestoreResult .Errors .Where(l => l.Level == LogLevel.Warning) .ForEach(message => { log.LogWarning(message.Message); }); } } #endif using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = noCache; cacheContext.IgnoreFailedSources = ignoreFailedSources; // Pre-loaded request provider containing the graph file var providers = new List <IPreLoadedRestoreRequestProvider>(); if (dependencyGraphSpec.Restore.Count > 0) { // Add all child projects if (recursive) { AddAllProjectsForRestore(dependencyGraphSpec); } providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dependencyGraphSpec)); var restoreContext = new RestoreArgs() { CacheContext = cacheContext, LockFileVersion = LockFileFormat.Version, // 'dotnet restore' fails on slow machines (https://github.com/NuGet/Home/issues/6742) // The workaround is to pass the '--disable-parallel' option. // We apply the workaround by default when the system has 1 cpu. // This will fix restore failures on VMs with 1 CPU and containers with less or equal to 1 CPU assigned. DisableParallel = Environment.ProcessorCount == 1 ? true : disableParallel, Log = log, MachineWideSettings = new XPlatMachineWideSetting(), PreLoadedRequestProviders = providers, AllowNoOp = !force, HideWarningsAndErrors = hideWarningsAndErrors, RestoreForceEvaluate = forceEvaluate }; if (restoreContext.DisableParallel) { HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore(); } cancellationToken.ThrowIfCancellationRequested(); restoreSummaries.AddRange(await RestoreRunner.RunAsync(restoreContext, cancellationToken)); } if (cleanupAssetsForUnsupportedProjects) { // Restore assets are normally left on disk between restores for all projects. This can cause a condition where a project that supports PackageReference was restored // but then a user changes a branch or some other condition and now the project does not use PackageReference. Since the restore assets are left on disk, the build // consumes them which can cause build errors. The code below cleans up all of the files that we write so that they are not used during build Parallel.ForEach(dependencyGraphSpec.Projects.Where(i => !DoesProjectSupportRestore(i)), project => { if (project.RestoreMetadata == null || string.IsNullOrWhiteSpace(project.RestoreMetadata.OutputPath) || string.IsNullOrWhiteSpace(project.RestoreMetadata.ProjectPath)) { return; } // project.assets.json FileUtility.Delete(Path.Combine(project.RestoreMetadata.OutputPath, LockFileFormat.AssetsFileName)); // project.csproj.nuget.cache FileUtility.Delete(project.RestoreMetadata.CacheFilePath); // project.csproj.nuget.g.props FileUtility.Delete(BuildAssetsUtils.GetMSBuildFilePathForPackageReferenceStyleProject(project, BuildAssetsUtils.PropsExtension)); // project..csproj.nuget.g.targets FileUtility.Delete(BuildAssetsUtils.GetMSBuildFilePathForPackageReferenceStyleProject(project, BuildAssetsUtils.TargetsExtension)); // project.csproj.nuget.dgspec.json FileUtility.Delete(Path.Combine(project.RestoreMetadata.OutputPath, DependencyGraphSpec.GetDGSpecFileName(Path.GetFileName(project.RestoreMetadata.ProjectPath)))); }); } } if (restoreSummaries.Count < 1) { log.LogMinimal(Strings.NoProjectsToRestore); } else { RestoreSummary.Log(log, restoreSummaries); } return(restoreSummaries.All(x => x.Success)); } finally { // The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger. // We need to update the delegating logger with a null instance // because the tear downs of the plugins and similar rely on idleness and process exit. DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance); } }
public async Task <int> Run(RepositorySettings repository, GitUsernamePasswordCredentials credentials, SettingsContainer settings, User user) { if (repository == null) { throw new ArgumentNullException(nameof(repository)); } if (credentials == null) { throw new ArgumentNullException(nameof(credentials)); } if (settings == null) { throw new ArgumentNullException(nameof(settings)); } DefaultCredentialServiceUtility.SetupDefaultCredentialService(_nugetLogger, true); try { var repositoryData = await BuildGitRepositorySpec(repository, credentials.Username); if (repositoryData == null) { return(0); } // should perform the remote check for "is this a .NET repo" // (and also not a github fork) // only when we have multiple remote repos // otherwise it's ok to work locally, and check there if (!(settings.SourceControlServerSettings.Scope == ServerScope.Repository || repository.IsLocalRepo)) { var remoteRepoContainsDotNet = await _repositoryFilter.ContainsDotNetProjects(repository); if (!remoteRepoContainsDotNet) { return(0); } } IFolder folder; if (repository.IsLocalRepo) { folder = new Folder(_logger, new DirectoryInfo(Uri.UnescapeDataString(repository.RemoteInfo.LocalRepositoryUri.AbsolutePath))); settings.WorkingFolder = new Folder(_logger, new DirectoryInfo(Uri.UnescapeDataString(repository.RemoteInfo.WorkingFolder.AbsolutePath))); repositoryData.IsLocalRepo = repository.IsLocalRepo; if (!repositoryData.IsFork) //check if we are on a fork. If not on a fork we set the remote to the locally found remote { repositoryData.Remote = repository.RemoteInfo.RemoteName; } } else { folder = !string.IsNullOrWhiteSpace(settings?.UserSettings?.Directory) ? _folderFactory.FolderFromPath(settings.UserSettings.Directory) : _folderFactory.UniqueTemporaryFolder(); settings.WorkingFolder = folder; } if (!string.IsNullOrEmpty(repository.RemoteInfo?.BranchName)) { repositoryData.DefaultBranch = repository.RemoteInfo.BranchName; } repositoryData.IsLocalRepo = repository.IsLocalRepo; IGitDriver git = string.IsNullOrWhiteSpace(settings?.UserSettings?.GitPath) ? new LibGit2SharpDriver(_logger, folder, credentials, user) as IGitDriver : new GitCmdDriver(settings.UserSettings.GitPath, _logger, folder, credentials) as IGitDriver; var updatesDone = await _repositoryUpdater.Run(git, repositoryData, settings); if (!repository.IsLocalRepo) { folder.TryDelete(); } return(updatesDone); } #pragma warning disable CA1031 catch (Exception ex) #pragma warning restore CA1031 { _logger.Error($"Failed on repo {repository.RepositoryName}", ex); return(1); } }
public static async Task <bool> RestoreAsync( DependencyGraphSpec dependencyGraphSpec, bool interactive, bool recursive, bool noCache, bool ignoreFailedSources, bool disableParallel, bool force, bool forceEvaluate, bool hideWarningsAndErrors, bool restorePC, Common.ILogger log, CancellationToken cancellationToken) { if (dependencyGraphSpec == null) { throw new ArgumentNullException(nameof(dependencyGraphSpec)); } if (log == null) { throw new ArgumentNullException(nameof(log)); } try { DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !interactive); // Set connection limit NetworkProtocolUtility.SetConnectionLimit(); // Set user agent string used for network calls #if IS_CORECLR UserAgent.SetUserAgentString(new UserAgentStringBuilder("NuGet .NET Core MSBuild Task") .WithOSDescription(RuntimeInformation.OSDescription)); #else // OS description is set by default on Desktop UserAgent.SetUserAgentString(new UserAgentStringBuilder("NuGet Desktop MSBuild Task")); #endif // This method has no effect on .NET Core. NetworkProtocolUtility.ConfigureSupportedSslProtocols(); var restoreSummaries = new List <RestoreSummary>(); var providerCache = new RestoreCommandProvidersCache(); #if IS_DESKTOP if (restorePC && dependencyGraphSpec.Projects.Any(i => i.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig)) { var v2RestoreResult = await PerformNuGetV2RestoreAsync(log, dependencyGraphSpec, noCache, disableParallel, interactive); restoreSummaries.Add(v2RestoreResult); if (restoreSummaries.Count < 1) { var message = string.Format( Strings.InstallCommandNothingToInstall, "packages.config" ); log.LogMinimal(message); } if (!v2RestoreResult.Success) { v2RestoreResult .Errors .Where(l => l.Level == LogLevel.Warning) .ForEach(message => { log.LogWarning(message.Message); }); } } #endif using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = noCache; cacheContext.IgnoreFailedSources = ignoreFailedSources; // Pre-loaded request provider containing the graph file var providers = new List <IPreLoadedRestoreRequestProvider>(); if (dependencyGraphSpec.Restore.Count > 0) { // Add all child projects if (recursive) { AddAllProjectsForRestore(dependencyGraphSpec); } providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dependencyGraphSpec)); var restoreContext = new RestoreArgs() { CacheContext = cacheContext, LockFileVersion = LockFileFormat.Version, // 'dotnet restore' fails on slow machines (https://github.com/NuGet/Home/issues/6742) // The workaround is to pass the '--disable-parallel' option. // We apply the workaround by default when the system has 1 cpu. // This will fix restore failures on VMs with 1 CPU and containers with less or equal to 1 CPU assigned. DisableParallel = Environment.ProcessorCount == 1 ? true : disableParallel, Log = log, MachineWideSettings = new XPlatMachineWideSetting(), PreLoadedRequestProviders = providers, AllowNoOp = !force, HideWarningsAndErrors = hideWarningsAndErrors, RestoreForceEvaluate = forceEvaluate }; if (restoreContext.DisableParallel) { HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore(); } cancellationToken.ThrowIfCancellationRequested(); restoreSummaries.AddRange(await RestoreRunner.RunAsync(restoreContext, cancellationToken)); } } if (restoreSummaries.Count < 1) { log.LogMinimal(Strings.NoProjectsToRestore); } else { RestoreSummary.Log(log, restoreSummaries); } return(restoreSummaries.All(x => x.Success)); } finally { // The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger. // We need to update the delegating logger with a null instance // because the tear downs of the plugins and similar rely on idleness and process exit. DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance); } }
public static void Register(CommandLineApplication app, Func <ILogger> getLogger) { app.Command("push", push => { push.Description = Strings.Push_Description; push.HelpOption(XPlatUtility.HelpOption); push.Option( CommandConstants.ForceEnglishOutputOption, Strings.ForceEnglishOutput_Description, CommandOptionType.NoValue); var source = push.Option( "-s|--source <source>", Strings.Source_Description, CommandOptionType.SingleValue); var symbolSource = push.Option( "-ss|--symbol-source <source>", Strings.SymbolSource_Description, CommandOptionType.SingleValue); var timeout = push.Option( "-t|--timeout <timeout>", Strings.Push_Timeout_Description, CommandOptionType.SingleValue); var apikey = push.Option( "-k|--api-key <apiKey>", Strings.ApiKey_Description, CommandOptionType.SingleValue); var symbolApiKey = push.Option( "-sk|--symbol-api-key <apiKey>", Strings.SymbolApiKey_Description, CommandOptionType.SingleValue); var disableBuffering = push.Option( "-d|--disable-buffering", Strings.DisableBuffering_Description, CommandOptionType.SingleValue); var noSymbols = push.Option( "-n|--no-symbols", Strings.NoSymbols_Description, CommandOptionType.SingleValue); var arguments = push.Argument( "[root]", Strings.Push_Package_ApiKey_Description, multipleValues: true); var noServiceEndpointDescription = push.Option( "--no-service-endpoint", Strings.NoServiceEndpoint_Description, CommandOptionType.NoValue); var interactive = push.Option( "--interactive", Strings.NuGetXplatCommand_Interactive, CommandOptionType.NoValue); push.OnExecute(async() => { if (arguments.Values.Count < 1) { throw new ArgumentException(Strings.Push_MissingArguments); } string packagePath = arguments.Values[0]; string sourcePath = source.Value(); string apiKeyValue = apikey.Value(); string symbolSourcePath = symbolSource.Value(); string symbolApiKeyValue = symbolApiKey.Value(); bool disableBufferingValue = disableBuffering.HasValue(); bool noSymbolsValue = noSymbols.HasValue(); bool noServiceEndpoint = noServiceEndpointDescription.HasValue(); int timeoutSeconds = 0; if (timeout.HasValue() && !int.TryParse(timeout.Value(), out timeoutSeconds)) { throw new ArgumentException(Strings.Push_InvalidTimeout); } var sourceProvider = new PackageSourceProvider(XPlatUtility.CreateDefaultSettings()); try { DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactive.HasValue()); await PushRunner.Run( sourceProvider.Settings, sourceProvider, packagePath, sourcePath, apiKeyValue, symbolSourcePath, symbolApiKeyValue, timeoutSeconds, disableBufferingValue, noSymbolsValue, noServiceEndpoint, getLogger()); } catch (TaskCanceledException ex) { throw new AggregateException(ex, new Exception(Strings.Push_Timeout_Error)); } return(0); }); }); }
public static SdkResult GetSdkResult(SdkReference sdk, object nuGetVersion, SdkResolverContext context, SdkResultFactory factory) { // Cast the NuGet version since the caller does not want to consume NuGet classes directly var parsedSdkVersion = (NuGetVersion)nuGetVersion; // Stores errors and warnings for the result ICollection <string> errors = new List <string>(); ICollection <string> warnings = new List <string>(); // Load NuGet settings and a path resolver var settings = Settings.LoadDefaultSettings(context.ProjectFilePath); var fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings)); var libraryIdentity = new LibraryIdentity(sdk.Name, parsedSdkVersion, LibraryType.Package); // Attempt to find a package if its already installed if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, libraryIdentity, out var installedPath, out var installedVersion)) { try { var nugetSDKLogger = new NuGetSdkLogger(context.Logger, warnings, errors); DefaultCredentialServiceUtility.SetupDefaultCredentialService(nugetSDKLogger, nonInteractive: context.IsNonInteractive()); // Asynchronously run the restore without a commit which find the package on configured feeds, download, and unzip it without generating any other files // This must be run in its own task because legacy project system evaluates projects on the UI thread which can cause RunWithoutCommit() to deadlock // https://developercommunity.visualstudio.com/content/problem/311379/solution-load-never-completes-when-project-contain.html var restoreTask = Task.Run(() => RestoreRunnerEx.RunWithoutCommit( libraryIdentity, settings, nugetSDKLogger)); var results = restoreTask.Result; fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings)); // Look for a successful result, any errors are logged by NuGet foreach (var result in results.Select(i => i.Result).Where(i => i.Success)) { // Find the information about the package that was installed. In some cases, the version can be different than what was specified (like you specify 1.0 but get 1.0.0) var installedPackage = result.GetAllInstalled().FirstOrDefault(i => i == libraryIdentity); if (installedPackage != null) { if (TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, installedPackage, out installedPath, out installedVersion)) { break; } // This should never happen because we were told the package was successfully installed. // If we can't find it, we probably did something wrong with the NuGet API errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.CouldNotFindInstalledPackage, sdk)); } else { // This should never happen because we were told the restore succeeded. // If we can't find the package from GetAllInstalled(), we probably did something wrong with the NuGet API errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.PackageWasNotInstalled, sdk, sdk.Name)); } } } catch (Exception e) { errors.Add(e.Message); } finally { // The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger. DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance); } } if (errors.Count == 0) { return(factory.IndicateSuccess(path: installedPath, version: installedVersion, warnings: warnings)); } return(factory.IndicateFailure(errors, warnings)); }
public async Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild) { packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture, Strings.Info_AddPkgAddingReference, packageReferenceArgs.PackageId, packageReferenceArgs.ProjectPath)); if (packageReferenceArgs.NoRestore) { packageReferenceArgs.Logger.LogWarning(string.Format(CultureInfo.CurrentCulture, Strings.Warn_AddPkgWithoutRestore)); VersionRange versionRange = default; if (packageReferenceArgs.NoVersion) { versionRange = packageReferenceArgs.Prerelease ? VersionRange.Parse("*-*") : VersionRange.Parse("*"); } else { versionRange = VersionRange.Parse(packageReferenceArgs.PackageVersion); } var libraryDependency = new LibraryDependency { LibraryRange = new LibraryRange( name: packageReferenceArgs.PackageId, versionRange: versionRange, typeConstraint: LibraryDependencyTarget.Package) }; msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, libraryDependency); return(0); } // 1. Get project dg file packageReferenceArgs.Logger.LogDebug("Reading project Dependency Graph"); var dgSpec = ReadProjectDependencyGraph(packageReferenceArgs); if (dgSpec == null) { // Logging non localized error on debug stream. packageReferenceArgs.Logger.LogDebug(Strings.Error_NoDgSpec); throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_NoDgSpec)); } packageReferenceArgs.Logger.LogDebug("Project Dependency Graph Read"); var projectFullPath = Path.GetFullPath(packageReferenceArgs.ProjectPath); var matchingPackageSpecs = dgSpec .Projects .Where(p => p.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference && PathUtility.GetStringComparerBasedOnOS().Equals(Path.GetFullPath(p.RestoreMetadata.ProjectPath), projectFullPath)) .ToArray(); // This ensures that the DG specs generated in previous steps contain exactly 1 project with the same path as the project requesting add package. // Throw otherwise since we cannot proceed further. if (matchingPackageSpecs.Length != 1) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_UnsupportedProject, packageReferenceArgs.PackageId, packageReferenceArgs.ProjectPath)); } // Parse the user specified frameworks once to avoid re-do's var userSpecifiedFrameworks = Enumerable.Empty <NuGetFramework>(); if (packageReferenceArgs.Frameworks?.Any() == true) { userSpecifiedFrameworks = packageReferenceArgs .Frameworks .Select(f => NuGetFramework.Parse(f)); } var originalPackageSpec = matchingPackageSpecs.FirstOrDefault(); // 2. Determine the version // Setup the Credential Service before making any potential http calls. DefaultCredentialServiceUtility.SetupDefaultCredentialService(packageReferenceArgs.Logger, !packageReferenceArgs.Interactive); if (packageReferenceArgs.Sources?.Any() == true) { // Convert relative path to absolute path if there is any List <string> sources = new List <string>(); foreach (string source in packageReferenceArgs.Sources) { sources.Add(UriUtility.GetAbsolutePath(Environment.CurrentDirectory, source)); } originalPackageSpec.RestoreMetadata.Sources = sources.Where(ns => !string.IsNullOrEmpty(ns)) .Select(ns => new PackageSource(ns)) .ToList(); } PackageDependency packageDependency = default; if (packageReferenceArgs.NoVersion) { var latestVersion = await GetLatestVersionAsync(originalPackageSpec, packageReferenceArgs.PackageId, packageReferenceArgs.Logger, packageReferenceArgs.Prerelease); if (latestVersion == null) { if (!packageReferenceArgs.Prerelease) { latestVersion = await GetLatestVersionAsync(originalPackageSpec, packageReferenceArgs.PackageId, packageReferenceArgs.Logger, !packageReferenceArgs.Prerelease); if (latestVersion != null) { throw new CommandException(string.Format(CultureInfo.CurrentCulture, Strings.PrereleaseVersionsAvailable, latestVersion)); } } throw new CommandException(string.Format(CultureInfo.CurrentCulture, Strings.Error_NoVersionsAvailable, packageReferenceArgs.PackageId)); } packageDependency = new PackageDependency(packageReferenceArgs.PackageId, new VersionRange(minVersion: latestVersion, includeMinVersion: true)); } else { packageDependency = new PackageDependency(packageReferenceArgs.PackageId, VersionRange.Parse(packageReferenceArgs.PackageVersion)); } // Create a copy to avoid modifying the original spec which may be shared. var updatedPackageSpec = originalPackageSpec.Clone(); if (packageReferenceArgs.Frameworks?.Any() == true) { // If user specified frameworks then just use them to add the dependency PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec, packageDependency, userSpecifiedFrameworks); } else { // If the user has not specified a framework, then just add it to all frameworks PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec, packageDependency, updatedPackageSpec.TargetFrameworks.Select(e => e.FrameworkName)); } var updatedDgSpec = dgSpec.WithReplacedSpec(updatedPackageSpec).WithoutRestores(); updatedDgSpec.AddRestore(updatedPackageSpec.RestoreMetadata.ProjectUniqueName); // 3. Run Restore Preview packageReferenceArgs.Logger.LogDebug("Running Restore preview"); var restorePreviewResult = await PreviewAddPackageReferenceAsync(packageReferenceArgs, updatedDgSpec); packageReferenceArgs.Logger.LogDebug("Restore Review completed"); // 4. Process Restore Result var compatibleFrameworks = new HashSet <NuGetFramework>( restorePreviewResult .Result .CompatibilityCheckResults .Where(t => t.Success) .Select(t => t.Graph.Framework), new NuGetFrameworkFullComparer()); if (packageReferenceArgs.Frameworks?.Any() == true) { // If the user has specified frameworks then we intersect that with the compatible frameworks. var userSpecifiedFrameworkSet = new HashSet <NuGetFramework>( userSpecifiedFrameworks, new NuGetFrameworkFullComparer()); compatibleFrameworks.IntersectWith(userSpecifiedFrameworkSet); } // 5. Write to Project if (compatibleFrameworks.Count == 0) { // Package is compatible with none of the project TFMs // Do not add a package reference, throw appropriate error packageReferenceArgs.Logger.LogError(string.Format(CultureInfo.CurrentCulture, Strings.Error_AddPkgIncompatibleWithAllFrameworks, packageReferenceArgs.PackageId, packageReferenceArgs.Frameworks?.Any() == true ? Strings.AddPkg_UserSpecified : Strings.AddPkg_All, packageReferenceArgs.ProjectPath)); return(1); } // Ignore the graphs with RID else if (compatibleFrameworks.Count == restorePreviewResult.Result.CompatibilityCheckResults.Where(r => string.IsNullOrEmpty(r.Graph.RuntimeIdentifier)).Count()) { // Package is compatible with all the project TFMs // Add an unconditional package reference to the project packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture, Strings.Info_AddPkgCompatibleWithAllFrameworks, packageReferenceArgs.PackageId, packageReferenceArgs.ProjectPath)); // generate a library dependency with all the metadata like Include, Exlude and SuppressParent var libraryDependency = GenerateLibraryDependency(updatedPackageSpec, packageReferenceArgs, restorePreviewResult, userSpecifiedFrameworks, packageDependency); msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, libraryDependency); } else { // Package is compatible with some of the project TFMs // Add conditional package references to the project for the compatible TFMs packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture, Strings.Info_AddPkgCompatibleWithSubsetFrameworks, packageReferenceArgs.PackageId, packageReferenceArgs.ProjectPath)); var compatibleOriginalFrameworks = compatibleFrameworks .Select(e => GetAliasForFramework(originalPackageSpec, e)) .Where(originalFramework => originalFramework != null); // generate a library dependency with all the metadata like Include, Exlude and SuppressParent var libraryDependency = GenerateLibraryDependency(updatedPackageSpec, packageReferenceArgs, restorePreviewResult, userSpecifiedFrameworks, packageDependency); msBuild.AddPackageReferencePerTFM(packageReferenceArgs.ProjectPath, libraryDependency, compatibleOriginalFrameworks); } // 6. Commit restore result await RestoreRunner.CommitAsync(restorePreviewResult, CancellationToken.None); return(0); }
private static async Task <RestoreSummary> PerformNuGetV2RestoreAsync(Common.ILogger log, DependencyGraphSpec dgFile, bool noCache, bool disableParallel, bool interactive) { string globalPackageFolder = null; string repositoryPath = null; string firstPackagesConfigPath = null; IList <PackageSource> packageSources = null; var installedPackageReferences = new HashSet <Packaging.PackageReference>(new PackageReferenceComparer()); ISettings settings = null; foreach (PackageSpec packageSpec in dgFile.Projects.Where(i => i.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig)) { var pcRestoreMetadata = (PackagesConfigProjectRestoreMetadata)packageSpec.RestoreMetadata; globalPackageFolder = globalPackageFolder ?? pcRestoreMetadata.PackagesPath; repositoryPath = repositoryPath ?? pcRestoreMetadata.RepositoryPath; if (packageSources == null) { packageSources = new List <PackageSource>(); if (!noCache) { if (!string.IsNullOrEmpty(globalPackageFolder) && Directory.Exists(globalPackageFolder)) { packageSources.Add(new FeedTypePackageSource(globalPackageFolder, FeedType.FileSystemV3)); } } packageSources.AddRange(pcRestoreMetadata.Sources); } settings = settings ?? Settings.LoadSettingsGivenConfigPaths(pcRestoreMetadata.ConfigFilePaths); var packagesConfigPath = Path.Combine(Path.GetDirectoryName(pcRestoreMetadata.ProjectPath), NuGetConstants.PackageReferenceFile); firstPackagesConfigPath = firstPackagesConfigPath ?? packagesConfigPath; installedPackageReferences.AddRange(GetInstalledPackageReferences(packagesConfigPath, allowDuplicatePackageIds: true, log)); } if (string.IsNullOrEmpty(repositoryPath)) { throw new InvalidOperationException(Strings.RestoreNoSolutionFound); } PackageSourceProvider packageSourceProvider = new PackageSourceProvider(settings); var sourceRepositoryProvider = new CachingSourceProvider(packageSourceProvider); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, repositoryPath); var effectivePackageSaveMode = CalculateEffectivePackageSaveMode(settings); var packageSaveMode = effectivePackageSaveMode == Packaging.PackageSaveMode.None ? Packaging.PackageSaveMode.Defaultv2 : effectivePackageSaveMode; var missingPackageReferences = installedPackageReferences.Where(reference => !nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity, packageSaveMode)).ToArray(); if (missingPackageReferences.Length == 0) { return(new RestoreSummary(true)); } var packageRestoreData = missingPackageReferences.Select(reference => new PackageRestoreData( reference, new[] { firstPackagesConfigPath }, isMissing: true)); var repositories = sourceRepositoryProvider.GetRepositories().ToArray(); var installCount = 0; var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>(); var collectorLogger = new RestoreCollectorLogger(log); var packageRestoreContext = new PackageRestoreContext( nuGetPackageManager, packageRestoreData, CancellationToken.None, packageRestoredEvent: (sender, args) => { Interlocked.Add(ref installCount, args.Restored ? 1 : 0); }, packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); }, sourceRepositories: repositories, maxNumberOfParallelTasks: disableParallel ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism, logger: collectorLogger); // TODO: Check require consent? // NOTE: This feature is currently not working at all. See https://github.com/NuGet/Home/issues/4327 // CheckRequireConsent(); var clientPolicyContext = ClientPolicyContext.GetClientPolicy(settings, collectorLogger); var projectContext = new ConsoleProjectContext(collectorLogger) { PackageExtractionContext = new PackageExtractionContext( packageSaveMode, PackageExtractionBehavior.XmlDocFileSaveMode, clientPolicyContext, collectorLogger) }; if (effectivePackageSaveMode != Packaging.PackageSaveMode.None) { projectContext.PackageExtractionContext.PackageSaveMode = packageSaveMode; } using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = noCache; var downloadContext = new PackageDownloadContext(cacheContext, repositoryPath, directDownload: false) { ClientPolicyContext = clientPolicyContext }; DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !interactive); var result = await PackageRestoreManager.RestoreMissingPackagesAsync( packageRestoreContext, projectContext, downloadContext); return(new RestoreSummary( result.Restored, "packages.config projects", settings.GetConfigFilePaths().ToArray(), packageSources.Select(x => x.Source).ToArray(), installCount, collectorLogger.Errors.Concat(ProcessFailedEventsIntoRestoreLogs(failedEvents)).ToArray() )); } }
public static SdkResult GetSdkResult(SdkReference sdk, object nuGetVersion, SdkResolverContext context, SdkResultFactory factory) { // Cast the NuGet version since the caller does not want to consume NuGet classes directly var parsedSdkVersion = (NuGetVersion)nuGetVersion; // Stores errors and warnings for the result ICollection <string> errors = new List <string>(); ICollection <string> warnings = new List <string>(); // Load NuGet settings and a path resolver var settings = Settings.LoadDefaultSettings(context.ProjectFilePath); var fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings)); // Attempt to find a package if its already installed if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, sdk.Name, parsedSdkVersion, out var installedPath, out var installedVersion)) { try { var nugetSDKLogger = new NuGetSdkLogger(context.Logger, warnings, errors); DefaultCredentialServiceUtility.SetupDefaultCredentialService(nugetSDKLogger, nonInteractive: true); // Asynchronously run the restore without a commit which find the package on configured feeds, download, and unzip it without generating any other files var results = RestoreRunnerEx.RunWithoutCommit( context.ProjectFilePath, sdk.Name, parsedSdkVersion.ToFullString(), settings, nugetSDKLogger) .ConfigureAwait(continueOnCapturedContext: false) .GetAwaiter() .GetResult(); fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings)); // Look for a successful result, any errors are logged by NuGet foreach (var result in results.Select(i => i.Result).Where(i => i.Success)) { // Find the information about the package that was installed. In some cases, the version can be different than what was specified (like you specify 1.0 but get 1.0.0) var installedPackage = result.GetAllInstalled().FirstOrDefault(i => i.Name.Equals(sdk.Name)); if (installedPackage != null) { if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, installedPackage.Name, installedPackage.Version, out installedPath, out installedVersion)) { // This should never happen because we were told the package was successfully installed. // If we can't find it, we probably did something wrong with the NuGet API errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.CouldNotFindInstalledPackage, sdk)); } } else { // This should never happen because we were told the restore succeeded. // If we can't find the package from GetAllInstalled(), we probably did something wrong with the NuGet API errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.PackageWasNotInstalled, sdk, sdk.Name)); } } } catch (Exception e) { errors.Add(e.Message); } } if (errors.Count == 0) { return(factory.IndicateSuccess(path: installedPath, version: installedVersion, warnings: warnings)); } return(factory.IndicateFailure(errors, warnings)); }