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