public Task <bool> DeletePackage(PackageIdentity packageIdentity,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
var packageFilePath = GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(packageFilePath))
{
var packageDirectoryPath = Path.GetDirectoryName(packageFilePath);
using (var packageReader = new PackageArchiveReader(packageFilePath))
{
var installedSatelliteFilesPair = PackageHelper.GetInstalledSatelliteFiles(
packageReader,
PackagePathResolver,
GetPackageSaveMode(nuGetProjectContext));
var runtimePackageDirectory = installedSatelliteFilesPair.Item1;
var installedSatelliteFiles = installedSatelliteFilesPair.Item2;
if (!string.IsNullOrEmpty(runtimePackageDirectory))
{
try
{
// Delete all the package files now
FileSystemUtility.DeleteFiles(installedSatelliteFiles, runtimePackageDirectory, nuGetProjectContext);
}
catch (Exception ex)
{
nuGetProjectContext.Log(MessageLevel.Warning, ex.Message);
// Catch all exception with delete so that the package file is always deleted
}
}
// Get all the package files before deleting the package file
var installedPackageFiles = PackageHelper.GetInstalledPackageFiles(
packageReader,
packageIdentity,
PackagePathResolver,
GetPackageSaveMode(nuGetProjectContext));
try
{
// Delete all the package files now
FileSystemUtility.DeleteFiles(installedPackageFiles, packageDirectoryPath, nuGetProjectContext);
}
catch (Exception ex)
{
nuGetProjectContext.Log(MessageLevel.Warning, ex.Message);
// Catch all exception with delete so that the package file is always deleted
}
}
// Delete the package file
FileSystemUtility.DeleteFile(packageFilePath, nuGetProjectContext);
// Delete the package directory if any
FileSystemUtility.DeleteDirectorySafe(packageDirectoryPath, recursive: true, nuGetProjectContext: nuGetProjectContext);
// If this is the last package delete the package directory
// If this is the last package delete the package directory
if (!FileSystemUtility.GetFiles(Root, string.Empty, "*.*").Any() &&
!FileSystemUtility.GetDirectories(Root, string.Empty).Any())
{
FileSystemUtility.DeleteDirectorySafe(Root, recursive: false, nuGetProjectContext: nuGetProjectContext);
}
}
return(Task.FromResult(true));
}
internal static void DeleteFiles(IMSBuildNuGetProjectSystem projectSystem,
ZipArchive zipArchive,
IEnumerable <string> otherPackagesPath,
FrameworkSpecificGroup frameworkSpecificGroup,
IDictionary <FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
var packageTargetFramework = frameworkSpecificGroup.TargetFramework;
IPackageFileTransformer transformer;
try
{
projectSystem.BeginProcessing();
var directoryLookup = frameworkSpecificGroup.Items.ToLookup(
p => Path.GetDirectoryName(ResolveTargetPath(projectSystem,
fileTransformers,
fte => fte.UninstallExtension,
GetEffectivePathForContentFile(packageTargetFramework, p),
out transformer)));
// Get all directories that this package may have added
var directories = from grouping in directoryLookup
from directory in FileSystemUtility.GetDirectories(grouping.Key, altDirectorySeparator: false)
orderby directory.Length descending
select directory;
string projectFullPath = projectSystem.ProjectFullPath;
// Remove files from every directory
foreach (var directory in directories)
{
var directoryFiles = directoryLookup.Contains(directory) ? directoryLookup[directory] : Enumerable.Empty <string>();
if (!Directory.Exists(Path.Combine(projectFullPath, directory)))
{
continue;
}
foreach (var file in directoryFiles)
{
if (IsEmptyFolder(file))
{
continue;
}
// Resolve the path
var path = ResolveTargetPath(projectSystem,
fileTransformers,
fte => fte.UninstallExtension,
GetEffectivePathForContentFile(packageTargetFramework, file),
out transformer);
if (projectSystem.IsSupportedFile(path))
{
// Register the file being uninstalled (used by web site project system).
projectSystem.RegisterProcessedFiles(new[] { path });
if (transformer != null)
{
// TODO: use the framework from packages.config instead of the current framework
// which may have changed during re-targeting
var projectFramework = projectSystem.TargetFramework;
var matchingFiles = new List <InternalZipFileInfo>();
foreach (var otherPackagePath in otherPackagesPath)
{
using (var otherPackageZipReader = new PackageArchiveReader(otherPackagePath))
{
// use the project framework to find the group that would have been installed
var mostCompatibleContentFilesGroup = GetMostCompatibleGroup(
projectFramework,
otherPackageZipReader.GetContentItems());
if (IsValid(mostCompatibleContentFilesGroup))
{
// Should not normalize content files group.
// It should be like a ZipFileEntry with a forward slash.
foreach (var otherPackageItem in mostCompatibleContentFilesGroup.Items)
{
if (GetEffectivePathForContentFile(packageTargetFramework, otherPackageItem)
.Equals(GetEffectivePathForContentFile(packageTargetFramework, file), StringComparison.OrdinalIgnoreCase))
{
matchingFiles.Add(new InternalZipFileInfo(otherPackagePath, otherPackageItem));
}
}
}
}
}
try
{
var zipArchiveFileEntry = PathUtility.GetEntry(zipArchive, file);
if (zipArchiveFileEntry != null)
{
transformer.RevertFile(zipArchiveFileEntry.Open, path, matchingFiles, projectSystem);
}
}
catch (Exception e)
{
projectSystem.NuGetProjectContext.Log(MessageLevel.Warning, e.Message);
}
}
else
{
try
{
var zipArchiveFileEntry = PathUtility.GetEntry(zipArchive, file);
if (zipArchiveFileEntry != null)
{
DeleteFileSafe(path, zipArchiveFileEntry.Open, projectSystem);
}
}
catch (Exception e)
{
projectSystem.NuGetProjectContext.Log(MessageLevel.Warning, e.Message);
}
}
}
}
// If the directory is empty then delete it
if (!GetFilesSafe(projectSystem, directory).Any() &&
!GetDirectoriesSafe(projectSystem, directory).Any())
{
DeleteDirectorySafe(projectSystem, directory);
}
}
}
finally
{
projectSystem.EndProcessing();
}
}