public VersionFolderPathContext(
PackageIdentity package,
string packagesDirectory,
bool isLowercasePackagesDirectory,
ILogger logger,
PackageSaveMode packageSaveMode,
XmlDocFileSaveMode xmlDocFileSaveMode)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (string.IsNullOrEmpty(packagesDirectory))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
Strings.StringCannotBeNullOrEmpty,
nameof(packagesDirectory)));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
Package = package;
PackagesDirectory = packagesDirectory;
IsLowercasePackagesDirectory = isLowercasePackagesDirectory;
Logger = logger;
PackageSaveMode = packageSaveMode;
XmlDocFileSaveMode = xmlDocFileSaveMode;
}
public override void AddPackage(IPackage package)
{
if (PackageSaveMode.HasFlag(PackageSaveModes.Nuspec))
{
// Starting from 2.1, we save the nuspec file into the subdirectory with the name as <packageId>.<version>
// for example, for jQuery version 1.0, it will be "jQuery.1.0\\jQuery.1.0.nuspec"
string packageFilePath = GetManifestFilePath(package.Id, package.Version);
Manifest manifest = Manifest.Create(package);
// The IPackage object doesn't carry the References information.
// Thus we set the References for the manifest to the set of all valid assembly references
manifest.Metadata.ReferenceSets = package.AssemblyReferences
.GroupBy(f => f.TargetFramework)
.Select(
g => new ManifestReferenceSet
{
TargetFramework = g.Key == null ? null : VersionUtility.GetFrameworkString(g.Key),
References = g.Select(p => new ManifestReference {
File = p.Name
}).ToList()
})
.ToList();
FileSystem.AddFileWithCheck(packageFilePath, manifest.Save);
}
if (PackageSaveMode.HasFlag(PackageSaveModes.Nupkg))
{
string packageFilePath = GetPackageFilePath(package);
FileSystem.AddFileWithCheck(packageFilePath, package.GetStream);
}
}
/// <summary>
/// Determines if a package is installed based on the provided package save mode.
/// </summary>
/// <param name="packageIdentity">A package identity.</param>
/// <param name="packageSaveMode">A package save mode.</param>
/// <returns>A flag indicating whether or not the package is installed.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" />
/// is <c>null</c>.</exception>
public bool PackageExists(PackageIdentity packageIdentity, PackageSaveMode packageSaveMode)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
var packageExists = !string.IsNullOrEmpty(GetInstalledPackageFilePath(packageIdentity));
var manifestExists = !string.IsNullOrEmpty(GetInstalledManifestFilePath(packageIdentity));
if (!packageExists)
{
packageExists |= !string.IsNullOrEmpty(GetPackageDownloadMarkerFilePath(packageIdentity));
}
// A package must have either a nupkg or a nuspec to be valid
var result = packageExists || manifestExists;
// Verify nupkg present if specified
if ((packageSaveMode & PackageSaveMode.Nupkg) == PackageSaveMode.Nupkg)
{
result &= packageExists;
}
// Verify nuspec present if specified
if ((packageSaveMode & PackageSaveMode.Nuspec) == PackageSaveMode.Nuspec)
{
result &= manifestExists;
}
return(result);
}
/// <summary>
/// Create a v3 folder of nupkgs
/// </summary>
public static async Task CreateFolderFeedV3(string root, PackageSaveMode saveMode, params string[] nupkgPaths)
{
var pathResolver = new VersionFolderPathResolver(root);
foreach (var file in nupkgPaths)
{
PackageIdentity identity = null;
using (var reader = new PackageArchiveReader(File.OpenRead(file)))
{
identity = reader.GetIdentity();
}
if (!File.Exists(pathResolver.GetHashPath(identity.Id, identity.Version)))
{
using (var fileStream = File.OpenRead(file))
{
await PackageExtractor.InstallFromSourceAsync(
identity,
(stream) => fileStream.CopyToAsync(stream, 4096, CancellationToken.None),
new VersionFolderPathResolver(root),
new PackageExtractionContext(
saveMode,
XmlDocFileSaveMode.None,
NullLogger.Instance,
signedPackageVerifier : null),
CancellationToken.None);
}
}
}
}
public VersionFolderPathContext(
PackageIdentity package,
string packagesDirectory,
ILogger logger,
bool fixNuspecIdCasing,
PackageSaveMode packageSaveMode,
bool normalizeFileNames,
XmlDocFileSaveMode xmlDocFileSaveMode)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (string.IsNullOrEmpty(packagesDirectory))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
Strings.StringCannotBeNullOrEmpty,
nameof(packagesDirectory)));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
Package = package;
PackagesDirectory = packagesDirectory;
Logger = logger;
FixNuspecIdCasing = fixNuspecIdCasing;
PackageSaveMode = packageSaveMode;
NormalizeFileNames = normalizeFileNames;
XmlDocFileSaveMode = xmlDocFileSaveMode;
}
void PackageHelper_IsPackageFile_False(string file, PackageSaveMode packageSaveMode)
{
// Arrange & Act
var isPackageFile = PackageHelper.IsPackageFile(file, packageSaveMode);
// Assert
Assert.False(isPackageFile);
}
public void IsPackageFile_ReturnsFalseForNonPackageFile(string file, PackageSaveMode packageSaveMode)
{
// Arrange & Act
var isPackageFile = PackageHelper.IsPackageFile(file, packageSaveMode);
// Assert
Assert.False(isPackageFile);
}
/// <summary>
/// Create a v3 folder of nupkgs
/// </summary>
public static async Task CreateFolderFeedV3(string root, PackageSaveMode saveMode, params SimpleTestPackageContext[] contexts)
{
using (var tempRoot = TestDirectory.Create())
{
CreatePackages(tempRoot, contexts);
await CreateFolderFeedV3(root, saveMode, Directory.GetFiles(tempRoot));
}
}
public static async Task <IEnumerable <string> > GetPackageFilesAsync(
this IAsyncPackageCoreReader packageReader,
PackageSaveMode packageSaveMode,
CancellationToken cancellationToken)
{
return((await packageReader
.GetFilesAsync(cancellationToken))
.Where(file => PackageHelper.IsPackageFile(file, packageSaveMode)));
}
public async Task PackageExists_PackageIdentityPackageSaveMode_ReturnsTrueIfDefaultv3Installed(
PackageSaveMode packageSaveMode)
{
using (var test = new FolderNuGetProjectTest())
{
await test.InstallAsync(packageSaveMode);
Assert.True(test.Project.PackageExists(test.PackageIdentity, PackageSaveMode.Defaultv3));
}
}
public PackageExtractionContext(
PackageSaveMode packageSaveMode,
XmlDocFileSaveMode xmlDocFileSaveMode,
ILogger logger,
IPackageSignatureVerifier signedPackageVerifier)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
PackageSaveMode = packageSaveMode;
XmlDocFileSaveMode = xmlDocFileSaveMode;
SignedPackageVerifier = signedPackageVerifier;
}
public PackageExtractionContext(
PackageSaveMode packageSaveMode,
XmlDocFileSaveMode xmlDocFileSaveMode,
ClientPolicyContext clientPolicyContext,
ILogger logger)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
PackageSaveMode = packageSaveMode;
XmlDocFileSaveMode = xmlDocFileSaveMode;
ClientPolicyContext = clientPolicyContext;
}
/// <summary>
/// Determines if a package is installed based on the provided package save mode.
/// </summary>
/// <param name="packageIdentity">A package identity.</param>
/// <param name="packageSaveMode">A package save mode.</param>
/// <returns>A flag indicating whether or not the package is installed.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" />
/// is <c>null</c>.</exception>
public bool PackageExists(PackageIdentity packageIdentity, PackageSaveMode packageSaveMode)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
var nupkgPath = GetInstalledPackageFilePath(packageIdentity);
var nuspecPath = GetInstalledManifestFilePath(packageIdentity);
var packageExists = !string.IsNullOrEmpty(nupkgPath);
var manifestExists = !string.IsNullOrEmpty(nuspecPath);
// When using -ExcludeVersion check that the actual package version matches.
if (!PackagePathResolver.UseSideBySidePaths)
{
if (packageExists)
{
using (var reader = new PackageArchiveReader(nupkgPath))
{
packageExists = packageIdentity.Equals(reader.NuspecReader.GetIdentity());
}
}
if (manifestExists)
{
var reader = new NuspecReader(nuspecPath);
packageExists = packageIdentity.Equals(reader.GetIdentity());
}
}
if (!packageExists)
{
packageExists |= !string.IsNullOrEmpty(GetPackageDownloadMarkerFilePath(packageIdentity));
}
// A package must have either a nupkg or a nuspec to be valid
var result = packageExists || manifestExists;
// Verify nupkg present if specified
if ((packageSaveMode & PackageSaveMode.Nupkg) == PackageSaveMode.Nupkg)
{
result &= packageExists;
}
// Verify nuspec present if specified
if ((packageSaveMode & PackageSaveMode.Nuspec) == PackageSaveMode.Nuspec)
{
result &= manifestExists;
}
return(result);
}
public PackageExtractionTelemetryEvent(
PackageSaveMode packageSaveMode,
NuGetOperationStatus status,
ExtractionSource extractionSource,
PackageIdentity packageId) :
base(EventName, new Dictionary <string, object>
{
{ nameof(Status), status },
{ nameof(ExtractionSource), extractionSource },
{ nameof(PackageSaveMode), packageSaveMode }
})
{
AddPiiData(nameof(PackageId), packageId.ToString());
}
public VersionFolderPathContext(
PackageIdentity package,
string packagesDirectory,
ILogger logger,
PackageSaveMode packageSaveMode,
XmlDocFileSaveMode xmlDocFileSaveMode) : this(
package,
packagesDirectory,
isLowercasePackagesDirectory : true,
logger : logger,
packageSaveMode : packageSaveMode,
xmlDocFileSaveMode : xmlDocFileSaveMode)
{
}
internal async Task InstallAsync(PackageSaveMode packageSaveMode)
{
using (var result = GetDownloadResourceResult(Package))
{
var projectContext = new TestNuGetProjectContext();
projectContext.PackageExtractionContext.PackageSaveMode = packageSaveMode;
await Project.InstallPackageAsync(
PackageIdentity,
result,
projectContext,
CancellationToken.None);
}
}
private static async Task <IEnumerable <string> > CopySatelliteFilesAsync(
PackageReaderBase packageReader,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageReader == null)
{
throw new ArgumentNullException(nameof(packageReader));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
await VerifyPackageSignatureAsync(packageReader.GetIdentity(), packageExtractionContext, packageReader, token);
var satelliteFilesCopied = Enumerable.Empty <string>();
var result = await PackageHelper.GetSatelliteFilesAsync(packageReader, packagePathResolver, token);
var runtimePackageDirectory = result.Item1;
var satelliteFiles = result.Item2
.Where(file => PackageHelper.IsPackageFile(file, packageSaveMode))
.ToList();
if (satelliteFiles.Count > 0)
{
var packageFileExtractor = new PackageFileExtractor(satelliteFiles, packageExtractionContext.XmlDocFileSaveMode);
// Now, add all the satellite files collected from the package to the runtime package folder(s)
satelliteFilesCopied = await packageReader.CopyFilesAsync(
runtimePackageDirectory,
satelliteFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token);
}
return(satelliteFilesCopied);
}
public async Task GetPackageFilesAsync_ReturnsFiles(PackageSaveMode packageSaveMode)
{
var packageFiles = (await PackageReaderExtensions.GetPackageFilesAsync(
_coreReader.Object,
packageSaveMode,
CancellationToken.None)).ToArray();
Assert.Equal(new[]
{
"b",
"/c/a.nuspec",
@"\c/a.nuspec",
"/c/d",
@"\c\d"
}, packageFiles);
}
public PackageExtractionTelemetryEvent(
PackageSaveMode packageSaveMode,
NuGetOperationStatus status,
ExtractionSource extractionSource,
PackageIdentity packageId = null) :
base(EventName, new Dictionary <string, object>
{
{ nameof(Status), status },
{ nameof(ExtractionSource), extractionSource },
{ nameof(PackageSaveMode), packageSaveMode }
})
{
if (packageId != null)
{
LogPackageIdentity(packageId);
}
}
private static IEnumerable <string> CopySatelliteFiles(
PackageReaderBase packageReader,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageReader == null)
{
throw new ArgumentNullException(nameof(packageReader));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
var satelliteFilesCopied = Enumerable.Empty <string>();
string runtimePackageDirectory;
var satelliteFiles = PackageHelper
.GetSatelliteFiles(packageReader, packagePathResolver, out runtimePackageDirectory)
.Where(file => PackageHelper.IsPackageFile(file, packageSaveMode))
.ToList();
if (satelliteFiles.Count > 0)
{
var packageFileExtractor = new PackageFileExtractor(satelliteFiles, packageExtractionContext.XmlDocFileSaveMode);
// Now, add all the satellite files collected from the package to the runtime package folder(s)
satelliteFilesCopied = packageReader.CopyFiles(
runtimePackageDirectory,
satelliteFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token);
}
return(satelliteFilesCopied);
}
/// <summary>
/// This returns all the installed package files (does not include satellite files)
/// </summary>
public static IEnumerable <ZipFilePair> GetInstalledPackageFiles(
PackageArchiveReader packageReader,
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode)
{
var installedPackageFiles = Enumerable.Empty <ZipFilePair>();
var packageDirectory = packagePathResolver.GetInstalledPath(packageIdentity);
if (!string.IsNullOrEmpty(packageDirectory))
{
var packageFiles = packageReader.GetPackageFiles(packageSaveMode);
var entries = packageReader.EnumeratePackageEntries(packageFiles, packageDirectory);
installedPackageFiles = entries.Where(e => e.IsInstalled());
}
return(installedPackageFiles.ToList());
}
public static Tuple <string, IEnumerable <ZipFilePair> > GetInstalledSatelliteFiles(
PackageArchiveReader packageReader,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode)
{
var installedSatelliteFiles = Enumerable.Empty <ZipFilePair>();
string runtimePackageDirectory;
var satelliteFiles = GetSatelliteFiles(packageReader, packagePathResolver, out runtimePackageDirectory);
if (satelliteFiles.Any())
{
var satelliteFileEntries = packageReader.EnumeratePackageEntries(
satelliteFiles.Where(f => IsPackageFile(f, packageSaveMode)),
runtimePackageDirectory);
installedSatelliteFiles = satelliteFileEntries.Where(e => e.IsInstalled());
}
return(new Tuple <string, IEnumerable <ZipFilePair> >(runtimePackageDirectory, installedSatelliteFiles.ToList()));
}
/// <summary>
/// This returns all the installed package files (does not include satellite files)
/// </summary>
public static async Task <IEnumerable <ZipFilePair> > GetInstalledPackageFilesAsync(
PackageArchiveReader packageReader,
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
CancellationToken cancellationToken)
{
var installedPackageFiles = Enumerable.Empty <ZipFilePair>();
var packageDirectory = packagePathResolver.GetInstalledPath(packageIdentity);
if (!string.IsNullOrEmpty(packageDirectory))
{
var packageFiles = await packageReader.GetPackageFilesAsync(packageSaveMode, cancellationToken);
var entries = packageReader.EnumeratePackageEntries(packageFiles, packageDirectory);
installedPackageFiles = entries.Where(e => e.IsInstalled());
}
return(installedPackageFiles.ToList());
}
public override void AddPackage(IPackage package)
{
string packageFilePath = GetPackageFilePath(package);
if (PackageSaveMode.HasFlag(PackageSaveModes.Nuspec))
{
string manifestFilePath = GetManifestFilePath(package.Id, package.Version);
Manifest manifest = Manifest.Create(package);
manifest.Metadata.ReferenceSets = Enumerable.ToList <ManifestReferenceSet>(Enumerable.Select <IGrouping <FrameworkName, IPackageAssemblyReference>, ManifestReferenceSet>(Enumerable.GroupBy <IPackageAssemblyReference, FrameworkName>(package.AssemblyReferences, (Func <IPackageAssemblyReference, FrameworkName>)(f => f.TargetFramework)), (Func <IGrouping <FrameworkName, IPackageAssemblyReference>, ManifestReferenceSet>)(g => new ManifestReferenceSet()
{
TargetFramework = g.Key == (FrameworkName)null ? (string)null : VersionUtility.GetFrameworkString(g.Key),
References = Enumerable.ToList <ManifestReference>(Enumerable.Select <IPackageAssemblyReference, ManifestReference>((IEnumerable <IPackageAssemblyReference>)g, (Func <IPackageAssemblyReference, ManifestReference>)(p => new ManifestReference()
{
File = p.Name
})))
})));
FileSystem.AddFileWithCheck(manifestFilePath, manifest.Save);
}
FileSystem.AddFileWithCheck(packageFilePath, package.GetStream);
}
public static bool IsPackageFile(string packageFileName, PackageSaveMode packageSaveMode)
{
if (String.IsNullOrEmpty(packageFileName) ||
String.IsNullOrEmpty(Path.GetFileName(packageFileName)))
{
// This is to ignore archive entries that are not really files
return(false);
}
if (IsManifest(packageFileName))
{
return((packageSaveMode & PackageSaveMode.Nuspec) == PackageSaveMode.Nuspec);
}
if ((packageSaveMode & PackageSaveMode.Files) == PackageSaveMode.Files)
{
return(!ExcludePaths.Any(p => packageFileName.StartsWith(p, StringComparison.OrdinalIgnoreCase)) &&
!packageFileName.EndsWith(ExcludeExtension, StringComparison.OrdinalIgnoreCase));
}
return(false);
}
public bool PackageExists(PackageIdentity packageIdentity, PackageSaveMode packageSaveMode)
{
var packageExists = !string.IsNullOrEmpty(GetInstalledPackageFilePath(packageIdentity));
var manifestExists = !string.IsNullOrEmpty(GetInstalledManifestFilePath(packageIdentity));
// A package must have either a nupkg or a nuspec to be valid
var result = packageExists || manifestExists;
// Verify nupkg present if specified
if ((packageSaveMode & PackageSaveMode.Nupkg) == PackageSaveMode.Nupkg)
{
result &= packageExists;
}
// Verify nuspec present if specified
if ((packageSaveMode & PackageSaveMode.Nuspec) == PackageSaveMode.Nuspec)
{
result &= manifestExists;
}
return(result);
}
public static async Task <Tuple <string, IEnumerable <ZipFilePair> > > GetInstalledSatelliteFilesAsync(
PackageArchiveReader packageReader,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
CancellationToken cancellationToken)
{
var installedSatelliteFiles = Enumerable.Empty <ZipFilePair>();
var result = await GetSatelliteFilesAsync(packageReader, packagePathResolver, cancellationToken);
var runtimePackageDirectory = result.Item1;
var satelliteFiles = result.Item2;
if (satelliteFiles.Any())
{
var satelliteFileEntries = packageReader.EnumeratePackageEntries(
satelliteFiles.Where(f => IsPackageFile(f, packageSaveMode)),
runtimePackageDirectory);
installedSatelliteFiles = satelliteFileEntries.Where(e => e.IsInstalled());
}
return(new Tuple <string, IEnumerable <ZipFilePair> >(runtimePackageDirectory, installedSatelliteFiles.ToList()));
}
public static async Task <IEnumerable <string> > CopySatelliteFilesAsync(
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
var satelliteFilesCopied = Enumerable.Empty <string>();
var nupkgFilePath = packagePathResolver.GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(nupkgFilePath))
{
using (var packageReader = new PackageArchiveReader(nupkgFilePath))
{
return(await CopySatelliteFilesAsync(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
}
return(satelliteFilesCopied);
}
public override void AddPackage(IPackage package)
{
string packageFilePath = GetPackageFilePath(package);
FileSystem.AddFileWithCheck(packageFilePath, package.GetStream);
// allow the file to finish being written
Thread.Sleep(200);
if (PackageSaveMode.HasFlag(PackageSaveModes.Nuspec))
{
// don't trust the package metadata to be complete - extract from the downloaded nupkg
var zipPackage = new OptimizedZipPackage(FileSystem, packageFilePath);
string manifestFilePath = GetManifestFilePath(package.Id, package.Version);
Manifest manifest = Manifest.Create(zipPackage);
manifest.Metadata.ReferenceSets = Enumerable.ToList <ManifestReferenceSet>(Enumerable.Select <IGrouping <FrameworkName, IPackageAssemblyReference>, ManifestReferenceSet>(Enumerable.GroupBy <IPackageAssemblyReference, FrameworkName>(package.AssemblyReferences, (Func <IPackageAssemblyReference, FrameworkName>)(f => f.TargetFramework)), (Func <IGrouping <FrameworkName, IPackageAssemblyReference>, ManifestReferenceSet>)(g => new ManifestReferenceSet()
{
TargetFramework = g.Key == (FrameworkName)null ? (string)null : VersionUtility.GetFrameworkString(g.Key),
References = Enumerable.ToList <ManifestReference>(Enumerable.Select <IPackageAssemblyReference, ManifestReference>((IEnumerable <IPackageAssemblyReference>)g, (Func <IPackageAssemblyReference, ManifestReference>)(p => new ManifestReference()
{
File = p.Name
})))
})));
FileSystem.AddFileWithCheck(manifestFilePath, manifest.Save);
}
}
/// <summary>
/// Create a v3 folder of nupkgs
/// </summary>
public static async Task CreateFolderFeedV3(string root, PackageSaveMode saveMode, params PackageIdentity[] packages)
{
var contexts = packages.Select(p => new SimpleTestPackageContext(p)).ToArray();
await CreateFolderFeedV3(root, saveMode, contexts);
}
