public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (String.IsNullOrEmpty(packageId)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId")); } PumpingJTF.Run(async delegate { NuGetPackageManager packageManager = new NuGetPackageManager( _sourceRepositoryProvider, _settings, _solutionManager, _deleteOnRestartManager); UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false); VSAPIProjectContext projectContext = new VSAPIProjectContext(); // find the project NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext); // uninstall the package await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None); }); }
public async Task Do(string package, string rootPath) { if (rootPath == null) { rootPath = Directory.GetCurrentDirectory(); } var providers = new List <Lazy <INuGetResourceProvider> >(); providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support var settings = Settings.LoadDefaultSettings(rootPath, null, new MachineWideSettings()); var project = new ProjectBazel(rootPath, null, false); var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers); var solutionManager = new BazelSolutionManager(project, rootPath); var deleteManager = new DeleteOnRestart(); var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, solutionManager, deleteManager) { PackagesFolderNuGetProject = project, }; var projectContext = new ProjectContext(); var uninstallContext = new UninstallationContext(true, true); await packageManager.UninstallPackageAsync(packageManager.PackagesFolderNuGetProject, package, uninstallContext, projectContext, CancellationToken.None); }
private static void CheckIfPackageCanBeUninstalled(PackageIdentity packageIdentity, IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependenciesDict, IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependentsDict, UninstallationContext uninstallationContext, HashSet<PackageIdentity> packagesMarkedForUninstall) { HashSet<PackageIdentity> dependents; if (dependentsDict.TryGetValue(packageIdentity, out dependents) && dependents != null) { if (!uninstallationContext.ForceRemove) { var unMarkedDependents = dependents.Where(d => !packagesMarkedForUninstall.Contains(d)).ToList(); if (unMarkedDependents.Count > 0) { throw CreatePackageHasDependentsException(packageIdentity, unMarkedDependents); } } } HashSet<PackageIdentity> dependencies; if (uninstallationContext.RemoveDependencies && dependenciesDict.TryGetValue(packageIdentity, out dependencies) && dependencies != null) { foreach(var dependency in dependencies) { CheckIfPackageCanBeUninstalled(dependency, dependenciesDict, dependentsDict, uninstallationContext, packagesMarkedForUninstall); } } }
/// <summary> /// Install package by Identity /// </summary> /// <param name="project"></param> /// <param name="identity"></param> /// <param name="resolutionContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <param name="isForce"></param> /// <param name="uninstallContext"></param> /// <returns></returns> protected async Task InstallPackageByIdentityAsync(NuGetProject project, PackageIdentity identity, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview, bool isForce = false, UninstallationContext uninstallContext = null) { List<NuGetProjectAction> actions = new List<NuGetProjectAction>(); // For Install-Package -Force if (isForce) { PackageReference installedReference = project.GetInstalledPackagesAsync(CancellationToken.None).Result.Where(p => StringComparer.OrdinalIgnoreCase.Equals(identity.Id, p.PackageIdentity.Id)).FirstOrDefault(); if (installedReference != null) { actions.AddRange(await PackageManager.PreviewUninstallPackageAsync(project, installedReference.PackageIdentity, uninstallContext, projectContext, CancellationToken.None)); } NuGetProjectAction installAction = NuGetProjectAction.CreateInstallProjectAction(identity, ActiveSourceRepository); actions.Add(installAction); } else { actions.AddRange(await PackageManager.PreviewInstallPackageAsync(project, identity, resolutionContext, projectContext, ActiveSourceRepository, null, CancellationToken.None)); } if (isPreview) { PreviewNuGetPackageActions(actions); } else { await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None); } }
public static async Task UninstallPackage(string packageId, string version, ILogger logger = null) { if (logger == null) { logger = new ConsoleNuGetLogger(IoC.Get <IConsole>()); } PackageIdentity identity = new PackageIdentity(packageId, new NuGet.Versioning.NuGetVersion(version)); List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >(); providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support var settings = NuGet.Configuration.Settings.LoadDefaultSettings(Platform.ReposDirectory, null, new MachineWideSettings(), false, true); ISourceRepositoryProvider sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers); // See part 2 using (var installedPackageCache = GetCache()) { var project = new AvalonStudioExtensionsFolderProject(GetFramework(), installedPackageCache, Platform.ReposDirectory); var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, new SolutionManager(), new DeleteOnRestartManager()) { PackagesFolderNuGetProject = project, }; INuGetProjectContext projectContext = new ProjectContext(logger); var uninstallationContext = new UninstallationContext(true, true); await packageManager.UninstallPackageAsync(project, packageId, uninstallationContext, projectContext, CancellationToken.None); } }
public void UninstallPackage(Project project, string packageId, bool removeDependencies) { const string eventName = nameof(IVsPackageUninstaller) + "." + nameof(UninstallPackage); using var _ = NuGetETW.ExtensibilityEventSource.StartStopEvent(eventName, new { // Can't add project information, since it's a COM object that this method might be called on a background thread PackageId = packageId, RemoveDependencies = removeDependencies }); if (project == null) { throw new ArgumentNullException(nameof(project)); } if (string.IsNullOrEmpty(packageId)) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageId))); } try { PumpingJTF.Run(async delegate { NuGetPackageManager packageManager = new NuGetPackageManager( _sourceRepositoryProvider, _settings, _solutionManager, _deleteOnRestartManager, _restoreProgressReporter); var uninstallContext = new UninstallationContext(removeDependencies, forceRemove: false); var projectContext = new VSAPIProjectContext { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; // find the project NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext); // uninstall the package await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None); }); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsPackageUninstaller).FullName); throw; } }
public static ICollection<PackageIdentity> GetPackagesToBeUninstalled(PackageIdentity packageIdentity, IEnumerable<PackageDependencyInfo> dependencyInfoEnumerable, IEnumerable<PackageIdentity> installedPackages, UninstallationContext uninstallationContext) { IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependenciesDict; var dependentsDict = GetPackageDependents(dependencyInfoEnumerable, installedPackages, out dependenciesDict); HashSet<PackageIdentity> packagesMarkedForUninstall = MarkPackagesToBeUninstalled(packageIdentity, dependenciesDict, dependentsDict, uninstallationContext); CheckIfPackageCanBeUninstalled(packageIdentity, dependenciesDict, dependentsDict, uninstallationContext, packagesMarkedForUninstall); return packagesMarkedForUninstall; }
public async ValueTask <IReadOnlyList <ProjectAction> > GetUninstallActionsAsync( string projectId, PackageIdentity packageIdentity, bool removeDependencies, bool forceRemove, CancellationToken cancellationToken) { Assumes.NotNullOrEmpty(projectId); Assumes.NotNull(packageIdentity); Assumes.False(packageIdentity.HasVersion); Assumes.NotNull(_state.SourceCacheContext); Assumes.NotNull(_state.ResolvedActions); Assumes.Null(_state.PackageIdentity); cancellationToken.ThrowIfCancellationRequested(); return(await CatchAndRethrowExceptionAsync(async() => { INuGetProjectContext projectContext = await ServiceLocator.GetInstanceAsync <INuGetProjectContext>(); (bool success, NuGetProject? project) = await TryGetNuGetProjectMatchingProjectIdAsync(projectId); Assumes.True(success); Assumes.NotNull(project); var projectActions = new List <ProjectAction>(); var uninstallationContext = new UninstallationContext(removeDependencies, forceRemove); NuGetPackageManager packageManager = await _sharedState.PackageManager.GetValueAsync(cancellationToken); IEnumerable <NuGetProjectAction> actions = await packageManager.PreviewUninstallPackageAsync( project, packageIdentity.Id, uninstallationContext, projectContext, cancellationToken); foreach (NuGetProjectAction action in actions) { var resolvedAction = new ResolvedAction(project, action); var projectAction = new ProjectAction( CreateProjectActionId(), projectId, action.PackageIdentity, action.NuGetProjectActionType, implicitActions: null); _state.ResolvedActions[projectAction.Id] = resolvedAction; projectActions.Add(projectAction); } return projectActions; })); }
public async ValueTask <IReadOnlyList <ProjectAction> > GetUninstallActionsAsync( IReadOnlyCollection <string> projectIds, PackageIdentity packageIdentity, bool removeDependencies, bool forceRemove, CancellationToken cancellationToken) { Assumes.NotNullOrEmpty(projectIds); Assumes.NotNull(packageIdentity); Assumes.False(packageIdentity.HasVersion); Assumes.NotNull(_state.SourceCacheContext); Assumes.Null(_state.PackageIdentity); Assumes.True(_state.ResolvedActions.Count == 0); cancellationToken.ThrowIfCancellationRequested(); return(await CatchAndRethrowExceptionAsync(async() => { INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>(); IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken); var projectActions = new List <ProjectAction>(); var uninstallationContext = new UninstallationContext(removeDependencies, forceRemove); NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken); IEnumerable <NuGetProjectAction> projectsWithActions = await packageManager.PreviewProjectsUninstallPackageAsync( projects, packageIdentity.Id, uninstallationContext, projectContext, cancellationToken); foreach (NuGetProjectAction projectWithActions in projectsWithActions) { var resolvedAction = new ResolvedAction(projectWithActions.Project, projectWithActions); var projectAction = new ProjectAction( CreateProjectActionId(), projectWithActions.Project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId), projectWithActions.PackageIdentity, projectWithActions.NuGetProjectActionType, implicitActions: null); _state.ResolvedActions[projectAction.Id] = resolvedAction; projectActions.Add(projectAction); } return projectActions; })); }
/// <summary> /// Return the resolve package actions /// </summary> protected async Task <IEnumerable <Tuple <NuGetProject, NuGetProjectAction> > > GetActions( INuGetUI uiService, IEnumerable <NuGetProject> targets, UserAction userAction, bool removeDependencies, bool forceRemove, ResolutionContext resolutionContext, INuGetProjectContext projectContext, CancellationToken token) { List <Tuple <NuGetProject, NuGetProjectAction> > results = new List <Tuple <NuGetProject, NuGetProjectAction> >(); Debug.Assert(userAction.PackageId != null, "Package id can never be null in a User action"); if (userAction.Action == NuGetProjectActionType.Install) { Debug.Assert(userAction.PackageIdentity != null, "Package identity cannot be null when installing a package"); foreach (var target in targets) { IEnumerable <NuGetProjectAction> actions; actions = await _packageManager.PreviewInstallPackageAsync(target, userAction.PackageIdentity, resolutionContext, projectContext, uiService.ActiveSource, null, token); results.AddRange(actions.Select(a => new Tuple <NuGetProject, NuGetProjectAction>(target, a))); } } else { UninstallationContext uninstallationContext = new UninstallationContext( removeDependencies: removeDependencies, forceRemove: forceRemove); foreach (var target in targets) { IEnumerable <NuGetProjectAction> actions; if (userAction.PackageIdentity != null) { actions = await _packageManager.PreviewUninstallPackageAsync(target, userAction.PackageIdentity, uninstallationContext, projectContext, token); } else { actions = await _packageManager.PreviewUninstallPackageAsync(target, userAction.PackageId, uninstallationContext, projectContext, token); } results.AddRange(actions.Select(a => new Tuple <NuGetProject, NuGetProjectAction>(target, a))); } } return(results); }
public Task <IEnumerable <NuGetProjectAction> > PreviewUninstallPackageAsync( NuGetProject nuGetProject, string packageId, UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token) { return(packageManager.PreviewUninstallPackageAsync( nuGetProject, packageId, uninstallationContext, nuGetProjectContext, token )); }
/// <summary> /// Return the resolve package actions /// </summary> private async Task <IReadOnlyList <ResolvedAction> > GetActionsAsync( INuGetUI uiService, IEnumerable <NuGetProject> targets, UserAction userAction, bool removeDependencies, bool forceRemove, ResolutionContext resolutionContext, INuGetProjectContext projectContext, CancellationToken token) { var results = new List <ResolvedAction>(); Debug.Assert(userAction.PackageId != null, "Package id can never be null in a User action"); if (userAction.Action == NuGetProjectActionType.Install) { foreach (var target in targets) { var actions = await _packageManager.PreviewInstallPackageAsync( target, new PackageIdentity(userAction.PackageId, userAction.Version), resolutionContext, projectContext, uiService.ActiveSources, null, token); results.AddRange(actions.Select(a => new ResolvedAction(target, a))); } } else { var uninstallationContext = new UninstallationContext( removeDependencies: removeDependencies, forceRemove: forceRemove); foreach (var target in targets) { IEnumerable <NuGetProjectAction> actions; actions = await _packageManager.PreviewUninstallPackageAsync( target, userAction.PackageId, uninstallationContext, projectContext, token); results.AddRange(actions.Select(a => new ResolvedAction(target, a))); } } return(results); }
public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (string.IsNullOrEmpty(packageId)) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageId))); } try { PumpingJTF.Run(async delegate { NuGetPackageManager packageManager = new NuGetPackageManager( _sourceRepositoryProvider, _settings, _solutionManager, _deleteOnRestartManager); var uninstallContext = new UninstallationContext(removeDependencies, forceRemove: false); var projectContext = new VSAPIProjectContext { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; // find the project NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext); // uninstall the package await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None); }); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsPackageUninstaller).FullName); throw; } }
public Task <IEnumerable <NuGetProjectAction> > PreviewUninstallPackageAsync( NuGetProject nuGetProject, string packageId, UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token) { PreviewUninstallProject = nuGetProject; PreviewUninstallPackageId = packageId; PreviewUninstallContext = uninstallationContext; PreviewUninstallProjectContext = nuGetProjectContext; PreviewUninstallCancellationToken = token; IEnumerable <NuGetProjectAction> actions = UninstallActions.ToArray(); return(Task.FromResult(actions)); }
public static async Task UninstallPackageAsync( this Project project, string packageId, UninstallationContext uninstallContext, CancellationToken token) { var message = new UninstallPackageParams { ProjectFileName = project.FileName, PackageId = packageId, Force = uninstallContext.ForceRemove, RemoveDependencies = uninstallContext.RemoveDependencies }; await JsonRpcProvider.Rpc.InvokeWithCancellationAsync( Methods.ProjectUninstallPackage, new [] { message }, token); }
public async Task <IEnumerable <NuGetProjectAction> > PreviewUninstallPackageAsync( CancellationToken token) { solutionManager = project.GetSolutionManager(); nugetProject = project.CreateNuGetProject(solutionManager); packageManager = new MonoDevelopNuGetPackageManager(solutionManager); uninstallationContext = new UninstallationContext(message.RemoveDependencies, message.Force); projectContext = new ConsoleHostNuGetProjectContext(solutionManager.Settings); return(await packageManager.PreviewUninstallPackageAsync( nugetProject, message.PackageId, uninstallationContext, projectContext, token ).ConfigureAwait(false)); }
public async Task UninstallAsync(IEnumerable <NuGetProject> projects, IEnumerable <string> packages, bool removeDependencies, bool forceRemove, bool shouldThrow, CancellationToken token) { MyProjectContext projectContext = new MyProjectContext(FileConflictAction.OverwriteAll) { ActionType = NuGetActionType.Uninstall, PackageExtractionContext = _packageExtractionContext }; // sort packages // packages = SortPackagesWhenUninstallAsync(projects, packages); foreach (string packageId in packages) { var uninstallationContext = new UninstallationContext(removeDependencies, forceRemove); IReadOnlyList <ResolvedAction> actions = await GetActionsForUninstallAsync( uninstallationContext : uninstallationContext, targets : projects, packageId : packageId, projectContext : projectContext, token : token); if (actions.Count != 0) { PackageUninstalling?.Invoke(packageId); try { await ExecuteActionsAsync(actions, null, projectContext, NullSourceCacheContext.Instance, token); } catch (Exception ex) { Debug.WriteLine(ex); if (shouldThrow) { throw; } } finally { PackageUninstalled?.Invoke(packageId); } } } }
public async Task UninstallAsync(string packageId) { UninstallationContext uninstallationContext; PackageReference installedPackage; IEnumerable <PackageReference> installedPackageSet; uninstallationContext = new UninstallationContext(); installedPackageSet = await _project.GetInstalledPackagesAsync(new CancellationToken()); installedPackage = installedPackageSet.FirstOrDefault(packageReference => packageReference.PackageIdentity.Id == packageId); if (installedPackage != null) { await _packageManager.UninstallPackageAsync(_project, packageId, uninstallationContext, _projectContext, CancellationToken.None); } this.OnInstalledPackagesChanged(); }
public static async Task <IEnumerable <PackageActionInfo> > PreviewUninstallPackageAsync( this Project project, string packageId, UninstallationContext uninstallContext, CancellationToken token) { var message = new UninstallPackageParams { ProjectFileName = project.FileName, PackageId = packageId, Force = uninstallContext.ForceRemove, RemoveDependencies = uninstallContext.RemoveDependencies }; var list = await JsonRpcProvider.Rpc.InvokeWithParameterObjectAsync <PackageActionList> ( Methods.ProjectPreviewUninstallPackage, message, token); return(list.Actions); }
protected async Task UninstallPackageByIdAsync( NuGetProject project, string packageId, UninstallationContext uninstallContext, INuGetProjectContext projectContext, bool isPreview) { ConsoleHostNuGetPackageManager packageManager = ConsoleHost.CreatePackageManager(); IEnumerable <NuGetProjectAction> actions = await packageManager.PreviewUninstallPackageAsync(project, packageId, uninstallContext, projectContext, ConsoleHost.Token); if (isPreview) { PreviewNuGetPackageActions(actions); } else { await packageManager.ExecuteNuGetProjectActionsAsync(project, actions, projectContext, ConsoleHost.Token); } }
public async Task UninstallPluginAsync( INuGetProjectContext projectContext, bool removeDependencies = true, bool forceRemove = false, CancellationToken cancellationToken = default) { var uninstallContext = new UninstallationContext(removeDependencies, forceRemove); await CreatePackageManager().UninstallPackageAsync( this, Plugin.Id, uninstallContext, projectContext, cancellationToken); if (_pluginHomeDirPath.Exists()) { _pluginHomeDirPath.Delete(); } }
public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (String.IsNullOrEmpty(packageId)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId")); } PumpingJTF.Run(async delegate { NuGetPackageManager packageManager = new NuGetPackageManager( _sourceRepositoryProvider, _settings, _solutionManager, _deleteOnRestartManager); UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false); VSAPIProjectContext projectContext = new VSAPIProjectContext(); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); var logger = new LoggerAdapter(projectContext); projectContext.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, logger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(_settings, logger)); // find the project NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext); // uninstall the package await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None); }); }
public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (String.IsNullOrEmpty(packageId)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId")); } NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager); UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false); VSAPIProjectContext projectContext = new VSAPIProjectContext(); // find the project NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext); // uninstall the package PackageManagementHelpers.RunSync(async () => await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None)); }
protected async Task <IReadOnlyList <ResolvedAction> > GetActionsForUninstallAsync(IEnumerable <NuGetProject> targets, string packageId, INuGetProjectContext projectContext, UninstallationContext uninstallationContext, CancellationToken token) { List <ResolvedAction> results = new List <ResolvedAction>(); foreach (NuGetProject target in targets) { IEnumerable <PackageReference> oldInstalledPackages = await target.GetInstalledPackagesAsync(token); if (oldInstalledPackages != null && oldInstalledPackages.Any(t => t.PackageIdentity.Id.Equals(packageId, StringComparison.InvariantCultureIgnoreCase))) { try { var actions = await _packageManager.PreviewUninstallPackageAsync(target, packageId, uninstallationContext, projectContext, token); results.AddRange(actions.Select(a => new ResolvedAction(target, a))); } catch (Exception ex) { Debug.WriteLine(ex); throw; } } } return(results); }
/// <summary> /// Install package by Id /// </summary> /// <param name="project"></param> /// <param name="packageId"></param> /// <param name="resolutionContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <param name="isForce"></param> /// <param name="uninstallContext"></param> /// <returns></returns> protected async Task InstallPackageByIdAsync(NuGetProject project, string packageId, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview, bool isForce = false, UninstallationContext uninstallContext = null) { List <NuGetProjectAction> actions = new List <NuGetProjectAction>(); // For Install-Package -Force if (isForce) { PackageReference installedReference = project.GetInstalledPackagesAsync(CancellationToken.None).Result.Where(p => StringComparer.OrdinalIgnoreCase.Equals(packageId, p.PackageIdentity.Id)).FirstOrDefault(); if (installedReference != null) { actions.AddRange(await PackageManager.PreviewUninstallPackageAsync(project, packageId, uninstallContext, projectContext, CancellationToken.None)); } NuGetVersion nVersion = PowerShellCmdletsUtility.GetLastestVersionForPackageId(ActiveSourceRepository, packageId, project, resolutionContext.IncludePrerelease); if (nVersion != null) { PackageIdentity identityToInstall = new PackageIdentity(packageId, nVersion); NuGetProjectAction installAction = NuGetProjectAction.CreateInstallProjectAction(identityToInstall, ActiveSourceRepository); actions.Add(installAction); } } else { actions.AddRange(await PackageManager.PreviewInstallPackageAsync(project, packageId, resolutionContext, projectContext, ActiveSourceRepository, null, CancellationToken.None)); } if (isPreview) { PreviewNuGetPackageActions(actions); } else { await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None); } }
/// <summary> /// Uninstall package by Id /// </summary> /// <param name="project"></param> /// <param name="packageId"></param> /// <param name="uninstallContext"></param> /// <param name="isPreview"></param> protected async Task UninstallPackageByIdAsync(Project project, string packageId, UninstallationContext uninstallContext, bool isPreview) { if (isPreview) { var actions = await project.PreviewUninstallPackageAsync(packageId, uninstallContext, Token); PreviewNuGetPackageActions(actions); } else { await project.UninstallPackageAsync(packageId, uninstallContext, CancellationToken.None); } }
/// <summary> /// Uninstall package by Id /// </summary> /// <param name="project"></param> /// <param name="packageId"></param> /// <param name="uninstallContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <returns></returns> protected async Task UninstallPackageByIdAsync(NuGetProject project, string packageId, UninstallationContext uninstallContext, INuGetProjectContext projectContext, bool isPreview) { var actions = await PackageManager.PreviewUninstallPackageAsync(project, packageId, uninstallContext, projectContext, CancellationToken.None); if (isPreview) { PreviewNuGetPackageActions(actions); } else { await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, projectContext, NullSourceCacheContext.Instance, CancellationToken.None); // Refresh Manager UI if needed RefreshUI(actions); } }
/// <summary> /// Gives the preview as a list of NuGetProjectActions that will be performed to uninstall <param name="packageId"></param> into <param name="nuGetProject"></param> /// <param name="uninstallationContext"></param> and <param name="nuGetProjectContext"></param> are used in the process /// </summary> public async Task<IEnumerable<NuGetProjectAction>> PreviewUninstallPackageAsync(NuGetProject nuGetProject, PackageIdentity packageIdentity, UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token) { if (nuGetProject == null) { throw new ArgumentNullException("nuGetProject"); } if (packageIdentity == null) { throw new ArgumentNullException("packageIdentity"); } if (uninstallationContext == null) { throw new ArgumentNullException("uninstallationContext"); } if (nuGetProjectContext == null) { throw new ArgumentNullException("nuGetProjectContext"); } // Step-1: Get the packageIdentity corresponding to packageId and check if it exists to be uninstalled var installedPackages = await nuGetProject.GetInstalledPackagesAsync(token); PackageReference packageReference = installedPackages .Where(pr => pr.PackageIdentity.Equals(packageIdentity)).FirstOrDefault(); if (packageReference == null || packageReference.PackageIdentity == null) { throw new ArgumentException(String.Format(Strings.PackageToBeUninstalledCouldNotBeFound, packageIdentity.Id, nuGetProject.GetMetadata<string>(NuGetProjectMetadataKeys.Name))); } return await PreviewUninstallPackageAsyncPrivate(nuGetProject, packageReference, uninstallationContext, nuGetProjectContext, token); }
private async Task<IEnumerable<NuGetProjectAction>> PreviewUninstallPackageAsyncPrivate(NuGetProject nuGetProject, PackageReference packageReference, UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token) { if(SolutionManager == null) { throw new InvalidOperationException(Strings.SolutionManagerNotAvailableForUninstall); } if (nuGetProject is ProjectManagement.Projects.ProjectKNuGetProjectBase) { var action = NuGetProjectAction.CreateUninstallProjectAction(packageReference.PackageIdentity); return new NuGetProjectAction[] { action }; } // Step-1 : Get the metadata resources from "packages" folder or custom repository path var packageIdentity = packageReference.PackageIdentity; var packageReferenceTargetFramework = packageReference.TargetFramework; nuGetProjectContext.Log(MessageLevel.Info, Strings.AttemptingToGatherDependencyInfo, packageIdentity, packageReferenceTargetFramework); // TODO: IncludePrerelease is a big question mark var installedPackageIdentities = (await nuGetProject.GetInstalledPackagesAsync(token)).Select(pr => pr.PackageIdentity); var dependencyInfoFromPackagesFolder = await GetDependencyInfoFromPackagesFolder(installedPackageIdentities, packageReferenceTargetFramework, includePrerelease: true); nuGetProjectContext.Log(MessageLevel.Info, Strings.ResolvingActionsToUninstallPackage, packageIdentity); // Step-2 : Determine if the package can be uninstalled based on the metadata resources var packagesToBeUninstalled = UninstallResolver.GetPackagesToBeUninstalled(packageIdentity, dependencyInfoFromPackagesFolder, installedPackageIdentities, uninstallationContext); var nuGetProjectActions = packagesToBeUninstalled.Select(p => NuGetProjectAction.CreateUninstallProjectAction(p)); nuGetProjectContext.Log(MessageLevel.Info, Strings.ResolvedActionsToUninstallPackage, packageIdentity); return nuGetProjectActions; }
/// <summary> /// Uninstall package by Id /// </summary> /// <param name="project"></param> /// <param name="packageId"></param> /// <param name="uninstallContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <returns></returns> protected async Task UninstallPackageByIdAsync(NuGetProject project, string packageId, UninstallationContext uninstallContext, INuGetProjectContext projectContext, bool isPreview) { if (isPreview) { IEnumerable <NuGetProjectAction> actions = await PackageManager.PreviewUninstallPackageAsync(project, packageId, uninstallContext, projectContext, CancellationToken.None); PreviewNuGetPackageActions(actions); } else { await PackageManager.UninstallPackageAsync(project, packageId, uninstallContext, projectContext, CancellationToken.None); } }
public async Task UninstallPackageAsync(NuGetProject nuGetProject, string packageId, UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token) { // Step-1 : Call PreviewUninstallPackagesAsync to get all the nuGetProjectActions var nuGetProjectActions = await PreviewUninstallPackageAsync(nuGetProject, packageId, uninstallationContext, nuGetProjectContext, token); // Step-2 : Execute all the nuGetProjectActions await ExecuteNuGetProjectActionsAsync(nuGetProject, nuGetProjectActions, nuGetProjectContext, token); }
private static async Task MainAsync(string[] args) { CustomNuGetLogger logger = new CustomNuGetLogger(); DefaultFrameworkNameProvider frameworkNameProvider = new DefaultFrameworkNameProvider(); string testAppFrameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true) .OfType <System.Runtime.Versioning.TargetFrameworkAttribute>() .Select(x => x.FrameworkName) .FirstOrDefault(); //string folderName = "netstandard1.1"; //NuGetFramework currentFramework = folderName == null // ? NuGetFramework.AnyFramework // : NuGetFramework.ParseFolder(folderName, frameworkNameProvider); NuGetFramework currentFramework = testAppFrameworkName == null ? NuGetFramework.AnyFramework : NuGetFramework.ParseFrameworkName(testAppFrameworkName, frameworkNameProvider); List <Lazy <INuGetResourceProvider> > resourceProviders = new List <Lazy <INuGetResourceProvider> >(); resourceProviders.AddRange(Repository.Provider.GetCoreV3()); PackageSource packageSource = new PackageSource("https://api.nuget.org/v3/index.json"); SourceRepository sourceRepository = new SourceRepository(packageSource, resourceProviders); //Console.WriteLine("Getting metadata resource..."); //PackageMetadataResource metadataResource = await sourceRepository.GetResourceAsync<PackageMetadataResource>(); //Console.WriteLine("Getting search resource..."); //PackageSearchResource searchResource = await sourceRepository.GetResourceAsync<PackageSearchResource>(); //Console.WriteLine("Getting auto complete resource..."); //AutoCompleteResource autoCompleteResource = await sourceRepository.GetResourceAsync<AutoCompleteResource>(); //Console.WriteLine("Getting dependency info resource..."); //DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync<DependencyInfoResource>(); //Console.WriteLine("Getting download resource..."); //DownloadResource downloadResource = await sourceRepository.GetResourceAsync<DownloadResource>(); // //Console.WriteLine(); //Console.WriteLine("-----------------------------------------------------------------------------"); //Console.WriteLine(); //Console.WriteLine("Getting metadata..."); //IEnumerable<IPackageSearchMetadata> metadata = await metadataResource.GetMetadataAsync("Newtonsoft.Json", false, false, logger, CancellationToken.None); //metadata.Dump(); // //Console.WriteLine(); //Console.WriteLine("-----------------------------------------------------------------------------"); //Console.WriteLine(); //Console.WriteLine("Searching metadata..."); //SearchFilter searchFilter = new SearchFilter(false, null); //metadata = await searchResource.SearchAsync("Newtonsoft.Json", searchFilter, 0, 10, logger, CancellationToken.None); //metadata.Dump(); // //Console.WriteLine(); //Console.WriteLine("-----------------------------------------------------------------------------"); //Console.WriteLine(); //Console.WriteLine("Resolving dependencies..."); //IEnumerable<RemoteSourceDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages("Newtonsoft.Json", logger, CancellationToken.None); //dependencyInfo.Dump(); // //Console.WriteLine(); //Console.WriteLine("-----------------------------------------------------------------------------"); //Console.WriteLine(); //Console.WriteLine("Resolving for target framework {0}...", currentFramework); //IEnumerable<SourcePackageDependencyInfo> dependencyInfo2 = await dependencyInfoResource.ResolvePackages("Newtonsoft.Json", currentFramework, logger, CancellationToken.None); //dependencyInfo2.Dump(); Console.WriteLine(); Console.WriteLine("-----------------------------------------------------------------------------"); Console.WriteLine(); Console.WriteLine("Installing for target framework {0}...", currentFramework); string rootPath = "ProjectRoot"; string targetPath = Path.Combine(rootPath, "Packages"); if (!Directory.Exists(targetPath)) { Directory.CreateDirectory(targetPath); } ISettings settings = new CustomNuGetSettings(rootPath); PackageSourceProvider sourceProvider = new PackageSourceProvider(settings); SourceRepositoryProvider repoProvider = new SourceRepositoryProvider(sourceProvider, resourceProviders); CustomNuGetProject project = new CustomNuGetProject(targetPath, currentFramework); CustomSolutionManager solutionManager = new CustomSolutionManager(rootPath, project); NuGetPackageManager manager = new NuGetPackageManager(repoProvider, settings, solutionManager, new CustomDeleteManager()); bool allowPrereleaseVersions = true; bool allowUnlisted = false; ResolutionContext resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, allowPrereleaseVersions, allowUnlisted, VersionConstraints.ExactMajor); UninstallationContext uninstallContext = new UninstallationContext( true, false); INuGetProjectContext projectContext = new CustomNuGetProjectContext(); List <SourceRepository> sourceRepositories = new List <SourceRepository>(); sourceRepositories.Add(sourceRepository); Console.WriteLine("Preview for package install..."); IEnumerable <NuGetProjectAction> installActions = await manager.PreviewInstallPackageAsync( project, new PackageIdentity("Newtonsoft.Json", new NuGetVersion(10, 0, 2)), resolutionContext, projectContext, sourceRepositories, Enumerable.Empty <SourceRepository>(), CancellationToken.None); Console.WriteLine("Execute package install..."); await manager.ExecuteNuGetProjectActionsAsync( project, installActions, projectContext, CancellationToken.None); Console.WriteLine("Preview for package update..."); IEnumerable <NuGetProjectAction> updateActions = await manager.PreviewUpdatePackagesAsync( new PackageIdentity("Newtonsoft.Json", new NuGetVersion(10, 0, 3)), new[] { project }, resolutionContext, projectContext, sourceRepositories, Enumerable.Empty <SourceRepository>(), CancellationToken.None); Console.WriteLine("Execute package update..."); await manager.ExecuteNuGetProjectActionsAsync( project, updateActions, projectContext, CancellationToken.None); Console.WriteLine("Preview for package uninstall..."); IEnumerable <NuGetProjectAction> uninstallActions = await manager.PreviewUninstallPackageAsync( project, new PackageIdentity("Newtonsoft.Json", new NuGetVersion(10, 0, 3)), uninstallContext, projectContext, CancellationToken.None); Console.WriteLine("Execute package uninstall..."); await manager.ExecuteNuGetProjectActionsAsync( project, uninstallActions, projectContext, CancellationToken.None); Console.WriteLine(); Console.WriteLine(); Console.WriteLine("Done"); }
/// <summary> /// Install package by Id /// </summary> /// <param name="project"></param> /// <param name="packageId"></param> /// <param name="resolutionContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <param name="isForce"></param> /// <param name="uninstallContext"></param> /// <returns></returns> protected async Task InstallPackageByIdAsync(NuGetProject project, string packageId, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview, bool isForce = false, UninstallationContext uninstallContext = null) { List<NuGetProjectAction> actions = new List<NuGetProjectAction>(); // For Install-Package -Force if (isForce) { PackageReference installedReference = project.GetInstalledPackagesAsync(CancellationToken.None).Result.Where(p => StringComparer.OrdinalIgnoreCase.Equals(packageId, p.PackageIdentity.Id)).FirstOrDefault(); if (installedReference != null) { actions.AddRange(await PackageManager.PreviewUninstallPackageAsync(project, packageId, uninstallContext, projectContext, CancellationToken.None)); } NuGetVersion nVersion = PowerShellCmdletsUtility.GetLastestVersionForPackageId(ActiveSourceRepository, packageId, project, resolutionContext.IncludePrerelease); if (nVersion != null) { PackageIdentity identityToInstall = new PackageIdentity(packageId, nVersion); NuGetProjectAction installAction = NuGetProjectAction.CreateInstallProjectAction(identityToInstall, ActiveSourceRepository); actions.Add(installAction); } } else { actions.AddRange(await PackageManager.PreviewInstallPackageAsync(project, packageId, resolutionContext, projectContext, ActiveSourceRepository, null, CancellationToken.None)); } if (isPreview) { PreviewNuGetPackageActions(actions); } else { await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None); } }
public async Task TestPacManUninstallPackageOnMultipleProjects() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packagePathResolver = new PackagePathResolver(packagesFolderPath); var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = NoDependencyLibPackages[0]; // Act await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); var projectBInstalled = (await projectB.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, projectAInstalled.Count); Assert.Equal(1, projectBInstalled.Count); // Main Act var uninstallationContext = new UninstallationContext(); await nuGetPackageManager.UninstallPackageAsync(projectA, packageIdentity.Id, uninstallationContext, testNuGetProjectContext, token); // Assert projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); projectBInstalled = (await projectB.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, projectAInstalled.Count); Assert.Equal(1, projectBInstalled.Count); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity))); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory); }
private static HashSet<PackageIdentity> MarkPackagesToBeUninstalled(PackageIdentity packageIdentity, IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependenciesDict, IDictionary<PackageIdentity, HashSet<PackageIdentity>> dependentsDict, UninstallationContext uninstallationContext) { Queue<PackageIdentity> breathFirstSearchQueue = new Queue<PackageIdentity>(); List<PackageIdentity> markedPackages = new List<PackageIdentity>(); breathFirstSearchQueue.Enqueue(packageIdentity); while(breathFirstSearchQueue.Count > 0) { PackageIdentity headPackage = breathFirstSearchQueue.Dequeue(); markedPackages.Add(headPackage); HashSet<PackageIdentity> dependencies; if(uninstallationContext.RemoveDependencies && dependenciesDict.TryGetValue(headPackage, out dependencies) && dependencies != null) { foreach(var dependency in dependencies) { if (markedPackages.Contains(dependency)) { // Put it back at the end markedPackages.Remove(dependency); markedPackages.Add(dependency); } else { breathFirstSearchQueue.Enqueue(dependency); } } } } return new HashSet<PackageIdentity>(markedPackages, PackageIdentity.Comparer); }
public async Task TestPacManUninstallPackage() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packagePathResolver = new PackagePathResolver(packagesFolderPath); var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder(); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath); var packageIdentity = NoDependencyLibPackages[0]; // Pre-Assert // Check that the packages.config file does not exist Assert.False(File.Exists(randomPackagesConfigPath)); // Check that there are no packages returned by PackagesConfigProject var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, packagesInPackagesConfig.Count); Assert.Equal(0, msBuildNuGetProjectSystem.References.Count); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, packagesInPackagesConfig.Count); Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework); // Main Act var uninstallationContext = new UninstallationContext(); await nuGetPackageManager.UninstallPackageAsync(msBuildNuGetProject, packageIdentity.Id, uninstallationContext, testNuGetProjectContext, token); // Assert // Check that the packages.config file exists after the installation Assert.True(!File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, packagesInPackagesConfig.Count); Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity))); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath); }
public async Task TestPacManUninstallWithRemoveDependenciesWithVDependency() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packagePathResolver = new PackagePathResolver(packagesFolderPath); var projectA = testSolutionManager.AddNewMSBuildProject(); var packageIdentity0 = PackageWithDependents[0]; var packageIdentity1 = PackageWithDependents[1]; var packageIdentity2 = PackageWithDependents[2]; var packageIdentity3 = PackageWithDependents[3]; // Act await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity2, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, projectAInstalled.Count); Assert.Equal(packageIdentity0, projectAInstalled[0].PackageIdentity); Assert.Equal(packageIdentity2, projectAInstalled[1].PackageIdentity); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2))); // Main Act await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity3, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(3, projectAInstalled.Count); Assert.Equal(packageIdentity1, projectAInstalled[0].PackageIdentity); Assert.Equal(packageIdentity2, projectAInstalled[2].PackageIdentity); Assert.Equal(packageIdentity3, projectAInstalled[1].PackageIdentity); Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity1))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity3))); // Main Act Exception exception = null; try { var uninstallationContext = new UninstallationContext(removeDependencies: true); await nuGetPackageManager.UninstallPackageAsync(projectA, packageIdentity2.Id, uninstallationContext, testNuGetProjectContext, token); } catch (InvalidOperationException ex) { exception = ex; } catch (AggregateException ex) { exception = ExceptionUtility.Unwrap(ex); } Assert.NotNull(exception); Assert.True(exception is InvalidOperationException); Assert.Equal("Unable to uninstall 'jQuery.1.6.4' because 'jQuery.UI.Combined.1.11.2' depends on it.", exception.Message); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory); }
public async Task TestPacManPreviewUninstallWithRemoveDependencies() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packagePathResolver = new PackagePathResolver(packagesFolderPath); var projectA = testSolutionManager.AddNewMSBuildProject(); var packageIdentity0 = PackageWithDependents[0]; var packageIdentity1 = PackageWithDependents[1]; var packageIdentity2 = PackageWithDependents[2]; var packageIdentity3 = PackageWithDependents[3]; // Act await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity2, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, projectAInstalled.Count); Assert.Equal(packageIdentity0, projectAInstalled[0].PackageIdentity); Assert.Equal(packageIdentity2, projectAInstalled[1].PackageIdentity); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2))); // Main Act var uninstallationContext = new UninstallationContext(removeDependencies: true); var packageActions = (await nuGetPackageManager.PreviewUninstallPackageAsync(projectA, packageIdentity2.Id, uninstallationContext, testNuGetProjectContext, token)).ToList(); Assert.Equal(2, packageActions.Count); Assert.Equal(packageIdentity2, packageActions[0].PackageIdentity); Assert.Equal(NuGetProjectActionType.Uninstall, packageActions[0].NuGetProjectActionType); Assert.Null(packageActions[0].SourceRepository); Assert.Equal(packageIdentity0, packageActions[1].PackageIdentity); Assert.Equal(NuGetProjectActionType.Uninstall, packageActions[1].NuGetProjectActionType); Assert.Null(packageActions[1].SourceRepository); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory); }
/// <summary> /// Install package by Identity /// </summary> /// <param name="project"></param> /// <param name="identity"></param> /// <param name="resolutionContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <param name="isForce"></param> /// <param name="uninstallContext"></param> /// <returns></returns> protected async Task InstallPackageByIdentityAsync(NuGetProject project, PackageIdentity identity, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview, bool isForce = false, UninstallationContext uninstallContext = null) { List <NuGetProjectAction> actions = new List <NuGetProjectAction>(); // For Install-Package -Force if (isForce) { PackageReference installedReference = project.GetInstalledPackagesAsync(CancellationToken.None).Result.Where(p => StringComparer.OrdinalIgnoreCase.Equals(identity.Id, p.PackageIdentity.Id)).FirstOrDefault(); if (installedReference != null) { actions.AddRange(await PackageManager.PreviewUninstallPackageAsync(project, installedReference.PackageIdentity, uninstallContext, projectContext, CancellationToken.None)); } NuGetProjectAction installAction = NuGetProjectAction.CreateInstallProjectAction(identity, ActiveSourceRepository); actions.Add(installAction); } else { actions.AddRange(await PackageManager.PreviewInstallPackageAsync(project, identity, resolutionContext, projectContext, ActiveSourceRepository, null, CancellationToken.None)); } if (isPreview) { PreviewNuGetPackageActions(actions); } else { await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None); } }
public Task<IEnumerable<NuGetProjectAction>> PreviewUninstallPackageAsync ( NuGetProject nuGetProject, string packageId, UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token) { PreviewUninstallProject = nuGetProject; PreviewUninstallPackageId = packageId; PreviewUninstallContext = uninstallationContext; PreviewUninstallProjectContext = nuGetProjectContext; PreviewUninstallCancellationToken = token; IEnumerable<NuGetProjectAction> actions = UninstallActions.ToArray (); return Task.FromResult (actions); }
public async Task UninstallAsync(PackageIdentity package, IExtensibleProject project, IEnumerable <PackageReference> installedPackageReferences, CancellationToken cancellationToken = default) { List <string> failedEntries = null; ICollection <PackageIdentity> uninstalledPackages; var targetFramework = FrameworkParser.TryParseFrameworkName(project.Framework, _frameworkNameProvider); #if NET5_0_OR_GREATER var reducer = new FrameworkReducer(); var mostSpecific = reducer.ReduceUpwards(project.SupportedPlatforms).FirstOrDefault(); targetFramework = mostSpecific; #endif var projectConfig = _nuGetProjectConfigurationProvider.GetProjectConfig(project); var uninstallationContext = new UninstallationContext(false, false); _nugetLogger.LogInformation($"Uninstall package {package}, Target framework: {targetFramework}"); if (projectConfig is null) { _nugetLogger.LogWarning($"Project {project.Name} doesn't implement any configuration for own packages"); } using (var cacheContext = new SourceCacheContext() { NoCache = false, DirectDownload = false, }) { var dependencyInfoResource = await project.AsSourceRepository(_sourceRepositoryProvider) .GetResourceAsync <DependencyInfoResource>(cancellationToken); var dependencyInfoResourceCollection = new DependencyInfoResourceCollection(dependencyInfoResource); var resolverContext = await ResolveDependenciesAsync(package, targetFramework, PackageIdentity.Comparer, dependencyInfoResourceCollection, cacheContext, project, true, cancellationToken); var packageReferences = installedPackageReferences.ToList(); if (uninstallationContext.RemoveDependencies) { uninstalledPackages = await GetPackagesCanBeUninstalledAsync(resolverContext.AvailablePackages, packageReferences.Select(x => x.PackageIdentity)); } else { uninstalledPackages = new List <PackageIdentity>() { package }; } } try { foreach (var removedPackage in uninstalledPackages) { if (removedPackage.Version is null) { _nugetLogger.LogWarning($"Skip package {removedPackage.Id} uninstall. Check your package.config for references of this packages"); continue; } var folderProject = new FolderNuGetProject(project.ContentPath); if (folderProject.PackageExists(removedPackage)) { _directoryService.ForceDeleteDirectory(_fileService, folderProject.GetInstalledPath(removedPackage), out failedEntries); } if (projectConfig is null) { continue; } var result = await projectConfig.UninstallPackageAsync(removedPackage, _nuGetProjectContextProvider.GetProjectContext(FileConflictAction.PromptUser), cancellationToken); if (!result) { _nugetLogger.LogError($"Saving package configuration failed in project {project} when installing package {package}"); } } } catch (IOException ex) { Log.Error(ex); _nugetLogger.LogError("Package files cannot be complete deleted by unexpected error (may be directory in use by another process?"); } finally { LogHelper.LogUnclearedPaths(failedEntries, Log); } }
public async Task TestPacManPreviewUninstallDependencyPackage() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder(); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath); var packageIdentity = PackageWithDependents[2]; // Pre-Assert // Check that the packages.config file does not exist Assert.False(File.Exists(randomPackagesConfigPath)); // Check that there are no packages returned by PackagesConfigProject var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, packagesInPackagesConfig.Count); Assert.Equal(0, msBuildNuGetProjectSystem.References.Count); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, packagesInPackagesConfig.Count); Assert.Equal(packageIdentity, packagesInPackagesConfig[1].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework); Assert.Equal(PackageWithDependents[0], packagesInPackagesConfig[0].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework); // Main Act Exception exception = null; try { var uninstallationContext = new UninstallationContext(); var packageActions = await nuGetPackageManager.PreviewUninstallPackageAsync(msBuildNuGetProject, "jQuery", uninstallationContext, testNuGetProjectContext, token); } catch (InvalidOperationException ex) { exception = ex; } catch (AggregateException ex) { exception = ExceptionUtility.Unwrap(ex); } Assert.NotNull(exception); Assert.True(exception is InvalidOperationException); Assert.Equal("Unable to uninstall 'jQuery.1.4.4' because 'jQuery.Validation.1.13.1' depends on it.", exception.Message); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath); }
public Task<IEnumerable<NuGetProjectAction>> PreviewUninstallPackageAsync ( NuGetProject nuGetProject, string packageId, UninstallationContext uninstallationContext, INuGetProjectContext nuGetProjectContext, CancellationToken token) { return packageManager.PreviewUninstallPackageAsync ( nuGetProject, packageId, uninstallationContext, nuGetProjectContext, token ); }
/// <summary> /// Return the resolve package actions /// </summary> protected async Task<IEnumerable<Tuple<NuGetProject, NuGetProjectAction>>> GetActions( INuGetUI uiService, IEnumerable<NuGetProject> targets, UserAction userAction, bool removeDependencies, bool forceRemove, ResolutionContext resolutionContext, INuGetProjectContext projectContext, CancellationToken token) { List<Tuple<NuGetProject, NuGetProjectAction>> results = new List<Tuple<NuGetProject, NuGetProjectAction>>(); Debug.Assert(userAction.PackageId != null, "Package id can never be null in a User action"); if (userAction.Action == NuGetProjectActionType.Install) { Debug.Assert(userAction.PackageIdentity != null, "Package identity cannot be null when installing a package"); foreach (var target in targets) { IEnumerable<NuGetProjectAction> actions; actions = await _packageManager.PreviewInstallPackageAsync(target, userAction.PackageIdentity, resolutionContext, projectContext, uiService.ActiveSource, null, token); results.AddRange(actions.Select(a => new Tuple<NuGetProject, NuGetProjectAction>(target, a))); } } else { UninstallationContext uninstallationContext = new UninstallationContext( removeDependencies: removeDependencies, forceRemove: forceRemove); foreach (var target in targets) { IEnumerable<NuGetProjectAction> actions; if (userAction.PackageIdentity != null) { actions = await _packageManager.PreviewUninstallPackageAsync(target, userAction.PackageIdentity, uninstallationContext, projectContext, token); } else { actions = await _packageManager.PreviewUninstallPackageAsync(target, userAction.PackageId, uninstallationContext, projectContext, token); } results.AddRange(actions.Select(a => new Tuple<NuGetProject, NuGetProjectAction>(target, a))); } } return results; }