// Add all reference items to the assembly list
private void AddReferencedAssemblies(PackageIdentity packageIdentify, DirectoryPath installedPath, PackageArchiveReader archiveReader)
{
List <FrameworkSpecificGroup> referenceItems = archiveReader.GetReferenceItems().ToList();
FrameworkSpecificGroup referenceGroup = GetMostCompatibleGroup(_currentFramework, referenceItems);
if (referenceGroup != null)
{
Trace.Verbose($"Found compatible reference group {referenceGroup.TargetFramework.DotNetFrameworkName} for package {packageIdentify}");
foreach (FilePath itemPath in referenceGroup.Items
.Select(x => new FilePath(x))
.Where(x => x.FileName.Extension == ".dll" || x.FileName.Extension == ".exe"))
{
FilePath assemblyPath = installedPath.CombineFile(itemPath);
_assemblyLoader.Add(assemblyPath.FullPath);
Trace.Verbose($"Added NuGet reference {assemblyPath} from package {packageIdentify} for loading");
}
}
else if (referenceItems.Count == 0)
{
// Only show a verbose message if there were no reference items (I.e., it's probably a content-only package or a metapackage and not a mismatch)
Trace.Verbose($"Could not find any reference items in package {packageIdentify}");
}
else
{
Trace.Verbose($"Could not find compatible reference group for package {packageIdentify} (found {string.Join(",", referenceItems.Select(x => x.TargetFramework.DotNetFrameworkName))})");
}
}
/// <summary>
/// Asynchronously gets build items.
/// </summary>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns an
/// <see cref="IEnumerable{FrameworkSpecificGroup}" />.</returns>
/// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" />
/// is cancelled.</exception>
public override async Task <IEnumerable <FrameworkSpecificGroup> > GetBuildItemsAsync(
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var nuspecReader = await GetNuspecReaderAsync(cancellationToken);
var id = nuspecReader.GetIdentity().Id;
var results = new List <FrameworkSpecificGroup>();
foreach (var group in await GetFileGroupsAsync(PackagingConstants.Folders.Build, cancellationToken))
{
var filteredGroup = group;
if (group.Items.Any(e => !IsAllowedBuildFile(id, e)))
{
// create a new group with only valid files
filteredGroup = new FrameworkSpecificGroup(group.TargetFramework, group.Items.Where(e => IsAllowedBuildFile(id, e)));
if (!filteredGroup.Items.Any())
{
// nothing was useful in the folder, skip this group completely
filteredGroup = null;
}
}
if (filteredGroup != null)
{
results.Add(filteredGroup);
}
}
return(results);
}
/// <summary>Returns the referenced .dll/.exe file paths</summary>
public IEnumerable <FilePath> GetReferencedAssembliesFilePaths(FolderNuGetProject project,
NuGetFramework targetFramework)
{
var pkgPath = GetPackageDirectoryPath(project);
var archiveReader = GetArchiveReader(project);
List <FrameworkSpecificGroup> referenceItems = archiveReader.GetReferenceItems().ToList();
FrameworkSpecificGroup referenceGroup = SelectFrameworkMostCompatibleGroup(targetFramework, referenceItems);
if (referenceGroup != null)
{
LogTo.Verbose(
$"Found compatible reference group {referenceGroup.TargetFramework.DotNetFrameworkName} for package {Identity}");
foreach (FilePath assemblyPath in referenceGroup.Items
.Select(x => new FilePath(x))
.Where(x => x.Extension == ".dll" || x.Extension == ".exe")
.Select(pkgPath.CombineFile))
{
LogTo.Verbose($"Found NuGet reference {assemblyPath} from package {Identity}");
yield return(assemblyPath);
}
}
else if (referenceItems.Count == 0)
{
// Only show a verbose message if there were no reference items (I.e., it's probably a content-only package or a metapackage and not a mismatch)
LogTo.Verbose($"Could not find any reference items in package {Identity}");
}
else
{
LogTo.Verbose(
$"Could not find compatible reference group for package {Identity} (found {string.Join(",", referenceItems.Select(x => x.TargetFramework.DotNetFrameworkName))})");
}
}
private static JToken WritePackageReferenceSet(FrameworkSpecificGroup item)
{
var json = new JObject();
json["targetFramework"] = item.TargetFramework?.ToString();
json["references"] = WriteArray(item.Items, WriteString);
return(json);
}
void AddPackageLibFile(string framework, string fileName)
{
var files = new List <string> ();
files.Add(fileName);
var nugetFramework = NuGetFramework.Parse(framework);
var item = new FrameworkSpecificGroup(nugetFramework, files);
packageFilesReader.LibItems.Add(item);
}
private static bool IsValid(FrameworkSpecificGroup frameworkSpecificGroup)
{
if (frameworkSpecificGroup != null)
{
return(frameworkSpecificGroup.HasEmptyFolder ||
frameworkSpecificGroup.Items.Any() ||
!frameworkSpecificGroup.TargetFramework.Equals(NuGetFramework.AnyFramework));
}
return(false);
}
private static IList<LibraryDependency> GetDependencies(NuGetFramework targetFramework,
PackageDependencyGroup dependencies,
FrameworkSpecificGroup frameworkAssemblies)
{
var libraryDependencies = new List<LibraryDependency>();
if (dependencies != null)
{
foreach (var d in dependencies.Packages)
{
libraryDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = d.Id,
VersionRange = d.VersionRange
}
});
}
}
if (frameworkAssemblies == null)
{
return libraryDependencies;
}
if (!targetFramework.IsDesktop())
{
// REVIEW: This isn't 100% correct since none *can* mean
// any in theory, but in practice it means .NET full reference assembly
// If there's no supported target frameworks and we're not targeting
// the desktop framework then skip it.
// To do this properly we'll need all reference assemblies supported
// by each supported target framework which isn't always available.
return libraryDependencies;
}
foreach (var name in frameworkAssemblies.Items)
{
libraryDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = name,
TypeConstraint = LibraryTypes.Reference
}
});
}
return libraryDependencies;
}
private static IList <LibraryDependency> GetDependencies(NuGetFramework targetFramework,
PackageDependencyGroup dependencies,
FrameworkSpecificGroup frameworkAssemblies)
{
var libraryDependencies = new List <LibraryDependency>();
if (dependencies != null)
{
foreach (var d in dependencies.Packages)
{
libraryDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = d.Id,
VersionRange = d.VersionRange
}
});
}
}
if (frameworkAssemblies == null)
{
return(libraryDependencies);
}
if (!targetFramework.IsDesktop())
{
// REVIEW: This isn't 100% correct since none *can* mean
// any in theory, but in practice it means .NET full reference assembly
// If there's no supported target frameworks and we're not targeting
// the desktop framework then skip it.
// To do this properly we'll need all reference assemblies supported
// by each supported target framework which isn't always available.
return(libraryDependencies);
}
foreach (var name in frameworkAssemblies.Items)
{
libraryDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = name,
TypeConstraint = LibraryTypes.Reference
}
});
}
return(libraryDependencies);
}
private FrameworkSpecificGroup?GetMostCompatibleGroup(NuGetFramework projectTargetFramework,
IEnumerable <FrameworkSpecificGroup> itemGroups)
{
NuGetFramework mostCompatibleFramework = new FrameworkReducer()
.GetNearest(projectTargetFramework, itemGroups.Select(i => i.TargetFramework));
if (mostCompatibleFramework is null)
{
return(null);
}
FrameworkSpecificGroup mostCompatibleGroup = itemGroups.FirstOrDefault(i => i.TargetFramework.Equals(mostCompatibleFramework));
return(IsValid(mostCompatibleGroup) ? mostCompatibleGroup : null);
}
// Add content directories to the input paths
private IEnumerable <DirectoryPath> GetContentDirectories(DirectoryPath installedPath, PackageArchiveReader archiveReader)
{
FrameworkSpecificGroup contentGroup = GetMostCompatibleGroup(_currentFramework, archiveReader.GetContentItems().ToList());
if (contentGroup != null)
{
// We need to use the directory name from an actual file to make sure we get the casing right
foreach (string contentSegment in contentGroup.Items
.Select(x => new FilePath(x).Segments[0])
.Distinct())
{
yield return(installedPath.Combine(contentSegment));
}
}
}
// Add all reference items to the assembly list
private void AddReferencedAssemblies(DirectoryPath installedPath, PackageArchiveReader archiveReader)
{
FrameworkSpecificGroup referenceGroup = GetMostCompatibleGroup(_currentFramework, archiveReader.GetReferenceItems().ToList());
if (referenceGroup != null)
{
foreach (FilePath itemPath in referenceGroup.Items
.Select(x => new FilePath(x))
.Where(x => x.FileName.Extension == ".dll" || x.FileName.Extension == ".exe"))
{
FilePath assemblyPath = installedPath.CombineFile(itemPath);
_assemblyLoader.Add(assemblyPath.FullPath);
Trace.Verbose($"Added NuGet reference {assemblyPath} for loading");
}
}
}
// Add content directories to the input paths
private IEnumerable <DirectoryPath> GetContentDirectories(PackageIdentity packageIdentify, DirectoryPath installedPath, PackageArchiveReader archiveReader)
{
FrameworkSpecificGroup contentGroup = GetMostCompatibleGroup(_currentFramework, archiveReader.GetContentItems().ToList());
if (contentGroup != null)
{
// We need to use the directory name from an actual file to make sure we get the casing right
foreach (string contentSegment in contentGroup.Items
.Select(x => new FilePath(x).Segments[0])
.Distinct())
{
DirectoryPath contentPath = installedPath.Combine(contentSegment);
Trace.Verbose($"Added content path {contentPath} from compatible content group {contentGroup.TargetFramework.DotNetFrameworkName} from package {packageIdentify} to included paths");
yield return(contentPath);
}
}
}
// Add content directories to the input paths
private void IncludeContentDirectories(DirectoryPath installedPath, PackageArchiveReader archiveReader)
{
FrameworkSpecificGroup contentGroup = GetMostCompatibleGroup(_reducer,
_currentFramework, archiveReader.GetContentItems().ToList());
if (contentGroup != null)
{
// We need to use the directory name from an actual file to make sure we get the casing right
foreach (string contentSegment in contentGroup.Items
.Select(x => new FilePath(x).Segments[0])
.Distinct())
{
DirectoryPath contentPath = installedPath.Combine(contentSegment);
_fileSystem.InputPaths.Insert(0, contentPath);
Trace.Verbose($"Added content path {contentPath} to included paths");
}
}
}
private async Task <List <string> > GetSatelliteFilesForLibraryAsync(FrameworkSpecificGroup libraryFrameworkSpecificGroup, PackageReaderBase packageReader,
CancellationToken cancellationToken)
{
var satelliteFiles = new List <string>();
using (var nuspec = await packageReader.GetNuspecAsync(cancellationToken))
{
var nuspecReader = new NuspecReader(nuspec);
var satelliteFilesInGroup = libraryFrameworkSpecificGroup.Items
.Where(item => Path.GetDirectoryName(item)
.Split(Path.DirectorySeparatorChar)
.Contains(nuspecReader.GetLanguage(), StringComparer.OrdinalIgnoreCase)).ToList();
satelliteFiles.AddRange(satelliteFilesInGroup);
return(satelliteFiles);
}
}
private static FrameworkSpecificGroup Normalize(FrameworkSpecificGroup group)
{
// Default to returning the same group
FrameworkSpecificGroup result = group;
// If the group is null or it does not contain any items besides _._ then this is a no-op.
// If it does have items create a new normalized group to replace it with.
if (group?.Items.Any() == true)
{
// Filter out invalid files
IEnumerable <string> normalizedItems = GetValidPackageItems(group.Items)
.Select(PathUtility.ReplaceAltDirSeparatorWithDirSeparator);
// Create a new group
result = new FrameworkSpecificGroup(group.TargetFramework, normalizedItems);
}
return(result);
}
internal static FrameworkSpecificGroup GetMostCompatibleGroup(NuGetFramework projectTargetFramework, IEnumerable<FrameworkSpecificGroup> itemGroups,
bool altDirSeparator = false)
{
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework mostCompatibleFramework = reducer.GetNearest(projectTargetFramework, itemGroups.Select(i => i.TargetFramework));
if (mostCompatibleFramework != null)
{
IEnumerable<FrameworkSpecificGroup> mostCompatibleGroups = itemGroups.Where(i => i.TargetFramework.Equals(mostCompatibleFramework));
var mostCompatibleGroup = mostCompatibleGroups.SingleOrDefault();
if (IsValid(mostCompatibleGroup))
{
mostCompatibleGroup = new FrameworkSpecificGroup(mostCompatibleGroup.TargetFramework,
GetValidPackageItems(mostCompatibleGroup.Items).Select(item => altDirSeparator ? PathUtility.ReplaceDirSeparatorWithAltDirSeparator(item)
: PathUtility.ReplaceAltDirSeparatorWithDirSeparator(item)));
}
return mostCompatibleGroup;
}
return null;
}
/// The following method is originally from the internal MSBuildNuGetProjectSystemUtility class
private static FrameworkSpecificGroup SelectFrameworkMostCompatibleGroup(NuGetFramework projectTargetFramework,
List <FrameworkSpecificGroup> itemGroups)
{
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework mostCompatibleFramework
= reducer.GetNearest(projectTargetFramework, itemGroups.Select(i => i.TargetFramework));
if (mostCompatibleFramework != null)
{
FrameworkSpecificGroup mostCompatibleGroup
= itemGroups.FirstOrDefault(i => i.TargetFramework.Equals(mostCompatibleFramework));
if (IsValidFrameworkGroup(mostCompatibleGroup))
{
return(mostCompatibleGroup);
}
}
return(null);
}
// Probably going to hell for using a region
// The following methods are originally from the internal MSBuildNuGetProjectSystemUtility class
#region MSBuildNuGetProjectSystemUtility
private static FrameworkSpecificGroup GetMostCompatibleGroup(FrameworkReducer reducer, NuGetFramework projectTargetFramework,
ICollection <FrameworkSpecificGroup> itemGroups)
{
NuGetFramework mostCompatibleFramework
= reducer.GetNearest(projectTargetFramework, itemGroups.Select(i => i.TargetFramework));
if (mostCompatibleFramework != null)
{
FrameworkSpecificGroup mostCompatibleGroup = itemGroups
.FirstOrDefault(i => i.TargetFramework.Equals(mostCompatibleFramework));
if (IsValid(mostCompatibleGroup))
{
// Normalize() is called outside GetMostCompatibleGroup() in MSBuildNuGetProjectSystemUtility but I combined it
return(Normalize(mostCompatibleGroup));
}
}
return(null);
}
internal static FrameworkSpecificGroup GetMostCompatibleGroup(NuGetFramework projectTargetFramework, IEnumerable <FrameworkSpecificGroup> itemGroups,
bool altDirSeparator = false)
{
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework mostCompatibleFramework = reducer.GetNearest(projectTargetFramework, itemGroups.Select(i => i.TargetFramework));
if (mostCompatibleFramework != null)
{
IEnumerable <FrameworkSpecificGroup> mostCompatibleGroups = itemGroups.Where(i => i.TargetFramework.Equals(mostCompatibleFramework));
var mostCompatibleGroup = mostCompatibleGroups.SingleOrDefault();
if (IsValid(mostCompatibleGroup))
{
mostCompatibleGroup = new FrameworkSpecificGroup(mostCompatibleGroup.TargetFramework,
GetValidPackageItems(mostCompatibleGroup.Items).Select(item => altDirSeparator ? PathUtility.ReplaceDirSeparatorWithAltDirSeparator(item)
: PathUtility.ReplaceAltDirSeparatorWithDirSeparator(item)));
}
return(mostCompatibleGroup);
}
return(null);
}
public static IEnumerable <DirectoryPath> GetContentDirectoryPath(
this NuGetPackage pkg,
FolderNuGetProject project,
NuGetFramework targetFramework)
{
if (pkg == null)
{
yield break;
}
var pkgPath = pkg.GetPackageDirectoryPath(project);
if (pkgPath == null)
{
yield break;
}
var archiveReader = pkg.GetArchiveReader(project);
if (archiveReader == null)
{
yield break;
}
FrameworkSpecificGroup contentGroup = SelectFrameworkMostCompatibleGroup(targetFramework, archiveReader.GetContentItems().ToList());
if (contentGroup != null)
{
foreach (DirectoryPath contentPath in contentGroup.Items.Select(x => new FilePath(x).Segments[0])
.Distinct()
.Select(x => pkgPath.Combine(x)))
{
LogTo.Trace(
$"Found content path {contentPath} from compatible content group {contentGroup.TargetFramework.DotNetFrameworkName} from package {pkg.Identity}");
yield return(contentPath);
}
}
}
internal static void DeleteFiles(IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem,
ZipArchive zipArchive,
IEnumerable<string> otherPackagesPath,
FrameworkSpecificGroup frameworkSpecificGroup,
IDictionary<FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
var packageTargetFramework = frameworkSpecificGroup.TargetFramework;
IPackageFileTransformer transformer;
var directoryLookup = frameworkSpecificGroup.Items.ToLookup(
p => Path.GetDirectoryName(ResolveTargetPath(msBuildNuGetProjectSystem,
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;
// 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(msBuildNuGetProjectSystem.ProjectFullPath, directory)))
{
continue;
}
try
{
foreach (var file in directoryFiles)
{
if (IsEmptyFolder(file))
{
continue;
}
// Resolve the path
string path = ResolveTargetPath(msBuildNuGetProjectSystem,
fileTransformers,
fte => fte.UninstallExtension,
GetEffectivePathForContentFile(packageTargetFramework, file),
out transformer);
if (msBuildNuGetProjectSystem.IsSupportedFile(path))
{
if (transformer != null)
{
// TODO: use the framework from packages.config instead of the current framework
// which may have changed during re-targeting
NuGetFramework projectFramework = msBuildNuGetProjectSystem.TargetFramework;
List<InternalZipFileInfo> matchingFiles = new List<InternalZipFileInfo>();
foreach(var otherPackagePath in otherPackagesPath)
{
using(var otherPackageStream = File.OpenRead(otherPackagePath))
{
var otherPackageZipArchive = new ZipArchive(otherPackageStream);
var otherPackageZipReader = new PackageReader(otherPackageZipArchive);
// use the project framework to find the group that would have been installed
var mostCompatibleContentFilesGroup = GetMostCompatibleGroup(projectFramework, otherPackageZipReader.GetContentItems(), altDirSeparator: true);
if(mostCompatibleContentFilesGroup != null && IsValid(mostCompatibleContentFilesGroup))
{
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 = zipArchive.GetEntry(PathUtility.ReplaceDirSeparatorWithAltDirSeparator(file));
if (zipArchiveFileEntry != null)
{
transformer.RevertFile(zipArchiveFileEntry, path, matchingFiles, msBuildNuGetProjectSystem);
}
}
catch (Exception e)
{
msBuildNuGetProjectSystem.NuGetProjectContext.Log(MessageLevel.Warning, e.Message);
}
}
else
{
var zipArchiveFileEntry = zipArchive.GetEntry(PathUtility.ReplaceDirSeparatorWithAltDirSeparator(file));
if (zipArchiveFileEntry != null)
{
DeleteFileSafe(path, zipArchiveFileEntry.Open, msBuildNuGetProjectSystem);
}
}
}
}
// If the directory is empty then delete it
if (!GetFilesSafe(msBuildNuGetProjectSystem, directory).Any() &&
!GetDirectoriesSafe(msBuildNuGetProjectSystem, directory).Any())
{
DeleteDirectorySafe(msBuildNuGetProjectSystem, directory, recursive: false);
}
}
finally
{
}
}
}
public IEnumerable<FrameworkSpecificGroup> GetBuildItems()
{
var id = GetIdentity().Id;
var results = new List<FrameworkSpecificGroup>();
foreach (var group in GetFileGroups("build"))
{
var filteredGroup = group;
if (group.Items.Any(e => !IsAllowedBuildFile(id, e)))
{
// create a new group with only valid files
filteredGroup = new FrameworkSpecificGroup(group.TargetFramework, group.Items.Where(e => IsAllowedBuildFile(id, e)));
if (!filteredGroup.Items.Any())
{
// nothing was useful in the folder, skip this group completely
filteredGroup = null;
}
}
if (filteredGroup != null)
{
results.Add(filteredGroup);
}
}
return results;
}
internal static void AddFiles(IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem,
ZipArchive zipArchive,
FrameworkSpecificGroup frameworkSpecificGroup,
IDictionary <FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
var packageTargetFramework = frameworkSpecificGroup.TargetFramework;
// Content files are maintained with AltDirectorySeparatorChar
List <string> packageItemListAsArchiveEntryNames = frameworkSpecificGroup.Items.Select(i => PathUtility.ReplaceDirSeparatorWithAltDirSeparator(i)).ToList();
packageItemListAsArchiveEntryNames.Sort(new PackageItemComparer());
try
{
var zipArchiveEntryList = packageItemListAsArchiveEntryNames.Select(i => zipArchive.GetEntry(i)).Where(i => i != null).ToList();
try
{
var paths = zipArchiveEntryList.Select(file => ResolvePath(fileTransformers, fte => fte.InstallExtension,
GetEffectivePathForContentFile(packageTargetFramework, file.FullName)));
paths = paths.Where(p => !String.IsNullOrEmpty(p));
msBuildNuGetProjectSystem.BeginProcessing(paths);
}
catch (Exception)
{
// Ignore all exceptions for now
}
foreach (ZipArchiveEntry zipArchiveEntry in zipArchiveEntryList)
{
if (zipArchiveEntry == null)
{
throw new ArgumentNullException("zipArchiveEntry");
}
if (IsEmptyFolder(zipArchiveEntry.FullName))
{
continue;
}
var effectivePathForContentFile = GetEffectivePathForContentFile(packageTargetFramework, zipArchiveEntry.FullName);
// Resolve the target path
IPackageFileTransformer installTransformer;
string path = ResolveTargetPath(msBuildNuGetProjectSystem,
fileTransformers,
fte => fte.InstallExtension, effectivePathForContentFile, out installTransformer);
if (msBuildNuGetProjectSystem.IsSupportedFile(path))
{
if (installTransformer != null)
{
installTransformer.TransformFile(zipArchiveEntry, path, msBuildNuGetProjectSystem);
}
else
{
// Ignore uninstall transform file during installation
string truncatedPath;
IPackageFileTransformer uninstallTransformer =
FindFileTransformer(fileTransformers, fte => fte.UninstallExtension, effectivePathForContentFile, out truncatedPath);
if (uninstallTransformer != null)
{
continue;
}
TryAddFile(msBuildNuGetProjectSystem, path, zipArchiveEntry.Open);
}
}
}
}
finally
{
msBuildNuGetProjectSystem.EndProcessing();
}
}
/// <summary>
/// Framework reference groups
/// </summary>
public IEnumerable<FrameworkSpecificGroup> GetFrameworkReferenceGroups()
{
var results = new List<FrameworkSpecificGroup>();
var ns = Xml.Root.GetDefaultNamespace().NamespaceName;
var groups = new Dictionary<NuGetFramework, HashSet<string>>(new NuGetFrameworkFullComparer());
foreach (var group in MetadataNode.Elements(XName.Get(FrameworkAssemblies, ns)).Elements(XName.Get(FrameworkAssembly, ns))
.GroupBy(n => GetAttributeValue(n, TargetFramework)))
{
// Framework references may have multiple comma delimited frameworks
var frameworks = new List<NuGetFramework>();
// Empty frameworks go under Any
if (String.IsNullOrEmpty(group.Key))
{
frameworks.Add(NuGetFramework.AnyFramework);
}
else
{
foreach (var fwString in group.Key.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
if (!String.IsNullOrEmpty(fwString))
{
frameworks.Add(NuGetFramework.Parse(fwString.Trim(), _frameworkProvider));
}
}
}
// apply items to each framework
foreach (var framework in frameworks)
{
HashSet<string> items = null;
if (!groups.TryGetValue(framework, out items))
{
items = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
groups.Add(framework, items);
}
// Merge items and ignore duplicates
items.UnionWith(group.Select(item => GetAttributeValue(item, AssemblyName)).Where(item => !String.IsNullOrEmpty(item)));
}
}
// Sort items to make this deterministic for the caller
foreach (var framework in groups.Keys.OrderBy(e => e, new NuGetFrameworkSorter()))
{
var group = new FrameworkSpecificGroup(framework, groups[framework].OrderBy(item => item, StringComparer.OrdinalIgnoreCase));
results.Add(group);
}
return results;
}
public async override Task <bool> InstallPackageAsync(PackageIdentity packageIdentity, Stream packageStream,
INuGetProjectContext nuGetProjectContext, CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (packageStream == null)
{
throw new ArgumentNullException("packageStream");
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException("nuGetProjectContext");
}
if (!packageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable);
}
// Step-1: Check if the package already exists after setting the nuGetProjectContext
MSBuildNuGetProjectSystem.SetNuGetProjectContext(nuGetProjectContext);
var packageReference = (await GetInstalledPackagesAsync(token)).Where(
p => p.PackageIdentity.Equals(packageIdentity)).FirstOrDefault();
if (packageReference != null)
{
nuGetProjectContext.Log(MessageLevel.Warning, Strings.PackageAlreadyExistsInProject,
packageIdentity, MSBuildNuGetProjectSystem.ProjectName);
return(false);
}
// Step-2: Create PackageReader using the PackageStream and obtain the various item groups
packageStream.Seek(0, SeekOrigin.Begin);
var zipArchive = new ZipArchive(packageStream);
PackageReader packageReader = new PackageReader(zipArchive);
IEnumerable <FrameworkSpecificGroup> referenceItemGroups = packageReader.GetReferenceItems();
IEnumerable <FrameworkSpecificGroup> frameworkReferenceGroups = packageReader.GetFrameworkItems();
IEnumerable <FrameworkSpecificGroup> contentFileGroups = packageReader.GetContentItems();
IEnumerable <FrameworkSpecificGroup> buildFileGroups = packageReader.GetBuildItems();
IEnumerable <FrameworkSpecificGroup> toolItemGroups = packageReader.GetToolItems();
// Step-3: Get the most compatible items groups for all items groups
bool hasCompatibleProjectLevelContent = false;
FrameworkSpecificGroup compatibleReferenceItemsGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, referenceItemGroups);
FrameworkSpecificGroup compatibleFrameworkReferencesGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, frameworkReferenceGroups);
FrameworkSpecificGroup compatibleContentFilesGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, contentFileGroups);
FrameworkSpecificGroup compatibleBuildFilesGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, buildFileGroups);
FrameworkSpecificGroup compatibleToolItemsGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework, toolItemGroups);
hasCompatibleProjectLevelContent = MSBuildNuGetProjectSystemUtility.IsValid(compatibleReferenceItemsGroup) ||
MSBuildNuGetProjectSystemUtility.IsValid(compatibleFrameworkReferencesGroup) ||
MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup) ||
MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup);
// Check if package has any content for project
bool hasProjectLevelContent = referenceItemGroups.Any() || frameworkReferenceGroups.Any() ||
contentFileGroups.Any() || buildFileGroups.Any();
bool onlyHasCompatibleTools = false;
bool onlyHasDependencies = false;
if (!hasProjectLevelContent)
{
// Since it does not have project-level content, check if it has dependencies or compatible tools
// Note that we are not checking if it has compatible project level content, but, just that it has project level content
// If the package has project-level content, but nothing compatible, we still need to throw
// If a package does not have any project-level content, it can be a
// Legacy solution level packages which only has compatible tools group
onlyHasCompatibleTools = MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup) && compatibleToolItemsGroup.Items.Any();
if (!onlyHasCompatibleTools)
{
// If it does not have compatible tool items either, check if it at least has dependencies
onlyHasDependencies = packageReader.GetPackageDependencies().Any();
}
}
else
{
string shortFramework = MSBuildNuGetProjectSystem.TargetFramework.GetShortFolderName();
nuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_TargetFrameworkInfoPrefix, packageIdentity,
this.GetMetadata <string>(NuGetProjectMetadataKeys.Name), shortFramework);
}
// Step-4: Check if there are any compatible items in the package or that this is not a package with only tools group. If not, throw
if (!hasCompatibleProjectLevelContent && !onlyHasCompatibleTools && !onlyHasDependencies)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
Strings.UnableToFindCompatibleItems, packageIdentity, MSBuildNuGetProjectSystem.TargetFramework));
}
if (hasCompatibleProjectLevelContent)
{
string shortFramework = MSBuildNuGetProjectSystem.TargetFramework.GetShortFolderName();
nuGetProjectContext.Log(MessageLevel.Debug, Strings.Debug_TargetFrameworkInfoPrefix, packageIdentity,
this.GetMetadata <string>(NuGetProjectMetadataKeys.Name), shortFramework);
}
else if (onlyHasCompatibleTools)
{
nuGetProjectContext.Log(MessageLevel.Info, Strings.AddingPackageWithOnlyToolsGroup, packageIdentity,
this.GetMetadata <string>(NuGetProjectMetadataKeys.Name));
}
else if (onlyHasDependencies)
{
nuGetProjectContext.Log(MessageLevel.Info, Strings.AddingPackageWithOnlyDependencies, packageIdentity,
this.GetMetadata <string>(NuGetProjectMetadataKeys.Name));
}
// Step-5: Raise PackageInstalling event
// At this point, GetInstalledPath is pointless since the package is, likely, not already installed. It will be empty
// Using PackagePathResolver.GetInstallPath would be wrong, since, package version from the nuspec is always used
var packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, FolderNuGetProject.GetInstalledPath(packageIdentity));
if (PackageInstalling != null)
{
PackageInstalling(this, packageEventArgs);
}
PackageEventsProvider.Instance.NotifyInstalling(packageEventArgs);
// Step-6: Install package to FolderNuGetProject
await FolderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, nuGetProjectContext, token);
// Step-7: Raise PackageInstalled event
// Call GetInstalledPath again, to get the package installed path
packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, FolderNuGetProject.GetInstalledPath(packageIdentity));
if (PackageInstalled != null)
{
PackageInstalled(this, packageEventArgs);
}
PackageEventsProvider.Instance.NotifyInstalled(packageEventArgs);
// Step-8: MSBuildNuGetProjectSystem operations
// Step-8.1: Add references to project
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleReferenceItemsGroup) && !IsSkipAssemblyReferences(nuGetProjectContext))
{
foreach (var referenceItem in compatibleReferenceItemsGroup.Items)
{
if (IsAssemblyReference(referenceItem))
{
var referenceItemFullPath = Path.Combine(FolderNuGetProject.GetInstalledPath(packageIdentity), referenceItem);
var referenceName = Path.GetFileName(referenceItem);
if (MSBuildNuGetProjectSystem.ReferenceExists(referenceName))
{
MSBuildNuGetProjectSystem.RemoveReference(referenceName);
}
MSBuildNuGetProjectSystem.AddReference(referenceItemFullPath);
}
}
}
// Step-8.2: Add Frameworkreferences to project
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleFrameworkReferencesGroup))
{
foreach (var frameworkReference in compatibleFrameworkReferencesGroup.Items)
{
var frameworkReferenceName = Path.GetFileName(frameworkReference);
if (!MSBuildNuGetProjectSystem.ReferenceExists(frameworkReference))
{
MSBuildNuGetProjectSystem.AddFrameworkReference(frameworkReference);
}
}
}
// Step-8.3: Add Content Files
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup))
{
MSBuildNuGetProjectSystemUtility.AddFiles(MSBuildNuGetProjectSystem,
zipArchive, compatibleContentFilesGroup, FileTransformers);
}
// Step-8.4: Add Build imports
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup))
{
foreach (var buildImportFile in compatibleBuildFilesGroup.Items)
{
string fullImportFilePath = Path.Combine(FolderNuGetProject.GetInstalledPath(packageIdentity), buildImportFile);
MSBuildNuGetProjectSystem.AddImport(fullImportFilePath,
fullImportFilePath.EndsWith(".props", StringComparison.OrdinalIgnoreCase) ? ImportLocation.Top : ImportLocation.Bottom);
}
}
// Step-9: Install package to PackagesConfigNuGetProject
await PackagesConfigNuGetProject.InstallPackageAsync(packageIdentity, packageStream, nuGetProjectContext, token);
// Step-10: Add packages.config to MSBuildNuGetProject
MSBuildNuGetProjectSystem.AddExistingFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath));
// Step 11: Raise PackageReferenceAdded event
if (PackageReferenceAdded != null)
{
PackageReferenceAdded(this, packageEventArgs);
}
PackageEventsProvider.Instance.NotifyReferenceAdded(packageEventArgs);
// Step-12: Execute powershell script - install.ps1
string packageInstallPath = FolderNuGetProject.GetInstalledPath(packageIdentity);
FrameworkSpecificGroup anyFrameworkToolsGroup = toolItemGroups.Where(g => g.TargetFramework.Equals(NuGetFramework.AnyFramework)).FirstOrDefault();
if (anyFrameworkToolsGroup != null)
{
string initPS1RelativePath = anyFrameworkToolsGroup.Items.Where(p =>
p.StartsWith(PowerShellScripts.InitPS1RelativePath)).FirstOrDefault();
if (!String.IsNullOrEmpty(initPS1RelativePath))
{
initPS1RelativePath = PathUtility.ReplaceAltDirSeparatorWithDirSeparator(initPS1RelativePath);
await MSBuildNuGetProjectSystem.ExecuteScriptAsync(packageInstallPath, initPS1RelativePath, zipArchive, this);
}
}
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup))
{
string installPS1RelativePath = compatibleToolItemsGroup.Items.Where(p =>
p.EndsWith(Path.DirectorySeparatorChar + PowerShellScripts.Install)).FirstOrDefault();
if (!String.IsNullOrEmpty(installPS1RelativePath))
{
await MSBuildNuGetProjectSystem.ExecuteScriptAsync(packageInstallPath, installPS1RelativePath, zipArchive, this);
}
}
return(true);
}
public async override Task <bool> UninstallPackageAsync(PackageIdentity packageIdentity, INuGetProjectContext nuGetProjectContext, CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException("nuGetProjectContext");
}
// Step-1: Check if the package already exists after setting the nuGetProjectContext
MSBuildNuGetProjectSystem.SetNuGetProjectContext(nuGetProjectContext);
var packageReference = (await GetInstalledPackagesAsync(token)).Where(
p => p.PackageIdentity.Equals(packageIdentity)).FirstOrDefault();
if (packageReference == null)
{
nuGetProjectContext.Log(MessageLevel.Warning, Strings.PackageDoesNotExistInProject,
packageIdentity, MSBuildNuGetProjectSystem.ProjectName);
return(false);
}
var packageTargetFramework = packageReference.TargetFramework ?? NuGetFramework.UnsupportedFramework;
var packageEventArgs = new PackageEventArgs(FolderNuGetProject, packageIdentity, FolderNuGetProject.GetInstalledPath(packageIdentity));
using (var packageStream = File.OpenRead(FolderNuGetProject.GetInstalledPackageFilePath(packageIdentity)))
{
// Step-2: Create PackageReader using the PackageStream and obtain the various item groups
// Get the package target framework instead of using project targetframework
var zipArchive = new ZipArchive(packageStream);
var packageReader = new PackageReader(zipArchive);
IEnumerable <FrameworkSpecificGroup> referenceItemGroups = packageReader.GetReferenceItems();
IEnumerable <FrameworkSpecificGroup> frameworkReferenceGroups = packageReader.GetFrameworkItems();
IEnumerable <FrameworkSpecificGroup> contentFileGroups = packageReader.GetContentItems();
IEnumerable <FrameworkSpecificGroup> buildFileGroups = packageReader.GetBuildItems();
// Step-3: Get the most compatible items groups for all items groups
FrameworkSpecificGroup compatibleReferenceItemsGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, referenceItemGroups);
FrameworkSpecificGroup compatibleFrameworkReferencesGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, frameworkReferenceGroups);
FrameworkSpecificGroup compatibleContentFilesGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, contentFileGroups);
FrameworkSpecificGroup compatibleBuildFilesGroup =
MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(packageTargetFramework, buildFileGroups);
// TODO: Need to handle References element??
// Step-4: Raise PackageUninstalling event
if (PackageUninstalling != null)
{
PackageUninstalling(this, packageEventArgs);
}
PackageEventsProvider.Instance.NotifyUninstalling(packageEventArgs);
// Step-5: Uninstall package from packages.config
await PackagesConfigNuGetProject.UninstallPackageAsync(packageIdentity, nuGetProjectContext, token);
// Step-6: Remove packages.config from MSBuildNuGetProject if there are no packages
// OR Add it again (to ensure that Source Control works), when there are some packages
if (!(await PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).Any())
{
MSBuildNuGetProjectSystem.RemoveFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath));
}
else
{
MSBuildNuGetProjectSystem.AddExistingFile(Path.GetFileName(PackagesConfigNuGetProject.FullPath));
}
// Step-7: Uninstall package from the msbuild project
// Step-7.1: Remove references
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleReferenceItemsGroup))
{
foreach (var item in compatibleReferenceItemsGroup.Items)
{
if (IsAssemblyReference(item))
{
MSBuildNuGetProjectSystem.RemoveReference(Path.GetFileName(item));
}
}
}
// Step-7.2: Framework references are never removed. This is a no-op
// Step-7.3: Remove content files
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleContentFilesGroup))
{
MSBuildNuGetProjectSystemUtility.DeleteFiles(MSBuildNuGetProjectSystem,
zipArchive,
(await GetInstalledPackagesAsync(token)).Select(pr => FolderNuGetProject.GetInstalledPackageFilePath(pr.PackageIdentity)),
compatibleContentFilesGroup,
FileTransformers);
}
// Step-7.4: Remove build imports
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleBuildFilesGroup))
{
foreach (var buildImportFile in compatibleBuildFilesGroup.Items)
{
string fullImportFilePath = Path.Combine(FolderNuGetProject.GetInstalledPath(packageIdentity), buildImportFile);
MSBuildNuGetProjectSystem.RemoveImport(fullImportFilePath);
}
}
// Step-7.5: Remove binding redirects. This is a no-op
// Step-8: Raise PackageReferenceRemoved event
if (PackageReferenceRemoved != null)
{
PackageReferenceRemoved(this, packageEventArgs);
}
PackageEventsProvider.Instance.NotifyReferenceRemoved(packageEventArgs);
// Step-9: Execute powershell script - uninstall.ps1
IEnumerable <FrameworkSpecificGroup> toolItemGroups = packageReader.GetToolItems();
FrameworkSpecificGroup compatibleToolItemsGroup = MSBuildNuGetProjectSystemUtility.GetMostCompatibleGroup(MSBuildNuGetProjectSystem.TargetFramework,
toolItemGroups);
if (MSBuildNuGetProjectSystemUtility.IsValid(compatibleToolItemsGroup))
{
string uninstallPS1RelativePath = compatibleToolItemsGroup.Items.Where(p =>
p.EndsWith(Path.DirectorySeparatorChar + PowerShellScripts.Uninstall)).FirstOrDefault();
if (!String.IsNullOrEmpty(uninstallPS1RelativePath))
{
string packageInstallPath = FolderNuGetProject.GetInstalledPath(packageIdentity);
await MSBuildNuGetProjectSystem.ExecuteScriptAsync(packageInstallPath, uninstallPS1RelativePath, zipArchive, this);
}
}
}
// Step-10: Uninstall package from the folderNuGetProject
await FolderNuGetProject.UninstallPackageAsync(packageIdentity, nuGetProjectContext, token);
// Step-11: Raise PackageUninstalled event
if (PackageUninstalled != null)
{
PackageUninstalled(this, packageEventArgs);
}
PackageEventsProvider.Instance.NotifyUninstalled(packageEventArgs);
return(true);
}
/// <summary>
/// 从文件中加载插件并管理(但不初始化)
/// </summary>
/// <param name="fileName">相对于运行目录的文件名</param>
public async Task LoadPackageAsync(string fileName)
{
using PackageArchiveReader reader = new PackageArchiveReader(File.OpenRead(fileName), false);
NuspecReader nuspecReader = await reader.GetNuspecReaderAsync(CancellationToken.None);
string identity = nuspecReader.GetId();
IEnumerable <FrameworkSpecificGroup> groups = await reader.GetLibItemsAsync(CancellationToken.None);
FrameworkSpecificGroup group = groups.Where(x => x.TargetFramework.GetShortFolderName().StartsWith("netstandard")).OrderByDescending(x => x.TargetFramework.GetShortFolderName()).FirstOrDefault();
foreach (string packageFile in group.Items)
{
if (!packageFile.EndsWith(".dll"))
{
continue;
}
string tmpPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
string path = reader.ExtractFile(packageFile, tmpPath, NullLogger.Instance);
//Type type = Load(await File.ReadAllBytesAsync(path));
Type type = Load(path);
if (type != null)// 为null时则不是插件程序集， 但不一定不是依赖程序集
{
PluginContext context = new PluginContext();
PluginMeta meta = new PluginMeta(identity, fileName, Path.Combine(Environment.CurrentDirectory, "plugins", identity));
context.Meta = meta;
if (!Directory.Exists(meta.SpaceDirectory))
{
Directory.CreateDirectory(meta.SpaceDirectory);
FrameworkSpecificGroup item = (await reader.GetContentItemsAsync(CancellationToken.None)).FirstOrDefault();
if (item != null)
{
foreach (string file in item.Items)
{
if (file.EndsWith('/') || file.EndsWith('\\'))
{
continue;
}
ZipArchiveEntry entry = reader.GetEntry(file);
entry.SaveAsFile(Path.Combine(meta.SpaceDirectory, file.Substring(8)), NullLogger.Instance);
}
}
}
string configFile = Path.Combine(meta.SpaceDirectory, "config.json");
if (File.Exists(configFile))
{
context.Configuration = new Lazy <IConfiguration>(() =>
{
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddJsonFile(configFile);
return(builder.Build());
});
}
else
{
context.Configuration = new Lazy <IConfiguration>(() => (new ConfigurationBuilder().Build()));
}
string dataFile = Path.Combine(meta.SpaceDirectory, "data.db");
context.Repository = new Lazy <IRepository>(() => new LiteDbRepository(new LiteDatabase(dataFile)));
plugins.Add(type, context);
}
}
}
private static bool IsValid(FrameworkSpecificGroup frameworkSpecificGroup)
{
if (frameworkSpecificGroup != null)
{
return (frameworkSpecificGroup.HasEmptyFolder
|| frameworkSpecificGroup.Items.Any()
|| !frameworkSpecificGroup.TargetFramework.Equals(NuGetFramework.AnyFramework));
}
return false;
}
private static FrameworkSpecificGroup Normalize(FrameworkSpecificGroup group)
{
// Default to returning the same group
FrameworkSpecificGroup result = group;
// If the group is null or it does not contain any items besides _._ then this is a no-op.
// If it does have items create a new normalized group to replace it with.
if (group?.Items.Any() == true)
{
// Filter out invalid files
IEnumerable<string> normalizedItems = GetValidPackageItems(group.Items)
.Select(PathUtility.ReplaceAltDirSeparatorWithDirSeparator);
// Create a new group
result = new FrameworkSpecificGroup(group.TargetFramework, normalizedItems);
}
return result;
}
public bool IsPassed(FrameworkSpecificGroup group) => group.TargetFramework.IsAny;
internal static bool IsValid(FrameworkSpecificGroup frameworkSpecificGroup)
{
return(frameworkSpecificGroup != null && frameworkSpecificGroup.Items != null &&
(frameworkSpecificGroup.Items.Any() || !frameworkSpecificGroup.TargetFramework.Equals(NuGetFramework.AnyFramework)));
}
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();
}
}
internal static void AddFiles(IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem,
IPackageCoreReader packageReader,
FrameworkSpecificGroup frameworkSpecificGroup,
IDictionary <FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
var packageTargetFramework = frameworkSpecificGroup.TargetFramework;
var packageItemListAsArchiveEntryNames = frameworkSpecificGroup.Items.ToList();
packageItemListAsArchiveEntryNames.Sort(new PackageItemComparer());
try
{
try
{
var paths = packageItemListAsArchiveEntryNames.Select(file => ResolvePath(fileTransformers, fte => fte.InstallExtension,
GetEffectivePathForContentFile(packageTargetFramework, file)));
paths = paths.Where(p => !string.IsNullOrEmpty(p));
msBuildNuGetProjectSystem.BeginProcessing();
msBuildNuGetProjectSystem.RegisterProcessedFiles(paths);
}
catch (Exception)
{
// Ignore all exceptions for now
}
foreach (var file in packageItemListAsArchiveEntryNames)
{
if (IsEmptyFolder(file))
{
continue;
}
var effectivePathForContentFile = GetEffectivePathForContentFile(packageTargetFramework, file);
// Resolve the target path
IPackageFileTransformer installTransformer;
var path = ResolveTargetPath(msBuildNuGetProjectSystem,
fileTransformers,
fte => fte.InstallExtension, effectivePathForContentFile, out installTransformer);
if (msBuildNuGetProjectSystem.IsSupportedFile(path))
{
if (installTransformer != null)
{
installTransformer.TransformFile(() => packageReader.GetStream(file), path, msBuildNuGetProjectSystem);
}
else
{
// Ignore uninstall transform file during installation
string truncatedPath;
var uninstallTransformer =
FindFileTransformer(fileTransformers, fte => fte.UninstallExtension, effectivePathForContentFile, out truncatedPath);
if (uninstallTransformer != null)
{
continue;
}
TryAddFile(msBuildNuGetProjectSystem, path, () => packageReader.GetStream(file));
}
}
}
}
finally
{
msBuildNuGetProjectSystem.EndProcessing();
}
}
internal static void AddFiles(IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem,
ZipArchive zipArchive,
FrameworkSpecificGroup frameworkSpecificGroup,
IDictionary<FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
var packageTargetFramework = frameworkSpecificGroup.TargetFramework;
// Content files are maintained with AltDirectorySeparatorChar
List<string> packageItemListAsArchiveEntryNames = frameworkSpecificGroup.Items.Select(i => PathUtility.ReplaceDirSeparatorWithAltDirSeparator(i)).ToList();
packageItemListAsArchiveEntryNames.Sort(new PackageItemComparer());
try
{
var zipArchiveEntryList = packageItemListAsArchiveEntryNames.Select(i => zipArchive.GetEntry(i)).Where(i => i != null).ToList();
try
{
var paths = zipArchiveEntryList.Select(file => ResolvePath(fileTransformers, fte => fte.InstallExtension,
GetEffectivePathForContentFile(packageTargetFramework, file.FullName)));
paths = paths.Where(p => !String.IsNullOrEmpty(p));
msBuildNuGetProjectSystem.BeginProcessing(paths);
}
catch (Exception)
{
// Ignore all exceptions for now
}
foreach (ZipArchiveEntry zipArchiveEntry in zipArchiveEntryList)
{
if (zipArchiveEntry == null)
{
throw new ArgumentNullException("zipArchiveEntry");
}
if (IsEmptyFolder(zipArchiveEntry.FullName))
{
continue;
}
var effectivePathForContentFile = GetEffectivePathForContentFile(packageTargetFramework, zipArchiveEntry.FullName);
// Resolve the target path
IPackageFileTransformer installTransformer;
string path = ResolveTargetPath(msBuildNuGetProjectSystem,
fileTransformers,
fte => fte.InstallExtension, effectivePathForContentFile, out installTransformer);
if (msBuildNuGetProjectSystem.IsSupportedFile(path))
{
if (installTransformer != null)
{
installTransformer.TransformFile(zipArchiveEntry, path, msBuildNuGetProjectSystem);
}
else
{
// Ignore uninstall transform file during installation
string truncatedPath;
IPackageFileTransformer uninstallTransformer =
FindFileTransformer(fileTransformers, fte => fte.UninstallExtension, effectivePathForContentFile, out truncatedPath);
if (uninstallTransformer != null)
{
continue;
}
TryAddFile(msBuildNuGetProjectSystem, path, zipArchiveEntry.Open);
}
}
}
}
finally
{
msBuildNuGetProjectSystem.EndProcessing();
}
}
internal static bool IsValid(FrameworkSpecificGroup frameworkSpecificGroup)
{
return (frameworkSpecificGroup != null && frameworkSpecificGroup.Items != null &&
(frameworkSpecificGroup.Items.Any() || !frameworkSpecificGroup.TargetFramework.Equals(NuGetFramework.AnyFramework)));
}