public async Task TestGetMissingPackagesForSolution_NoPackagesInstalled() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) { var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); // Act var packagesFromSolution = (await packageRestoreManager.GetPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, token)); Assert.False(packagesFromSolution.Any()); } }
public MonoDevelopPackageRestoreManager(IMonoDevelopSolutionManager solutionManager) { restoreManager = new PackageRestoreManager( solutionManager.CreateSourceRepositoryProvider(), solutionManager.Settings, solutionManager); }
protected async Task CheckMissingPackagesAsync() { var solutionDirectory = VsSolutionManager.SolutionDirectory; var packages = await PackageRestoreManager.GetPackagesInSolutionAsync(solutionDirectory, CancellationToken.None); if (packages.Any(p => p.IsMissing)) { var packageRestoreConsent = new VisualStudio.PackageRestoreConsent(ConfigSettings); if (packageRestoreConsent.IsGranted) { await TaskScheduler.Default; var result = await PackageRestoreManager.RestoreMissingPackagesAsync(solutionDirectory, packages, this, Token); if (result.Restored) { await PackageRestoreManager.RaisePackagesMissingEventForSolutionAsync(solutionDirectory, CancellationToken.None); return; } } ErrorHandler.HandleException( new InvalidOperationException(Resources.Cmdlet_MissingPackages), terminating: true, errorId: NuGetErrorId.MissingPackages, category: ErrorCategory.InvalidOperation); } }
public async Task TestPackageRestoredEvent() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) { var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = Packages[0]; var testNuGetProjectContext = new TestNuGetProjectContext(); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var resolutionContext = new ResolutionContext(); var token = CancellationToken.None; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); var restoredPackages = new List <PackageIdentity>(); packageRestoreManager.PackageRestoredEvent += delegate(object sender, PackageRestoredEventArgs args) { if (args.Restored) { restoredPackages.Add(args.Package); } }; Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(packageIdentity)); // Delete packages folder TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages")); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); // Act await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, testNuGetProjectContext, new TestLogger(), CancellationToken.None); Assert.Equal(1, restoredPackages.Count); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); } }
private async Task PerformV2Restore(string packagesConfigFilePath, string installPath) { var sourceRepositoryProvider = GetSourceRepositoryProvider(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, installPath, ExcludeVersion); var installedPackageReferences = GetInstalledPackageReferences( packagesConfigFilePath, allowDuplicatePackageIds: true); var packageRestoreData = installedPackageReferences.Select(reference => new PackageRestoreData( reference, new[] { packagesConfigFilePath }, isMissing: true)); var packageSources = GetPackageSources(Settings); Console.PrintPackageSources(packageSources); var packageRestoreContext = new PackageRestoreContext( nuGetPackageManager, packageRestoreData, CancellationToken.None, packageRestoredEvent: null, packageRestoreFailedEvent: null, sourceRepositories: packageSources.Select(sourceRepositoryProvider.CreateRepository), maxNumberOfParallelTasks: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism); var missingPackageReferences = installedPackageReferences.Where(reference => !nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity)).Any(); if (!missingPackageReferences) { var message = string.Format( CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandNothingToInstall"), packagesConfigFilePath); Console.LogMinimal(message); } using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = NoCache; cacheContext.DirectDownload = DirectDownload; var downloadContext = new PackageDownloadContext(cacheContext, installPath, DirectDownload); await PackageRestoreManager.RestoreMissingPackagesAsync( packageRestoreContext, new ConsoleProjectContext(Console), downloadContext); if (downloadContext.DirectDownload) { GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext); } } }
public async Task TestCheckForMissingPackages() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) using (var randomPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder()) { var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomPackageSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using (var packageStream = GetDownloadResult(packageFileInfo)) { // Act await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); var packagesMissingEventCount = 0; var packagesMissing = false; packageRestoreManager.PackagesMissingStatusChanged += delegate(object sender, PackagesMissingStatusEventArgs args) { packagesMissingEventCount++; packagesMissing = args.PackagesMissing; }; // Act await packageRestoreManager.RaisePackagesMissingEventForSolutionAsync(testSolutionManager.SolutionDirectory, token); // Assert Assert.Equal(1, packagesMissingEventCount); Assert.False(packagesMissing); // Delete packages folder TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages")); // Act await packageRestoreManager.RaisePackagesMissingEventForSolutionAsync(testSolutionManager.SolutionDirectory, token); // Assert Assert.Equal(2, packagesMissingEventCount); Assert.True(packagesMissing); } }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { base.Initialize(); // Add our command handlers for menu (commands must exist in the .vsct file) AddMenuCommandHandlers(); // IMPORTANT: Do NOT do anything that can lead to a call to ServiceLocator.GetGlobalService(). // Doing so is illegal and may cause VS to hang. _dte = (DTE)GetService(typeof(SDTE)); Debug.Assert(_dte != null); _dteEvents = _dte.Events.DTEEvents; _dteEvents.OnBeginShutdown += OnBeginShutDown; // set default credential provider for the HttpClient var webProxy = (IVsWebProxy)GetService(typeof(SVsWebProxy)); Debug.Assert(webProxy != null); var settings = Settings.LoadDefaultSettings( _solutionManager == null ? null : _solutionManager.SolutionFileSystem, configFileName: null, machineWideSettings: MachineWideSettings); var packageSourceProvider = new PackageSourceProvider(settings); HttpClient.DefaultCredentialProvider = new SettingsCredentialProvider(new VSRequestCredentialProvider(webProxy), packageSourceProvider); // when NuGet loads, if the current solution has package // restore mode enabled, we make sure every thing is set up correctly. // For example, projects which were added outside of VS need to have // the <Import> element added. if (PackageRestoreManager.IsCurrentSolutionEnabledForRestore) { if (VsVersionHelper.IsVisualStudio2013) { // Run on a background thread in VS2013 to avoid CPS hangs. The modal loading dialog will block // until this completes. ThreadPool.QueueUserWorkItem(new WaitCallback((obj) => PackageRestoreManager.EnableCurrentSolutionForRestore(fromActivation: false))); } else { PackageRestoreManager.EnableCurrentSolutionForRestore(fromActivation: false); } } // when NuGet loads, if the current solution has some package // folders marked for deletion (because a previous uninstalltion didn't succeed), // delete them now. if (SolutionManager.IsSolutionOpen) { DeleteOnRestart.DeleteMarkedPackageDirectories(); } }
protected async Task CheckMissingPackagesAsync() { var solutionDirectory = VsSolutionManager.SolutionDirectory; var packages = await PackageRestoreManager.GetPackagesInSolutionAsync(solutionDirectory, CancellationToken.None); if (packages.Any(p => p.IsMissing)) { var packageRestoreConsent = new PackageRestoreConsent(ConfigSettings); if (packageRestoreConsent.IsGranted) { await TaskScheduler.Default; using (var cacheContext = new SourceCacheContext()) { var logger = new LoggerAdapter(this); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); var downloadContext = new PackageDownloadContext(cacheContext) { ParentId = OperationId, ExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, PackageExtractionBehavior.XmlDocFileSaveMode, logger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(ConfigSettings, logger)) }; var result = await PackageRestoreManager.RestoreMissingPackagesAsync( solutionDirectory, packages, this, downloadContext, logger, Token); if (result.Restored) { await PackageRestoreManager.RaisePackagesMissingEventForSolutionAsync(solutionDirectory, CancellationToken.None); return; } } } ErrorHandler.HandleException( new InvalidOperationException(Resources.Cmdlet_MissingPackages), terminating: true, errorId: NuGetErrorId.MissingPackages, category: ErrorCategory.InvalidOperation); } }
private async Task RestoreMissingPackagesInSolutionAsync(string solutionDirectory, IEnumerable <PackageRestoreData> packages, CancellationToken token) { await TaskScheduler.Default; await PackageRestoreManager.RestoreMissingPackagesAsync(solutionDirectory, packages, NuGetProjectContext, token); }
public async override Task ExecuteCommand() { CalculateEffectivePackageSaveMode(); DetermineRestoreMode(); if (_restoringForSolution && !String.IsNullOrEmpty(SolutionDirectory)) { // option -SolutionDirectory is not valid when we are restoring packages for a solution throw new InvalidOperationException(LocalizedResourceManager.GetString("RestoreCommandOptionSolutionDirectoryIsInvalid")); } string packagesFolderPath = GetPackagesFolderPath(); var packageSourceProvider = new NuGet.Configuration.PackageSourceProvider(Settings); var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, packagesFolderPath); HashSet <PackageReference> installedPackageReferences; Stopwatch watch = new Stopwatch(); if (_restoringForSolution) { watch.Restart(); installedPackageReferences = GetInstalledPackageReferencesFromSolutionFile(_solutionFileFullPath); watch.Stop(); DisplayExecutedTime(watch.Elapsed, "GetInstalledPackageReferencesFromSolution"); } else { // By default the PackageReferenceFile does not throw if the file does not exist at the specified path. // So we'll need to verify that the file exists. if (!File.Exists(_packagesConfigFileFullPath)) { string message = String.Format(CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("RestoreCommandFileNotFound"), _packagesConfigFileFullPath); throw new InvalidOperationException(message); } watch.Restart(); installedPackageReferences = GetInstalledPackageReferences(_packagesConfigFileFullPath); watch.Stop(); DisplayExecutedTime(watch.Elapsed, "GetInstalledPackageReferences"); } watch.Restart(); var missingPackages = PackageRestoreManager.GetMissingPackages(nuGetPackageManager, installedPackageReferences); watch.Stop(); DisplayExecutedTime(watch.Elapsed, "GetMissingPackages"); watch.Restart(); // If sourceRepositories parameter below is null, then the sourceRepositories from the SourceRepositoryProvider in NuGetPackageManager will be used await PackageRestoreManager.RestoreMissingPackages(nuGetPackageManager, missingPackages, Console, CancellationToken.None, packageRestoredEvent : null, sourceRepositories : GetSourceRepositoriesFromSourceSwitch(sourceRepositoryProvider)); watch.Stop(); DisplayExecutedTime(watch.Elapsed, "RestorePackages"); }
public async Task TestGetMissingPackagesForSolution() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) using (var randomPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder()) { var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomPackageSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using (var packageStream = GetDownloadResult(packageFileInfo)) { // Act await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); // Act var packagesFromSolution = (await packageRestoreManager.GetPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, token)); var packagesFromSolutionList = packagesFromSolution.ToList(); var missingPackagesFromSolutionList = packagesFromSolution.Where(p => p.IsMissing).ToList(); Assert.Equal(1, packagesFromSolutionList.Count); Assert.Equal(0, missingPackagesFromSolutionList.Count); // Delete packages folder TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages")); packagesFromSolution = (await packageRestoreManager.GetPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, token)); packagesFromSolutionList = packagesFromSolution.ToList(); missingPackagesFromSolutionList = packagesFromSolution.Where(p => p.IsMissing).ToList(); Assert.Equal(1, missingPackagesFromSolutionList.Count); } }
private void CreatePackageManagerControl() { _container = Initialize(); // This method is called from MainWindow's constructor. Current thread is the main thread var mainThread = Thread.CurrentThread; var synchronizationContext = SynchronizationContext.Current; NuGetUIThreadHelper.SetCustomJoinableTaskFactory(mainThread, synchronizationContext); Title = "NuGet Standalone UI"; Height = 800; Width = 1000; var repositoryProvider = new SourceRepositoryProvider(_settings, Repository.Provider.GetVisualStudio()); var settings = new DefaultSettings(); var testSolutionManager = new TestSolutionManager(@"c:\temp\test"); var projectA = testSolutionManager.AddNewMSBuildProject("projectA"); //var projectB = testSolutionManager.AddNewMSBuildProject("projectB"); //var projectC = testSolutionManager.AddProjectKProject("projectK"); var projectBuildIntegrated = testSolutionManager.AddBuildIntegratedProject("BuildIntProj", NuGetFramework.Parse("net46")); var projects = new[] { projectBuildIntegrated }; var packageRestoreManager = new PackageRestoreManager( repositoryProvider, settings, testSolutionManager); var contextFactory = new StandaloneUIContextFactory( repositoryProvider, testSolutionManager, settings, packageRestoreManager: packageRestoreManager, optionsPage: null); var context = contextFactory.Create(@"c:\temp\test\settings.txt", projects); var uiController = _uiServiceFactory.Create( context, new NuGetUIProjectContext(new StandaloneUILogger(_textBox, _scrollViewer), _sourceControlManagerProvider, _commonOperations)); var model = new PackageManagerModel(uiController, context, isSolution: false, editorFactoryGuid: Guid.Empty); model.SolutionName = "test solution"; _packageManagerControl = new PackageManagerControl(model, _settings, new SimpleSearchBoxFactory(), vsShell: null); layoutGrid.Children.Add(_packageManagerControl); }
protected async Task CheckMissingPackagesAsync() { var solutionDirectory = await VsSolutionManager.GetSolutionDirectoryAsync(); var packages = await PackageRestoreManager.GetPackagesInSolutionAsync(solutionDirectory, CancellationToken.None); if (packages.Any(p => p.IsMissing)) { var packageRestoreConsent = new PackageRestoreConsent(ConfigSettings); if (packageRestoreConsent.IsGranted) { await TaskScheduler.Default; using (var cacheContext = new SourceCacheContext()) { var logger = new LoggerAdapter(this); var downloadContext = new PackageDownloadContext(cacheContext) { ParentId = OperationId, ClientPolicyContext = ClientPolicyContext.GetClientPolicy(ConfigSettings, logger) }; var result = await PackageRestoreManager.RestoreMissingPackagesAsync( solutionDirectory, packages, this, downloadContext, logger, Token); if (result.Restored) { await PackageRestoreManager.RaisePackagesMissingEventForSolutionAsync(solutionDirectory, CancellationToken.None); return; } } } ErrorHandler.HandleException( new InvalidOperationException(Resources.Cmdlet_MissingPackages), terminating: true, errorId: NuGetErrorId.MissingPackages, category: ErrorCategory.InvalidOperation); } }
public RestoreNuGetPackagesInProjectAction( DotNetProject project, NuGetProject nugetProject, IMonoDevelopSolutionManager solutionManager) { this.project = project; this.nugetProject = nugetProject; this.solutionManager = solutionManager; packageManagementEvents = PackageManagementServices.PackageManagementEvents; restoreManager = new PackageRestoreManager( solutionManager.CreateSourceRepositoryProvider(), solutionManager.Settings, solutionManager ); }
protected static Task <PackageRestoreResult> RestoreNuGetPackages(Solution solution) { var solutionManager = new MonoDevelopSolutionManager(solution); var context = new FakeNuGetProjectContext { LogToConsole = true }; var restoreManager = new PackageRestoreManager( solutionManager.CreateSourceRepositoryProvider(), solutionManager.Settings, solutionManager ); return(restoreManager.RestoreMissingPackagesInSolutionAsync( solutionManager.SolutionDirectory, context, CancellationToken.None)); }
public async Task TestGetMissingPackagesForSolution() { // Arrange var testSolutionManager = new TestSolutionManager(); var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); var randomPackageSourcePath = TestFilesystemUtility.CreateRandomTestFolder(); var packageFileInfo = TestPackages.GetLegacyTestPackage(randomPackageSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using (var packageStream = packageFileInfo.OpenRead()) { // Act await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = NullSettings.Instance; var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager); // Act var packageReferencesFromSolution = (await packageRestoreManager.GetPackageReferencesFromSolution(token)).ToList(); var missingPackagesFromSolution = (await packageRestoreManager.GetMissingPackagesInSolution(token)).ToList(); Assert.Equal(2, packageReferencesFromSolution.Count); Assert.Equal(0, missingPackagesFromSolution.Count); // Delete packages folder Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true); packageReferencesFromSolution = (await packageRestoreManager.GetPackageReferencesFromSolution(token)).ToList(); missingPackagesFromSolution = (await packageRestoreManager.GetMissingPackagesInSolution(token)).ToList(); Assert.Equal(2, packageReferencesFromSolution.Count); Assert.Equal(1, missingPackagesFromSolution.Count); }
public async Task <bool> UIRestorePackagesAsync(CancellationToken token) { ThreadHelper.ThrowIfNotOnUIThread(); ShowProgressUI(); OperationId = Guid.NewGuid(); try { PackageRestoreManager.PackageRestoreFailedEvent += PackageRestoreFailedEvent; var solutionDirectory = SolutionManager.SolutionDirectory; await PackageRestoreManager.RestoreMissingPackagesInSolutionAsync(solutionDirectory, this, new LoggerAdapter(this), token); if (RestoreException == null) { // when the control is first loaded, check for missing packages await PackageRestoreManager.RaisePackagesMissingEventForSolutionAsync(solutionDirectory, token); } else { ShowErrorUI(RestoreException.Message); return(false); } } catch (Exception ex) { ShowErrorUI(ex.Message); return(false); } finally { PackageRestoreManager.PackageRestoreFailedEvent -= PackageRestoreFailedEvent; RestoreException = null; } NuGetEventTrigger.Instance.TriggerEvent(NuGetEvent.PackageRestoreCompleted); return(true); }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { base.Initialize(); // Add our command handlers for menu (commands must exist in the .vsct file) AddMenuCommandHandlers(); // IMPORTANT: Do NOT do anything that can lead to a call to ServiceLocator.GetGlobalService(). // Doing so is illegal and may cause VS to hang. _dte = (DTE)GetService(typeof(SDTE)); Debug.Assert(_dte != null); // set default credential provider for the HttpClient var webProxy = (IVsWebProxy)GetService(typeof(SVsWebProxy)); Debug.Assert(webProxy != null); var settings = Settings.LoadDefaultSettings(_solutionManager == null ? null : _solutionManager.SolutionFileSystem); var packageSourceProvider = new PackageSourceProvider(settings); HttpClient.DefaultCredentialProvider = new SettingsCredentialProvider(new VSRequestCredentialProvider(webProxy), packageSourceProvider); // when NuGet loads, if the current solution has package // restore mode enabled, we make sure every thing is set up correctly. // For example, projects which were added outside of VS need to have // the <Import> element added. if (PackageRestoreManager.IsCurrentSolutionEnabledForRestore) { PackageRestoreManager.EnableCurrentSolutionForRestore(fromActivation: false); } // when NuGet loads, if the current solution has some package // folders marked for deletion (because a previous uninstalltion didn't succeed), // delete them now. if (SolutionManager.IsSolutionOpen) { DeleteOnRestart.DeleteMarkedPackageDirectories(); } }
private void UserControl_Loaded(object sender, RoutedEventArgs e) { if (PackageRestoreManager != null) { NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async delegate { try { var solutionDirectory = SolutionManager.SolutionDirectory; // when the control is first loaded, check for missing packages await PackageRestoreManager.RaisePackagesMissingEventForSolutionAsync(solutionDirectory, CancellationToken.None); } catch (Exception ex) { // By default, restore bar is invisible. So, in case of failure of RaisePackagesMissingEventForSolutionAsync, assume it is needed UpdateRestoreBar(packagesMissing: true); var unwrappedException = ExceptionUtility.Unwrap(ex); ShowErrorUI(unwrappedException.Message); } }); } }
private void CreatePackageManagerControl() { _container = Initialize(); this.Title = "NuGet Standalone UI"; Height = 800; Width = 1000; var repositoryProvider = new SourceRepositoryProvider(_settings, Repository.Provider.GetVisualStudio()); var settings = new DefaultSettings(); var testSolutionManager = new TestSolutionManager(@"c:\temp\test"); var projectA = testSolutionManager.AddNewMSBuildProject("projectA"); var projectB = testSolutionManager.AddNewMSBuildProject("projectB"); //var projectC = testSolutionManager.AddProjectKProject("projectK"); var projects = new NuGetProject[] { projectA, projectB }; var packageRestoreManager = new PackageRestoreManager(repositoryProvider, settings, testSolutionManager); var contextFactory = new StandaloneUIContextFactory( repositoryProvider, testSolutionManager, settings, packageRestoreManager: packageRestoreManager, optionsPage: null); var context = contextFactory.Create(@"c:\temp\test\settings.txt", projects); var uiController = _uiServiceFactory.Create( context, new NuGetUIProjectContext(new StandaloneUILogger(_textBox, _scrollViewer), _sourceControlManagerProvider, _commonOperations)); PackageManagerModel model = new PackageManagerModel(uiController, context); model.SolutionName = "test solution"; _packageManagerControl = new PackageManagerControl(model, _settings); layoutGrid.Children.Add(_packageManagerControl); }
private async System.Threading.Tasks.Task RestorePackagesInProject(NuGetProject nuGetProject, CancellationToken token) { if (token.IsCancellationRequested) { return; } var projectName = nuGetProject.GetMetadata <string>(NuGetProjectMetadataKeys.Name); bool hasMissingPackages = false; try { hasMissingPackages = await PackageRestoreManager.RestoreMissingPackagesAsync(nuGetProject, token); WriteLine(hasMissingPackages, error: false); } catch (Exception ex) { var exceptionMessage = _msBuildOutputVerbosity >= (int)VerbosityLevel.Detailed ? ex.ToString() : ex.Message; var message = String.Format( CultureInfo.CurrentCulture, Resources.PackageRestoreFailedForProject, projectName, exceptionMessage); WriteLine(VerbosityLevel.Quiet, message); ActivityLog.LogError(LogEntrySource, message); ShowError(_errorListProvider, TaskErrorCategory.Error, TaskPriority.High, message, hierarchyItem: null); WriteLine(hasMissingPackages, error: true); } finally { WriteLine(VerbosityLevel.Normal, Resources.PackageRestoreFinishedForProject, projectName); } }
public async Task TestRestoreMissingPackages() { // Arrange var testSolutionManager = new TestSolutionManager(); var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = Packages[0]; var testNuGetProjectContext = new TestNuGetProjectContext(); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = NullSettings.Instance; var resolutionContext = new ResolutionContext(); var token = CancellationToken.None; var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(packageIdentity)); // Delete packages folder Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); // Act await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(CancellationToken.None); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); }
private async Task RestorePackagesOrCheckForMissingPackagesAsync( string solutionDirectory, bool isSolutionAvailable) { // To be sure, switch to main thread before doing anything on this method await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var waitDialogFactory = ServiceLocator.GetGlobalService <SVsThreadedWaitDialogFactory, IVsThreadedWaitDialogFactory>(); if (string.IsNullOrEmpty(solutionDirectory)) { // If the solution is closed, SolutionDirectory will be unavailable. Just return. Do nothing return; } var packages = await PackageRestoreManager.GetPackagesInSolutionAsync(solutionDirectory, CancellationToken.None); if (IsConsentGranted(Settings)) { CurrentCount = 0; if (!packages.Any()) { if (!isSolutionAvailable && GetProjectFolderPath().Any(p => CheckPackagesConfig(p.ProjectPath, p.ProjectName))) { MessageHelper.ShowError(_errorListProvider, TaskErrorCategory.Error, TaskPriority.High, NuGet.PackageManagement.VisualStudio.Strings.SolutionIsNotSaved, hierarchyItem: null); WriteLine( VerbosityLevel.Quiet, NuGet.PackageManagement.VisualStudio.Strings.SolutionIsNotSaved); } // Restore is not applicable, since, there is no project with installed packages return; } var missingPackagesList = packages.Where(p => p.IsMissing).ToList(); TotalCount = missingPackagesList.Count; if (TotalCount > 0) { // Only show the wait dialog, when there are some packages to restore using (var threadedWaitDialogSession = waitDialogFactory.StartWaitDialog( waitCaption: Resources.DialogTitle, initialProgress: new ThreadedWaitDialogProgressData( Resources.RestoringPackages, string.Empty, string.Empty, isCancelable: true, currentStep: 0, totalSteps: 0))) { Token = threadedWaitDialogSession.UserCancellationToken; ThreadedWaitDialogProgress = threadedWaitDialogSession.Progress; // Display the restore opt out message if it has not been shown yet DisplayOptOutMessage(); await RestoreMissingPackagesInSolutionAsync(solutionDirectory, packages, Token); // Mark that work is being done during this restore _hasMissingPackages = true; _displayRestoreSummary = true; } } } else { // When the user consent is not granted, missing packages may not be restored. // So, we just check for them, and report them as warning(s) on the error list window using (var twd = waitDialogFactory.StartWaitDialog( waitCaption: Resources.DialogTitle, initialProgress: new ThreadedWaitDialogProgressData( Resources.RestoringPackages, string.Empty, string.Empty, isCancelable: true, currentStep: 0, totalSteps: 0))) { CheckForMissingPackages(packages); } } await PackageRestoreManager.RaisePackagesMissingEventForSolutionAsync(solutionDirectory, CancellationToken.None); }
private async Task <RestoreSummary> PerformNuGetV2RestoreAsync(PackageRestoreInputs packageRestoreInputs) { ReadSettings(packageRestoreInputs); var packagesFolderPath = GetPackagesFolder(packageRestoreInputs); var sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(SourceProvider); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, packagesFolderPath); var installedPackageReferences = new HashSet <Packaging.PackageReference>(new PackageReferenceComparer()); if (packageRestoreInputs.RestoringWithSolutionFile) { installedPackageReferences.AddRange(packageRestoreInputs .PackagesConfigFiles .SelectMany(file => GetInstalledPackageReferences(file, allowDuplicatePackageIds: true))); } else if (packageRestoreInputs.PackagesConfigFiles.Count > 0) { // By default the PackageReferenceFile does not throw // if the file does not exist at the specified path. // So we'll need to verify that the file exists. Debug.Assert(packageRestoreInputs.PackagesConfigFiles.Count == 1, "Only one packages.config file is allowed to be specified " + "at a time when not performing solution restore."); var packageReferenceFile = packageRestoreInputs.PackagesConfigFiles[0]; if (!File.Exists(packageReferenceFile)) { var message = string.Format( CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("RestoreCommandFileNotFound"), packageReferenceFile); throw new InvalidOperationException(message); } installedPackageReferences.AddRange( GetInstalledPackageReferences(packageReferenceFile, allowDuplicatePackageIds: true)); } var missingPackageReferences = installedPackageReferences.Where(reference => !nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity)).ToArray(); if (missingPackageReferences.Length == 0) { var message = string.Format( CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandNothingToInstall"), "packages.config"); Console.LogMinimal(message); return(new RestoreSummary(true)); } var packageRestoreData = missingPackageReferences.Select(reference => new PackageRestoreData( reference, new[] { packageRestoreInputs.RestoringWithSolutionFile ? packageRestoreInputs.DirectoryOfSolutionFile : packageRestoreInputs.PackagesConfigFiles[0] }, isMissing: true)); var packageSources = GetPackageSources(Settings); var repositories = packageSources .Select(sourceRepositoryProvider.CreateRepository) .ToArray(); var installCount = 0; var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>(); 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: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism); CheckRequireConsent(); var collectorLogger = new CollectorLogger(Console); var projectContext = new ConsoleProjectContext(collectorLogger) { PackageExtractionContext = new PackageExtractionContext(collectorLogger) }; if (EffectivePackageSaveMode != Packaging.PackageSaveMode.None) { projectContext.PackageExtractionContext.PackageSaveMode = EffectivePackageSaveMode; } var result = await PackageRestoreManager.RestoreMissingPackagesAsync( packageRestoreContext, projectContext); return(new RestoreSummary( result.Restored, "packages.config projects", Settings.Priority.Select(x => Path.Combine(x.Root, x.FileName)), packageSources.Select(x => x.Source), installCount, collectorLogger.Errors.Concat(failedEvents.Select(e => e.Exception.Message)))); }
public async Task Test_PackageRestoreFailure_WithRaisedEvents() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) using (var randomTestPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder()) { var projectA = testSolutionManager.AddNewMSBuildProject("projectA"); var projectB = testSolutionManager.AddNewMSBuildProject("projectB"); var projectC = testSolutionManager.AddNewMSBuildProject("projectC"); var jQuery144 = Packages[0]; var jQueryValidation = Packages[2]; var testNuGetProjectContext = new TestNuGetProjectContext(); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var resolutionContext = new ResolutionContext(); var token = CancellationToken.None; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); await nuGetPackageManager.InstallPackageAsync(projectA, jQueryValidation, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, jQueryValidation, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); var testPackage1 = new PackageIdentity("package1A", new NuGetVersion("1.0.0")); var testPackage2 = new PackageIdentity("package1B", new NuGetVersion("1.0.0")); var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomTestPackageSourcePath, testPackage1.Id, testPackage1.Version.ToNormalizedString()); using (var packageStream = GetDownloadResult(packageFileInfo)) { // Act await projectB.InstallPackageAsync(testPackage1, packageStream, testNuGetProjectContext, token); await projectC.InstallPackageAsync(testPackage1, packageStream, testNuGetProjectContext, token); } packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomTestPackageSourcePath, testPackage2.Id, testPackage2.Version.ToNormalizedString()); using (var packageStream = GetDownloadResult(packageFileInfo)) { // Act await projectA.InstallPackageAsync(testPackage2, packageStream, testNuGetProjectContext, token); await projectC.InstallPackageAsync(testPackage2, packageStream, testNuGetProjectContext, token); } var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); var restoredPackages = new List <PackageIdentity>(); packageRestoreManager.PackageRestoredEvent += delegate(object sender, PackageRestoredEventArgs args) { restoredPackages.Add(args.Package); }; var restoreFailedPackages = new ConcurrentDictionary <Packaging.PackageReference, IEnumerable <string> >(new PackageReferenceComparer()); packageRestoreManager.PackageRestoreFailedEvent += delegate(object sender, PackageRestoreFailedEventArgs args) { restoreFailedPackages.AddOrUpdate(args.RestoreFailedPackageReference, args.ProjectNames, (Packaging.PackageReference packageReference, IEnumerable <string> oldValue) => { return(oldValue); }); }; Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation)); // Delete packages folder TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages")); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(jQuery144)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage1)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage2)); // Act await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, testNuGetProjectContext, CancellationToken.None); // Assert Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQuery144)); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage1)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage2)); Assert.Equal(4, restoredPackages.Count); // The ordering is not guaranteed and can vary. Do not assert based on that Assert.True(restoredPackages.Contains(jQuery144)); Assert.True(restoredPackages.Contains(jQueryValidation)); Assert.True(restoredPackages.Contains(testPackage1)); Assert.True(restoredPackages.Contains(testPackage2)); Assert.Equal(2, restoreFailedPackages.Count); // The ordering is not guaranteed and can vary. Do not assert based on that var restoreFailedPackageKeys = restoreFailedPackages.Keys; var testPackage1Key = restoreFailedPackageKeys.Where(r => r.PackageIdentity.Equals(testPackage1)).First(); var testPackage1ProjectNames = restoreFailedPackages[testPackage1Key].ToList(); Assert.Equal(2, testPackage1ProjectNames.Count); Assert.True(testPackage1ProjectNames.Contains("projectB", StringComparer.OrdinalIgnoreCase)); Assert.True(testPackage1ProjectNames.Contains("projectC", StringComparer.OrdinalIgnoreCase)); var testPackage2Key = restoreFailedPackageKeys.Where(r => r.PackageIdentity.Equals(testPackage2)).First(); var testPackage2ProjectNames = restoreFailedPackages[testPackage2Key].ToList(); Assert.Equal(2, testPackage2ProjectNames.Count); Assert.True(testPackage2ProjectNames.Contains("projectA", StringComparer.OrdinalIgnoreCase)); Assert.True(testPackage2ProjectNames.Contains("projectC", StringComparer.OrdinalIgnoreCase)); } }
private async System.Threading.Tasks.Task RestorePackagesOrCheckForMissingPackages(vsBuildScope scope) { _msBuildOutputVerbosity = GetMSBuildOutputVerbositySetting(_dte); var waitDialogFactory = ServiceLocator.GetGlobalService <SVsThreadedWaitDialogFactory, IVsThreadedWaitDialogFactory>(); waitDialogFactory.CreateInstance(out _waitDialog); var token = CancellationTokenSource.Token; try { if (IsConsentGranted()) { if (scope == vsBuildScope.vsBuildScopeSolution || scope == vsBuildScope.vsBuildScopeBatch || scope == vsBuildScope.vsBuildScopeProject) { TotalCount = (await PackageRestoreManager.GetMissingPackagesInSolution(token)).ToList().Count; if (TotalCount > 0) { if (_outputOptOutMessage) { _waitDialog.StartWaitDialog( Resources.DialogTitle, Resources.RestoringPackages, String.Empty, varStatusBmpAnim: null, szStatusBarText: null, iDelayToShowDialog: 0, fIsCancelable: true, fShowMarqueeProgress: true); WriteLine(VerbosityLevel.Quiet, Resources.PackageRestoreOptOutMessage); _outputOptOutMessage = false; } System.Threading.Tasks.Task waitDialogCanceledCheckTask = System.Threading.Tasks.Task.Run(() => { // Just create an extra task that can keep checking if the wait dialog was cancelled // If so, cancel the CancellationTokenSource bool canceled = false; try { while (!canceled && CancellationTokenSource != null && !CancellationTokenSource.IsCancellationRequested && _waitDialog != null) { _waitDialog.HasCanceled(out canceled); // Wait on the cancellation handle for 100ms to avoid checking on the wait dialog too frequently CancellationTokenSource.Token.WaitHandle.WaitOne(100); } CancellationTokenSource.Cancel(); } catch (Exception) { // Catch all and don't throw // There is a slight possibility that the _waitDialog was set to null by another thread right after the check for null // So, it could be null or disposed. Just ignore all errors } }); System.Threading.Tasks.Task whenAllTaskForRestorePackageTasks = System.Threading.Tasks.Task.WhenAll(SolutionManager.GetNuGetProjects().Select(nuGetProject => RestorePackagesInProject(nuGetProject, token))); await System.Threading.Tasks.Task.WhenAny(whenAllTaskForRestorePackageTasks, waitDialogCanceledCheckTask); // Once all the tasks are completed, just cancel the CancellationTokenSource // This will prevent the wait dialog from getting updated CancellationTokenSource.Cancel(); } } else { throw new NotImplementedException(); } } else { _waitDialog.StartWaitDialog( Resources.DialogTitle, Resources.RestoringPackages, String.Empty, varStatusBmpAnim: null, szStatusBarText: null, iDelayToShowDialog: 0, fIsCancelable: true, fShowMarqueeProgress: true); CheckForMissingPackages((await PackageRestoreManager.GetMissingPackagesInSolution(token)).ToList()); } } finally { int canceled; _waitDialog.EndWaitDialog(out canceled); _waitDialog = null; } await PackageRestoreManager.RaisePackagesMissingEventForSolution(CancellationToken.None); }
private async Task PerformV2RestoreAsync(string packagesConfigFilePath, string installPath) { var sourceRepositoryProvider = GetSourceRepositoryProvider(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, installPath, ExcludeVersion); var installedPackageReferences = GetInstalledPackageReferences( packagesConfigFilePath, allowDuplicatePackageIds: true); var packageRestoreData = installedPackageReferences.Select(reference => new PackageRestoreData( reference, new[] { packagesConfigFilePath }, isMissing: true)); var packageSources = GetPackageSources(Settings); Console.PrintPackageSources(packageSources); var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>(); var packageRestoreContext = new PackageRestoreContext( nuGetPackageManager, packageRestoreData, CancellationToken.None, packageRestoredEvent: null, packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); }, sourceRepositories: packageSources.Select(sourceRepositoryProvider.CreateRepository), maxNumberOfParallelTasks: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism, logger: Console); var missingPackageReferences = installedPackageReferences.Where(reference => !nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity)).Any(); if (!missingPackageReferences) { var message = string.Format( CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandNothingToInstall"), packagesConfigFilePath); Console.LogMinimal(message); } using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = NoCache; cacheContext.DirectDownload = DirectDownload; var clientPolicyContext = ClientPolicyContext.GetClientPolicy(Settings, Console); var projectContext = new ConsoleProjectContext(Console) { PackageExtractionContext = new PackageExtractionContext( Packaging.PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, clientPolicyContext, Console) }; var downloadContext = new PackageDownloadContext(cacheContext, installPath, DirectDownload) { ClientPolicyContext = clientPolicyContext }; var result = await PackageRestoreManager.RestoreMissingPackagesAsync( packageRestoreContext, projectContext, downloadContext); if (downloadContext.DirectDownload) { GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext); } // Use failure count to determine errors. result.Restored will be false for noop restores. if (failedEvents.Count > 0) { // Log errors if they exist foreach (var message in failedEvents.Select(e => new RestoreLogMessage(LogLevel.Error, NuGetLogCode.Undefined, e.Exception.Message))) { await Console.LogAsync(message); } throw new ExitCodeException(1); } } }
private async Task <IReadOnlyList <RestoreSummary> > PerformNuGetV2RestoreAsync(PackageRestoreInputs packageRestoreInputs) { ReadSettings(packageRestoreInputs); var packagesFolderPath = Path.GetFullPath(GetPackagesFolder(packageRestoreInputs)); var sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(SourceProvider); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, packagesFolderPath); var installedPackageReferences = new HashSet <Packaging.PackageReference>(new PackageReferenceComparer()); if (packageRestoreInputs.RestoringWithSolutionFile) { installedPackageReferences.AddRange(packageRestoreInputs .PackagesConfigFiles .SelectMany(file => GetInstalledPackageReferences(file, allowDuplicatePackageIds: true))); } else if (packageRestoreInputs.PackagesConfigFiles.Count > 0) { // By default the PackageReferenceFile does not throw // if the file does not exist at the specified path. // So we'll need to verify that the file exists. Debug.Assert(packageRestoreInputs.PackagesConfigFiles.Count == 1, "Only one packages.config file is allowed to be specified " + "at a time when not performing solution restore."); var packageReferenceFile = packageRestoreInputs.PackagesConfigFiles[0]; if (!File.Exists(packageReferenceFile)) { var message = string.Format( CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("RestoreCommandFileNotFound"), packageReferenceFile); throw new InvalidOperationException(message); } installedPackageReferences.AddRange( GetInstalledPackageReferences(packageReferenceFile, allowDuplicatePackageIds: true)); } // EffectivePackageSaveMode is None when -PackageSaveMode is not provided by the user. None is treated as // Defaultv3 for V3 restore and should be treated as Defaultv2 for V2 restore. This is the case in the // actual V2 restore flow and should match in this preliminary missing packages check. 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) { var message = string.Format( CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandNothingToInstall"), "packages.config"); Console.LogMinimal(message); var restoreSummaries = new List <RestoreSummary>(); ValidatePackagesConfigLockFiles( packageRestoreInputs.PackagesConfigFiles, packageRestoreInputs.ProjectReferenceLookup.Projects, packagesFolderPath, restoreSummaries); if (restoreSummaries.Count == 0) { restoreSummaries.Add(new RestoreSummary(success: true)); } return(restoreSummaries); } var packageRestoreData = missingPackageReferences.Select(reference => new PackageRestoreData( reference, new[] { packageRestoreInputs.RestoringWithSolutionFile ? packageRestoreInputs.DirectoryOfSolutionFile : packageRestoreInputs.PackagesConfigFiles[0] }, isMissing: true)); var packageSources = GetPackageSources(Settings); var repositories = packageSources .Select(sourceRepositoryProvider.CreateRepository) .ToArray(); var installCount = 0; var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>(); var collectorLogger = new RestoreCollectorLogger(Console); 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: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism, logger: collectorLogger); CheckRequireConsent(); var clientPolicyContext = ClientPolicyContext.GetClientPolicy(Settings, collectorLogger); var projectContext = new ConsoleProjectContext(collectorLogger) { PackageExtractionContext = new PackageExtractionContext( Packaging.PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, clientPolicyContext, collectorLogger) }; if (EffectivePackageSaveMode != Packaging.PackageSaveMode.None) { projectContext.PackageExtractionContext.PackageSaveMode = EffectivePackageSaveMode; } using (var cacheContext = new SourceCacheContext()) { cacheContext.NoCache = NoCache; cacheContext.DirectDownload = DirectDownload; var packageSourceMapping = PackageSourceMapping.GetPackageSourceMapping(Settings); var downloadContext = new PackageDownloadContext(cacheContext, packagesFolderPath, DirectDownload, packageSourceMapping) { ClientPolicyContext = clientPolicyContext }; var result = await PackageRestoreManager.RestoreMissingPackagesAsync( packageRestoreContext, projectContext, downloadContext); if (downloadContext.DirectDownload) { GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext); } IReadOnlyList <IRestoreLogMessage> errors = collectorLogger.Errors.Concat(ProcessFailedEventsIntoRestoreLogs(failedEvents)).ToList(); var restoreSummaries = new List <RestoreSummary>() { new RestoreSummary( result.Restored, "packages.config projects", Settings.GetConfigFilePaths().ToList().AsReadOnly(), packageSources.Select(x => x.Source).ToList().AsReadOnly(), installCount, errors) }; if (result.Restored) { ValidatePackagesConfigLockFiles( packageRestoreInputs.PackagesConfigFiles, packageRestoreInputs.ProjectReferenceLookup.Projects, packagesFolderPath, restoreSummaries); } return(restoreSummaries); } }
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() )); } }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { base.Initialize(); Styles.Initialize(); // *** // VsNuGetDiagnostics.Initialize( // ServiceLocator.GetInstance<IDebugConsoleController>()); // Add our command handlers for menu (commands must exist in the .vsct file) AddMenuCommandHandlers(); // IMPORTANT: Do NOT do anything that can lead to a call to ServiceLocator.GetGlobalService(). // Doing so is illegal and may cause VS to stop responding. _dte = (DTE)GetService(typeof(SDTE)); Debug.Assert(_dte != null); _dteEvents = _dte.Events.DTEEvents; _dteEvents.OnBeginShutdown += OnBeginShutDown; // set default credential provider for the HttpClient var webProxy = (IVsWebProxy)GetService(typeof(SVsWebProxy)); Debug.Assert(webProxy != null); if (SolutionManager != null) { SolutionManager.SolutionOpened += (obj, ev) => { _nugetSettings = new NuGetSettings(); LoadNuGetSettings(); }; } // when NuGet loads, if the current solution has package // restore mode enabled, we make sure every thing is set up correctly. // For example, projects which were added outside of VS need to have // the <Import> element added. if (PackageRestoreManager.IsCurrentSolutionEnabledForRestore) { if (VSVersionHelper.IsVisualStudio2013) { // Run on a background thread in VS2013 to avoid CPS hangs. The modal loading dialog will block // until this completes. ThreadPool.QueueUserWorkItem(new WaitCallback((obj) => PackageRestoreManager.EnableCurrentSolutionForRestore(fromActivation: false))); } else { PackageRestoreManager.EnableCurrentSolutionForRestore(fromActivation: false); } } _outputConsoleLogger = new OutputConsoleLogger(this); _uiProjectContext = new NuGetUIProjectContext( _outputConsoleLogger, SourceControlManagerProvider, CommonOperations); /* **** * // when NuGet loads, if the current solution has some package * // folders marked for deletion (because a previous uninstalltion didn't succeed), * // delete them now. * if (SolutionManager.IsSolutionOpen) * { * DeleteOnRestart.DeleteMarkedPackageDirectories(); * } */ // NOTE: Don't use the exported IPackageRestoreManager for OnBuildPackageRestorer. Exported IPackageRestoreManager also uses 'PackageRestoreManager' // but, overrides RestoreMissingPackages to catch the exceptions. OnBuildPackageRestorer needs to catch the exception by itself to populate error list window // Exported IPackageRestoreManager is used by UI manual restore, Powershell manual restore and by VS extensibility package restore // var packageRestoreManagerForOnBuildPackageRestorer = new PackageRestoreManager(SourceRepositoryProvider, Settings, SolutionManager); OnBuildPackageRestorer = new OnBuildPackageRestorer(SolutionManager, PackageRestoreManager, this); var vsSourceControlTracker = VSSourceControlTracker; LoadNuGetSettings(); }