private async ThreadingTask InstallFromStream(Task <Stream> getStream, PackageIdentity package,
string packagesFolder, CancellationToken token)
{
bool isValid = true;
if (OfflineFeedUtility.PackageExists(package, packagesFolder, out isValid))
{
return;
}
var logger = new NugetMsBuildLogger(new TaskLoggingHelper(this));
var versionFolderPathContext = new VersionFolderPathContext(
package,
packagesFolder,
isLowercasePackagesDirectory: false,
logger: logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
await PackageExtractor.InstallFromSourceAsync(
async dest =>
{
var source = await getStream;
await source.CopyToAsync(dest, bufferSize: DefaultBufferSize, cancellationToken: token);
},
versionFolderPathContext,
token);
}
private async ThreadingTask InstallFromStream(Task<Stream> getStream, PackageIdentity package,
string packagesFolder, CancellationToken token)
{
bool isValid = true;
if (OfflineFeedUtility.PackageExists(package, packagesFolder, out isValid))
{
return;
}
var logger = new NugetMsBuildLogger(new TaskLoggingHelper(this));
var versionFolderPathContext = new VersionFolderPathContext(
package,
packagesFolder,
isLowercasePackagesDirectory: false,
logger: logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
await PackageExtractor.InstallFromSourceAsync(
async dest =>
{
var source = await getStream;
await source.CopyToAsync(dest, bufferSize: DefaultBufferSize, cancellationToken: token);
},
versionFolderPathContext,
token);
}
/// <summary>
/// Installs the package.
/// </summary>
/// <param name="match">NuGet package match.</param>
/// <param name="path">Installation path</param>
/// <returns>Task</returns>
/// <seealso cref="INuGetEngine.GetPackageTargetPath" />
public Task InstallPackage(RemoteMatch match, string path)
{
var packageIdentity = new PackageIdentity(match.Library.Name, match.Library.Version);
if (match.Provider == null)
{
Console.WriteLine("Invalid match provider!");
throw new Exception("invalid match provider for " + packageIdentity);
}
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
path,
_nuGetLogger,
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None);
return(PackageExtractor.InstallFromSourceAsync(
stream => match.Provider.CopyToAsync(
match.Library,
stream,
_cache,
_nuGetLogger,
CancellationToken.None),
versionFolderPathContext,
CancellationToken.None));
}
public static async Task InstallFromStream(Task <Stream> getStream, PackageIdentity package, string packagesFolder, CancellationToken token)
{
bool isValid = true;
if (OfflineFeedUtility.PackageExists(package, packagesFolder, out isValid))
{
return;
}
var logger = NuGetConsoleLogger.Instance;
var versionFolderPathContext = new VersionFolderPathContext(
package,
packagesFolder,
isLowercasePackagesDirectory: false,
logger: logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
await PackageExtractor.InstallFromSourceAsync(
async dest =>
{
var source = await getStream;
await source.CopyToAsync(dest);
},
versionFolderPathContext,
token);
}
public static async Task Extract (
Solution solution,
PackageIdentity packageIdentity,
DownloadResourceResult downloadResult,
CancellationToken token)
{
string globalPackagesFolder = await GetPackagesDirectory (solution);
var defaultPackagePathResolver = new VersionFolderPathResolver (globalPackagesFolder);
string hashPath = defaultPackagePathResolver.GetHashPath (packageIdentity.Id, packageIdentity.Version);
if (File.Exists (hashPath))
return;
var versionFolderPathContext = new VersionFolderPathContext (
packageIdentity,
globalPackagesFolder,
NullLogger.Instance,
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode);
downloadResult.PackageStream.Position = 0;
await PackageExtractor.InstallFromSourceAsync (
stream => downloadResult.PackageStream.CopyToAsync (stream, BufferSize, token),
versionFolderPathContext,
token);
}
public static async Task Extract(
Solution solution,
PackageIdentity packageIdentity,
DownloadResourceResult downloadResult,
CancellationToken token)
{
string globalPackagesFolder = await GetPackagesDirectory(solution);
var defaultPackagePathResolver = new VersionFolderPathResolver(globalPackagesFolder);
string hashPath = defaultPackagePathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version);
if (File.Exists(hashPath))
{
return;
}
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
globalPackagesFolder,
NullLogger.Instance,
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode);
downloadResult.PackageStream.Position = 0;
await PackageExtractor.InstallFromSourceAsync(
stream => downloadResult.PackageStream.CopyToAsync(stream, BufferSize, token),
versionFolderPathContext,
token);
}
public async Task PackageExpander_Recovers_WhenStreamIsCorrupt()
{
// Arrange
using (var package = TestPackagesCore.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestDirectory.Create();
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var versionFolderPathContext = new VersionFolderPathContext(
identity,
packagesDir,
logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
Assert.False(Directory.Exists(packageDir), packageDir + " exist");
// Act
using (var packageDownloader = new ThrowingPackageArchiveDownloader(
package.File.FullName,
identity,
logger))
{
await Assert.ThrowsAnyAsync <CorruptionException>(async() =>
await PackageExtractor.InstallFromSourceAsync(
packageDownloader,
versionFolderPathContext,
token));
}
AssertDirectoryExists(packageDir, packageDir + " does not exist");
Assert.NotEmpty(Directory.EnumerateFiles(packageDir));
using (var packageDownloader = new LocalPackageArchiveDownloader(
package.File.FullName,
identity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
packageDownloader,
versionFolderPathContext,
token);
}
// Assert
var filePath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(filePath), filePath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
}
}
public async Task PackageExpander_CleansExtraFiles()
{
// Arrange
using (var package = TestPackagesCore.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestDirectory.Create();
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var versionFolderPathContext = new VersionFolderPathContext(
identity,
packagesDir,
logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
var randomFile = Path.Combine(packageDir, package.Id + "." + package.Version + ".random");
Directory.CreateDirectory(packageDir);
File.WriteAllBytes(randomFile, new byte[] { });
var randomFolder = Path.Combine(packageDir, "random");
Directory.CreateDirectory(randomFolder);
Assert.True(File.Exists(randomFile), randomFile + " does not exist");
AssertDirectoryExists(randomFolder);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
package.File.FullName,
identity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
packageDownloader,
versionFolderPathContext,
token);
}
// Assert
AssertDirectoryExists(packageDir, packageDir + " does not exist");
var filePath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(filePath), filePath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
Assert.False(File.Exists(randomFile), randomFile + " does exist");
Assert.False(Directory.Exists(randomFolder), randomFolder + " does exist");
}
}
public async Task Test_ExtractionIgnoresNupkgHashFile()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageFileInfo = await TestPackagesCore.GetPackageWithSHA512AtRoot(
packagesDirectory,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
packagesDirectory,
NullLogger.Instance,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
packageFileInfo.FullName,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageDownloader,
versionFolderPathContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);
AssertDirectoryExists(packageVersionDirectory);
AssertFileExists(packageVersionDirectory, pathResolver.GetPackageFilePath(packageIdentity.Id, packageIdentity.Version));
AssertFileExists(packageVersionDirectory, pathResolver.GetManifestFileName(packageIdentity.Id, packageIdentity.Version));
AssertFileExists(packageVersionDirectory, "lib", "net45", "A.dll");
var hashPath = pathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version);
var hashFileInfo = new FileInfo(hashPath);
Assert.True(File.Exists(hashFileInfo.FullName));
Assert.NotEqual(0, hashFileInfo.Length);
var bsha512Path = Path.Combine(packageVersionDirectory, "lib", "net45", "B.sha512");
var bsha512FileInfo = new FileInfo(bsha512Path);
Assert.True(File.Exists(bsha512FileInfo.FullName));
Assert.Equal(0, bsha512FileInfo.Length);
var csha512Path = Path.Combine(packageVersionDirectory, "C.sha512");
var csha512FileInfo = new FileInfo(csha512Path);
Assert.True(File.Exists(csha512FileInfo.FullName));
Assert.Equal(0, csha512FileInfo.Length);
}
}
public async Task PackageExpander_ExpandsPackage_SkipsIfShaIsThere()
{
// Arrange
using (var package = TestPackagesCore.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestDirectory.Create();
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var versionFolderPathContext = new VersionFolderPathContext(
identity,
packagesDir,
logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
Directory.CreateDirectory(packageDir);
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
var shaPath = pathResolver.GetHashPath(package.Id, identity.Version);
File.WriteAllBytes(shaPath, new byte[] { });
Assert.True(File.Exists(shaPath));
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
package.File.FullName,
identity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
packageDownloader,
versionFolderPathContext,
token);
}
// Assert
AssertDirectoryExists(packageDir, packageDir + " does not exist");
Assert.False(File.Exists(nupkgPath), nupkgPath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.False(File.Exists(dllPath), dllPath + " does not exist");
Assert.Equal(1, Directory.EnumerateFiles(packageDir).Count());
}
}
public async Task Test_ExtractionIgnoresNupkgFile()
{
// Arrange
var package = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageFileInfo = await TestPackagesCore.GetPackageWithNupkgAtRoot(
packagesDirectory,
package.Id,
package.Version.ToNormalizedString());
var versionFolderPathContext = new VersionFolderPathContext(
package,
packagesDirectory,
NullLogger.Instance,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var packageFileStream = packageFileInfo.OpenRead())
{
await PackageExtractor.InstallFromSourceAsync(
stream => packageFileStream.CopyToAsync(stream),
versionFolderPathContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(package.Id, package.Version);
AssertDirectoryExists(packageVersionDirectory);
AssertFileExists(packageVersionDirectory, pathResolver.GetPackageFilePath(package.Id, package.Version));
AssertFileExists(packageVersionDirectory, pathResolver.GetManifestFileName(package.Id, package.Version));
AssertFileExists(packageVersionDirectory, "lib", "net45", "A.dll");
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, package.Version);
var nupkgFileInfo = new FileInfo(nupkgPath);
Assert.True(File.Exists(nupkgFileInfo.FullName));
Assert.NotEqual(0, nupkgFileInfo.Length);
var bnupkgPath = Path.Combine(packageVersionDirectory, "lib", "net45", "B.nupkg");
var bnupkgFileInfo = new FileInfo(bnupkgPath);
Assert.True(File.Exists(bnupkgFileInfo.FullName));
Assert.Equal(0, bnupkgFileInfo.Length);
}
}
public static async Task <DownloadResourceResult> AddPackageAsync(PackageIdentity packageIdentity,
Stream packageStream,
ISettings settings,
ILogger logger,
CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (packageStream == null)
{
throw new ArgumentNullException(nameof(packageStream));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
// The following call adds it to the global packages folder.
// Addition is performed using ConcurrentUtils, such that,
// multiple processes may add at the same time
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
globalPackagesFolder,
logger,
fixNuspecIdCasing: false,
packageSaveMode: PackageSaveMode.Defaultv3,
normalizeFileNames: false,
xmlDocFileSaveMode: PackageExtractionBehavior.XmlDocFileSaveMode);
await PackageExtractor.InstallFromSourceAsync(
stream => packageStream.CopyToAsync(stream, bufferSize: 8192, cancellationToken: token),
versionFolderPathContext,
token : token);
var package = GetPackage(packageIdentity, settings);
Debug.Assert(package.PackageStream.CanSeek);
Debug.Assert(package.PackageReader != null);
return(package);
}
private async Task InstallPackageAsync(RemoteMatch installItem, string packagesDirectory, CancellationToken token)
{
var packageIdentity = new PackageIdentity(installItem.Library.Name, installItem.Library.Version);
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
packagesDirectory,
_logger,
packageSaveMode: _request.PackageSaveMode,
xmlDocFileSaveMode: _request.XmlDocFileSaveMode);
await PackageExtractor.InstallFromSourceAsync(
stream => installItem.Provider.CopyToAsync(installItem.Library, stream, token),
versionFolderPathContext,
token);
}
public static async Task <DownloadResourceResult> AddPackageAsync(
PackageIdentity packageIdentity,
Stream packageStream,
string globalPackagesFolder,
ILogger logger,
CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (packageStream == null)
{
throw new ArgumentNullException(nameof(packageStream));
}
if (globalPackagesFolder == null)
{
throw new ArgumentNullException(nameof(globalPackagesFolder));
}
// The following call adds it to the global packages folder.
// Addition is performed using ConcurrentUtils, such that,
// multiple processes may add at the same time
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
globalPackagesFolder,
logger,
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode);
await PackageExtractor.InstallFromSourceAsync(
stream => packageStream.CopyToAsync(stream, BufferSize, token),
versionFolderPathContext,
token);
var package = GetPackage(packageIdentity, globalPackagesFolder);
Debug.Assert(package.PackageStream.CanSeek);
Debug.Assert(package.PackageReader != null);
return(package);
}
public async Task Test_ExtractionHonorsFileTimestamp()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
var entryModifiedTime = new DateTimeOffset(1985, 11, 20, 12, 0, 0, TimeSpan.FromHours(-7.0)).DateTime;
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageFileInfo = await TestPackagesCore.GeneratePackageAsync(
packagesDirectory,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString(),
entryModifiedTime,
"lib/net45/A.dll");
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
packagesDirectory,
NullLogger.Instance,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
packageFileInfo.FullName,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageDownloader,
versionFolderPathContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);
AssertDirectoryExists(packageVersionDirectory);
var dllPath = Path.Combine(packageVersionDirectory, "lib", "net45", "A.dll");
var dllFileInfo = new FileInfo(dllPath);
AssertFileExists(dllFileInfo.FullName);
Assert.Equal(entryModifiedTime, dllFileInfo.LastWriteTime);
}
}
public async Task PackageExpander_ExpandsPackage_WithNupkgCopy()
{
// Arrange
using (var package = TestPackagesCore.GetPackageWithNupkgCopy())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestDirectory.Create();
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var versionFolderPathContext = new VersionFolderPathContext(
identity,
packagesDir,
logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
package.File.FullName,
identity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
packageDownloader,
versionFolderPathContext,
token);
}
// Assert
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
AssertDirectoryExists(packageDir, packageDir + " does not exist");
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(nupkgPath), nupkgPath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
}
}
/// <summary>
/// Add a nupkg to the global package folder.
/// </summary>
public static async Task AddPackageToGlobalFolderAsync(string packagePath, string globalFolder)
{
using (var reader = new PackageArchiveReader(packagePath))
{
var pathContext = new VersionFolderPathContext(
package: reader.GetIdentity(),
packagesDirectory: globalFolder,
logger: Common.NullLogger.Instance,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
using (var stream = File.OpenRead(packagePath))
{
await PackageExtractor.InstallFromSourceAsync(async (d) => await stream.CopyToAsync(d),
pathContext,
CancellationToken.None);
}
}
}
public Task InstallPackage(RemoteMatch match, string path)
{
var packageIdentity = new PackageIdentity(match.Library.Name, match.Library.Version);
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
path,
_nuGetLogger,
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None);
return(PackageExtractor.InstallFromSourceAsync(
stream => match.Provider.CopyToAsync(
match.Library,
stream,
_cache,
_nuGetLogger,
CancellationToken.None),
versionFolderPathContext,
CancellationToken.None));
}
public static void ExpandPackageFiles(IEnumerable <PackageInfo> processedPackages, string expandDirectory)
{
Parallel.ForEach(processedPackages, package =>
{
Log.WriteInformation($"Expanding {package.Identity}.");
using (var inputStream = File.OpenRead(package.PackagePath))
{
var versionFolderPathContext = new VersionFolderPathContext(
package.Identity,
expandDirectory,
NullLogger.Instance,
packageSaveMode: PackageSaveMode.Nupkg | PackageSaveMode.Nuspec,
xmlDocFileSaveMode: XmlDocFileSaveMode.Skip);
PackageExtractor.InstallFromSourceAsync(
inputStream.CopyToAsync,
versionFolderPathContext,
default(CancellationToken)).Wait();
}
});
}
public async Task Test_ExtractionDoesNotExtractFiles_IfPackageSaveModeDoesNotIncludeFiles()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
using (var packageFileInfo = TestPackagesCore.GetLegacyTestPackage())
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
packagesDirectory,
NullLogger.Instance,
packageSaveMode: PackageSaveMode.Nupkg | PackageSaveMode.Nuspec,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
packageFileInfo,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageDownloader,
versionFolderPathContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);
AssertDirectoryExists(packageVersionDirectory);
AssertFileExists(packageVersionDirectory, pathResolver.GetPackageFileName(packageIdentity.Id, packageIdentity.Version));
AssertFileExists(packageVersionDirectory, pathResolver.GetManifestFileName(packageIdentity.Id, packageIdentity.Version));
AssertFileExists(packageVersionDirectory, "packagea.2.0.3.nupkg.sha512");
Assert.False(File.Exists(Path.Combine(packageVersionDirectory, "lib", "test.dll")));
}
}
public async Task PackageExpander_ExpandsPackage()
{
// Arrange
using (var package = TestPackages.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestFileSystemUtility.CreateRandomTestFolder();
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var versionFolderPathContext = new VersionFolderPathContext(
identity,
packagesDir,
logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var stream = package.File.OpenRead())
{
await PackageExtractor.InstallFromSourceAsync(async (d) => await stream.CopyToAsync(d),
versionFolderPathContext,
token);
}
// Assert
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
AssertDirectoryExists(packageDir, packageDir + " does not exist");
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(nupkgPath), nupkgPath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
}
}
private async Task InstallPackageAsync(RemoteMatch installItem, CancellationToken token)
{
var packageIdentity = new PackageIdentity(installItem.Library.Name, installItem.Library.Version);
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
_request.PackagesDirectory,
_logger,
_request.PackageSaveMode,
_request.XmlDocFileSaveMode);
using (var packageDependency = await installItem.Provider.GetPackageDownloaderAsync(
packageIdentity,
_request.CacheContext,
_logger,
token))
{
await PackageExtractor.InstallFromSourceAsync(
packageDependency,
versionFolderPathContext,
token);
}
}
private async Task InstallPackageAsync(RemoteMatch installItem, NuGetv3LocalRepository userPackageFolder, CancellationToken token)
{
var packageIdentity = new PackageIdentity(installItem.Library.Name, installItem.Library.Version);
// Check if the package has already been installed.
if (!userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version))
{
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
_request.PackagesDirectory,
_logger,
_request.PackageSaveMode,
_request.XmlDocFileSaveMode);
using (var packageDependency = await installItem.Provider.GetPackageDownloaderAsync(
packageIdentity,
_request.CacheContext,
_logger,
token))
{
// Install, returns true if the package was actually installed.
// Returns false if the package was a noop once the lock
// was acquired.
var installed = await PackageExtractor.InstallFromSourceAsync(
packageDependency,
versionFolderPathContext,
token);
if (installed)
{
// If the package was added, clear the cache so that the next caller can see it.
// Avoid calling this for packages that were not actually installed.
userPackageFolder.ClearCacheForIds(new string[] { packageIdentity.Id });
}
}
}
}
public async Task Test_ExtractNuspecOnly()
{
// Arrange
var package = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
using (var packageFileInfo = TestPackagesCore.GetLegacyTestPackage())
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var versionFolderPathContext = new VersionFolderPathContext(
package,
packagesDirectory,
NullLogger.Instance,
packageSaveMode: PackageSaveMode.Nuspec | PackageSaveMode.Nupkg,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var packageFileStream = File.OpenRead(packageFileInfo))
{
await PackageExtractor.InstallFromSourceAsync(
stream => packageFileStream.CopyToAsync(stream),
versionFolderPathContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(package.Id, package.Version);
AssertDirectoryExists(packageVersionDirectory);
AssertFileExists(packageVersionDirectory, pathResolver.GetPackageFileName(package.Id, package.Version));
AssertFileExists(packageVersionDirectory, pathResolver.GetManifestFileName(package.Id, package.Version));
AssertFileExists(packageVersionDirectory, "packagea.2.0.3.nupkg.sha512");
Assert.False(File.Exists(Path.Combine(packageVersionDirectory, "lib", "test.dll")));
}
}
public static async Task AddPackageToSource(
OfflineFeedAddContext offlineFeedAddContext,
CancellationToken token)
{
var packagePath = offlineFeedAddContext.PackagePath;
var source = offlineFeedAddContext.Source;
var logger = offlineFeedAddContext.Logger;
using (var packageStream = File.OpenRead(packagePath))
{
try
{
var packageReader = new PackageArchiveReader(packageStream, leaveStreamOpen: true);
var packageIdentity = packageReader.GetIdentity();
bool isValidPackage;
if (PackageExists(packageIdentity, source, out isValidPackage))
{
// Package already exists. Verify if it is valid
if (isValidPackage)
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.AddPackage_PackageAlreadyExists,
packageIdentity,
source);
if (offlineFeedAddContext.ThrowIfPackageExists)
{
throw new ArgumentException(message);
}
else
{
logger.LogMinimal(message);
}
}
else
{
var message = string.Format(CultureInfo.CurrentCulture,
Strings.AddPackage_ExistingPackageInvalid,
packageIdentity,
source);
if (offlineFeedAddContext.ThrowIfPackageExistsAndInvalid)
{
throw new ArgumentException(message);
}
else
{
logger.LogWarning(message);
}
}
}
else
{
packageStream.Seek(0, SeekOrigin.Begin);
var packageSaveMode = offlineFeedAddContext.Expand
? PackageSaveMode.Defaultv3
: PackageSaveMode.Nuspec | PackageSaveMode.Nupkg;
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
source,
logger,
packageSaveMode: packageSaveMode,
xmlDocFileSaveMode: PackageExtractionBehavior.XmlDocFileSaveMode);
await PackageExtractor.InstallFromSourceAsync(
stream => packageStream.CopyToAsync(stream),
versionFolderPathContext,
token);
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.AddPackage_SuccessfullyAdded,
packagePath,
source);
logger.LogMinimal(message);
}
}
// Mono will throw ArchiveException when package is invalid.
// Reading Nuspec in invalid package on Mono will get PackagingException
catch (Exception ex) when(ex is InvalidDataException ||
(RuntimeEnvironmentHelper.IsMono &&
(ex.GetType().FullName.Equals("SharpCompress.Common.ArchiveException") ||
ex is PackagingException)))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.NupkgPath_Invalid,
packagePath);
if (offlineFeedAddContext.ThrowIfSourcePackageIsInvalid)
{
throw new ArgumentException(message);
}
else
{
logger.LogWarning(message);
}
}
}
}
public static void InstallPackage(IReadOnlyList <string> packages, bool quiet)
{
Init();
RemoteWalkContext context = new RemoteWalkContext();
ILogger logger = new NullLogger();
SourceCacheContext cacheContext = new SourceCacheContext
{
IgnoreFailedSources = true
};
foreach (SourceRepository repo in Repos)
{
if (!repo.PackageSource.IsLocal)
{
context.RemoteLibraryProviders.Add(new SourceRepositoryDependencyProvider(repo, logger, cacheContext));
}
else
{
context.LocalLibraryProviders.Add(new SourceRepositoryDependencyProvider(repo, logger, cacheContext));
}
}
Paths.User.Content.CreateDirectory();
RemoteDependencyWalker walker = new RemoteDependencyWalker(context);
HashSet <Package> remainingPackages = new HashSet <Package>(packages.Select(x => new Package(x, VersionRange.All)));
HashSet <Package> encounteredPackages = new HashSet <Package>();
List <string> templateRoots = new List <string>();
List <KeyValuePair <string, string> > componentRoots = new List <KeyValuePair <string, string> >();
while (remainingPackages.Count > 0)
{
HashSet <Package> nextRound = new HashSet <Package>();
foreach (Package package in remainingPackages)
{
string name = package.PackageId;
GraphNode <RemoteResolveResult> result = walker.WalkAsync(new LibraryRange(name, package.Version, LibraryDependencyTarget.All), NuGetFramework.AnyFramework, "", RuntimeGraph.Empty, true).Result;
RemoteMatch match = result.Item.Data.Match;
PackageIdentity packageIdentity = new PackageIdentity(match.Library.Name, match.Library.Version);
nextRound.UnionWith(result.Item.Data.Dependencies.Select(x => new Package(x.Name, x.LibraryRange.VersionRange)));
VersionFolderPathContext versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
Paths.User.PackageCache,
new NullLogger(),
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.Skip,
fixNuspecIdCasing: true,
normalizeFileNames: true);
if (match.Library.Version == null)
{
if (!quiet)
{
throw new Exception($"Package '{package.PackageId}' version {package.Version} could not be located.");
}
else
{
continue;
}
}
string source = Path.Combine(Paths.User.PackageCache, match.Library.Name, match.Library.Version.ToString());
if (!source.Exists() && match.Provider != null)
{
PackageExtractor.InstallFromSourceAsync(
stream => match.Provider.CopyToAsync(match.Library, stream, CancellationToken.None),
versionFolderPathContext,
CancellationToken.None).Wait();
string target = Path.Combine(Paths.User.Content, match.Library.Name);
target.CreateDirectory();
target = Path.Combine(target, match.Library.Version.ToString());
target.CreateDirectory();
Paths.Copy(source, target);
target.Delete("*.nupkg", "*.nupkg.*");
string nuspec = target.EnumerateFiles("*.nuspec").FirstOrDefault();
//If there's a nuspec, figure out whether this package is a template and walk the dependency graph
if (nuspec?.Exists() ?? false)
{
XDocument doc = XDocument.Load(nuspec);
IReadOnlyList <PackageType> types = NuspecUtility.GetPackageTypes(doc.Root.Element(XName.Get("metadata", "http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd")), false);
//If the thing we got is a template...
if (types.Any(x => string.Equals(x.Name, "template", StringComparison.OrdinalIgnoreCase)))
{
templateRoots.Add(target);
}
else
{
componentRoots.Add(new KeyValuePair <string, string>(match.Library.Name, match.Library.Version.ToString()));
}
}
}
}
encounteredPackages.UnionWith(remainingPackages);
nextRound.ExceptWith(encounteredPackages);
remainingPackages = nextRound;
}
foreach (KeyValuePair <string, string> package in componentRoots)
{
foreach (string path in Path.Combine(Paths.User.Content, package.Key, package.Value).EnumerateFiles($"{package.Key}.dll", SearchOption.AllDirectories))
{
if (path.IndexOf($"{Path.DirectorySeparatorChar}lib{Path.DirectorySeparatorChar}", StringComparison.OrdinalIgnoreCase) < 0 ||
(path.IndexOf($"{Path.DirectorySeparatorChar}netstandard1.", StringComparison.OrdinalIgnoreCase) < 0 &&
path.IndexOf($"{Path.DirectorySeparatorChar}netcoreapp1.", StringComparison.OrdinalIgnoreCase) < 0))
{
continue;
}
#if !NET451
Assembly asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(path);
#else
Assembly asm = Assembly.LoadFile(path);
#endif
foreach (Type type in asm.GetTypes())
{
SettingsLoader.Components.Register(type);
}
}
}
TemplateCache.Scan(templateRoots);
}
public static async Task AddPackageToSource(
OfflineFeedAddContext offlineFeedAddContext,
CancellationToken token)
{
var packagePath = offlineFeedAddContext.PackagePath;
var source = offlineFeedAddContext.Source;
var logger = offlineFeedAddContext.Logger;
using (var packageStream = File.OpenRead(packagePath))
{
try
{
var packageReader = new PackageArchiveReader(packageStream, leaveStreamOpen: true);
var packageIdentity = packageReader.GetIdentity();
bool isValidPackage;
if (PackageExists(packageIdentity, source, out isValidPackage))
{
// Package already exists. Verify if it is valid
if (isValidPackage)
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.AddPackage_PackageAlreadyExists,
packageIdentity,
source);
if (offlineFeedAddContext.ThrowIfPackageExists)
{
throw new ArgumentException(message);
}
else
{
logger.LogMinimal(message);
}
}
else
{
var message = string.Format(CultureInfo.CurrentCulture,
Strings.AddPackage_ExistingPackageInvalid,
packageIdentity,
source);
if (offlineFeedAddContext.ThrowIfPackageExistsAndInvalid)
{
throw new ArgumentException(message);
}
else
{
logger.LogWarning(message);
}
}
}
else
{
packageStream.Seek(0, SeekOrigin.Begin);
var packageSaveMode = offlineFeedAddContext.Expand
? PackageSaveMode.Defaultv3
: PackageSaveMode.Nuspec | PackageSaveMode.Nupkg;
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
source,
logger,
fixNuspecIdCasing: false,
packageSaveMode: packageSaveMode,
normalizeFileNames: true,
xmlDocFileSaveMode: PackageExtractionBehavior.XmlDocFileSaveMode);
await PackageExtractor.InstallFromSourceAsync(
stream => packageStream.CopyToAsync(stream),
versionFolderPathContext,
token);
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.AddPackage_SuccessfullyAdded,
packagePath,
source);
logger.LogMinimal(message);
}
}
catch (InvalidDataException)
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.NupkgPath_Invalid,
packagePath);
if (offlineFeedAddContext.ThrowIfSourcePackageIsInvalid)
{
throw new ArgumentException(message);
}
else
{
logger.LogWarning(message);
}
}
}
}
public async Task PackageExpander_Recovers_WhenFileIsLocked()
{
// Arrange
using (var package = TestPackagesCore.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestDirectory.Create();
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var versionFolderPathContext = new VersionFolderPathContext(
identity,
packagesDir,
logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
Assert.False(Directory.Exists(packageDir), packageDir + " exist");
string filePathToLock = Path.Combine(packageDir, "lib", "net40", "two.dll");
// Act
using (var stream = package.File.OpenRead())
{
var cts = new CancellationTokenSource(DefaultTimeOut);
Func <CancellationToken, Task <bool> > action = (ct) => {
Assert.ThrowsAnyAsync <IOException>(async() =>
await PackageExtractor.InstallFromSourceAsync(
str => stream.CopyToAsync(stream, bufferSize: 8192, cancellationToken: token),
versionFolderPathContext,
token));
return(Task.FromResult(true));
};
await ConcurrencyUtilities.ExecuteWithFileLockedAsync(filePathToLock, action, cts.Token);
}
AssertDirectoryExists(packageDir, packageDir + " does not exist");
Assert.NotEmpty(Directory.EnumerateFiles(packageDir));
using (var stream = package.File.OpenRead())
{
await PackageExtractor.InstallFromSourceAsync(async (d) => await stream.CopyToAsync(d),
versionFolderPathContext,
token);
}
// Assert
var filePath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(filePath), filePath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
Assert.True(File.Exists(filePathToLock));
// Make sure the actual file from the zip was extracted
Assert.Equal(new byte[] { 0 }, File.ReadAllBytes(filePathToLock));
}
}
