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 packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
logger: NullLogger.Instance,
signedPackageVerifier: null,
signedPackageVerifierSettings: null);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDirectory);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
packageFileInfo.FullName,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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_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 packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
logger: logger,
signedPackageVerifier: null);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDir);
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(
identity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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 PackageExpander_ExpandsPackage_SkipsIfShaIsThere()
{
// Arrange
using (var package = TestPackagesCore.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
using (var packagesDir = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
clientPolicyContext: null,
logger: logger);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDir);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
Directory.CreateDirectory(packageDir);
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
var shaPath = pathResolver.GetNupkgMetadataPath(package.Id, identity.Version);
File.WriteAllBytes(shaPath, new byte[] { });
Assert.True(File.Exists(shaPath));
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
package.File.FullName,
identity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
identity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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 LocalPackageInfo AddPackage(LocalPackageInfo package)
{
var ct = CancellationToken.None;
var destPackageDir = _pathResolver.GetPackageDirectory(package.Identity.Id, package.Identity.Version);
var destPackagePath = _pathResolver.GetPackageFilePath(package.Identity.Id, package.Identity.Version);
_fileSystem.MakeDirectoryForFile(destPackagePath);
using (var downloader = new LocalPackageArchiveDownloader(package.Path, package.Identity, _logAdapter)) {
downloader.CopyNupkgFileToAsync(destPackagePath, ct).Wait();
var hashFilePath = Path.ChangeExtension(destPackagePath, PackagingCoreConstants.HashFileExtension);
var hash = downloader.GetPackageHashAsync("SHA512", ct).Result;
var hashBytes = Encoding.UTF8.GetBytes(hash);
_fileSystem.AddFile(hashFilePath, hashFileStream => { hashFileStream.Write(hashBytes, 0, hashBytes.Length); });
var nuspecPath = _pathResolver.GetManifestFilePath(package.Identity.Id, package.Identity.Version);
using (var nuspecStream = File.OpenWrite(nuspecPath)) {
using (var fs = downloader.CoreReader.GetNuspecAsync(ct).Result) {
fs.CopyTo(nuspecStream);
}
}
_log.DebugFormat("Saved manifest {0}", nuspecPath);
Lazy <NuspecReader> nuspecReader = new Lazy <NuspecReader>(() => new NuspecReader(nuspecPath));
var packageReader = new Func <PackageReaderBase>(() => new PackageArchiveReader(File.OpenRead(destPackagePath)));
return(new LocalPackageInfo(package.Identity, destPackagePath, package.LastWriteTimeUtc, nuspecReader, packageReader));
}
}
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 static RestoreTargetGraph GetRestoreTargetGraph(
string source,
PackageIdentity identity,
FileInfo packagePath,
TestLogger logger)
{
var libraryRange = new LibraryRange {
Name = identity.Id
};
var libraryIdentity = new LibraryIdentity(identity.Id, identity.Version, LibraryType.Package);
var dependencyProvider = new Mock <IRemoteDependencyProvider>();
IPackageDownloader packageDependency = null;
dependencyProvider
.Setup(x => x.GetPackageDownloaderAsync(
It.IsAny <PackageIdentity>(),
It.IsAny <SourceCacheContext>(),
It.IsAny <ILogger>(),
It.IsAny <CancellationToken>()))
.Callback <PackageIdentity, SourceCacheContext, ILogger, CancellationToken>(
(callbackIdentity, sourceCacheContext, callbackLogger, cancellationToken) =>
{
packageDependency = new LocalPackageArchiveDownloader(
source,
packagePath.FullName,
callbackIdentity,
callbackLogger);
})
.Returns(() => Task.FromResult(packageDependency));
var graph = RestoreTargetGraph.Create(
new[]
{
new GraphNode <RemoteResolveResult>(libraryRange)
{
Item = new GraphItem <RemoteResolveResult>(libraryIdentity)
{
Data = new RemoteResolveResult
{
Match = new RemoteMatch
{
Library = libraryIdentity,
Provider = dependencyProvider.Object
}
}
}
}
},
new TestRemoteWalkContext(),
logger,
FrameworkConstants.CommonFrameworks.NetStandard16);
return(graph);
}
private LocalPackageArchiveDownloaderTest(
TestDirectory testDirectory,
PackageIdentity packageIdentity,
FileInfo sourcePackageFile,
LocalPackageArchiveDownloader downloader)
{
TestDirectory = testDirectory;
PackageIdentity = packageIdentity;
SourcePackageFile = sourcePackageFile;
Downloader = downloader;
}
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 packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
logger: NullLogger.Instance,
signedPackageVerifier: null,
signedPackageVerifierSettings: null);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDirectory);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
packageFileInfo.FullName,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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);
using (var packagesDir = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
clientPolicyContext: null,
logger: logger);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDir);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
package.File.FullName,
identity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
identity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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");
}
}
}
public LocalPackageInfo AddPackage(Stream packageStream, bool allowOverwrite)
{
string tempFilePath = Path.Combine(this.Source, Path.GetRandomFileName() + PackagingCoreConstants.PackageDownloadMarkerFileExtension);
using (var dest = File.OpenWrite(tempFilePath)) {
packageStream.CopyTo(dest);
}
PackageIdentity identity;
string destPackagePath;
using (var archive = new PackageArchiveReader(File.OpenRead(tempFilePath))){
var id = archive.NuspecReader.GetId();
var version = archive.NuspecReader.GetVersion();
identity = new PackageIdentity(id, version);
destPackagePath = _pathResolver.GetPackageFilePath(id, version);
_fileSystem.MakeDirectoryForFile(destPackagePath);
}
var hashFilePath = Path.ChangeExtension(destPackagePath, PackagingCoreConstants.HashFileExtension);
if (!allowOverwrite && File.Exists(hashFilePath))
{
throw new PackageDuplicateException($"Package {identity} already exists");
}
if (File.Exists(destPackagePath))
{
File.Delete(destPackagePath);
}
File.Move(tempFilePath, destPackagePath);
var ct = CancellationToken.None;
using (var downloader = new LocalPackageArchiveDownloader(destPackagePath, identity, _logAdapter)) {
var hash = downloader.GetPackageHashAsync("SHA512", ct).Result;
var hashBytes = Encoding.UTF8.GetBytes(hash);
File.WriteAllBytes(hashFilePath, hashBytes);
var nuspecPath = _pathResolver.GetManifestFilePath(identity.Id, identity.Version);
using (var nuspecStream = File.OpenWrite(nuspecPath)) {
using (var stream = downloader.CoreReader.GetNuspecAsync(ct).Result){
stream.CopyTo(nuspecStream);
}
}
_log.DebugFormat("Saved manifest {0}", nuspecPath);
Lazy <NuspecReader> nuspecReader = new Lazy <NuspecReader>(() => new NuspecReader(nuspecPath));
var packageReader = new Func <PackageReaderBase>(() => new PackageArchiveReader(File.OpenRead(destPackagePath)));
return(new LocalPackageInfo(identity, destPackagePath, DateTime.UtcNow, nuspecReader, packageReader));
}
}
internal static async Task <LocalPackageArchiveDownloaderTest> CreateAsync()
{
var testDirectory = TestDirectory.Create();
var packageIdentity = new PackageIdentity(id: "a", version: NuGetVersion.Parse("1.0.0"));
var packageContext = new SimpleTestPackageContext()
{
Id = packageIdentity.Id,
Version = packageIdentity.Version.ToNormalizedString(),
Nuspec = XDocument.Parse($@"<?xml version=""1.0"" encoding=""utf-8""?>
<package>
<metadata>
<id>{packageIdentity.Id}</id>
<version>{packageIdentity.Version.ToNormalizedString()}</version>
<title />
<frameworkAssemblies>
<frameworkAssembly assemblyName=""System.Runtime"" />
</frameworkAssemblies>
<contentFiles>
<files include=""lib/net45/{packageIdentity.Id}.dll"" copyToOutput=""true"" flatten=""false"" />
</contentFiles>
</metadata>
</package>")
};
packageContext.AddFile($"lib/net45/{packageIdentity.Id}.dll");
await SimpleTestPackageUtility.CreatePackagesAsync(testDirectory.Path, packageContext);
var sourcePackageFilePath = Path.Combine(
testDirectory.Path,
$"{packageIdentity.Id}.{packageIdentity.Version.ToNormalizedString()}.nupkg");
var downloader = new LocalPackageArchiveDownloader(
testDirectory.Path,
sourcePackageFilePath,
packageIdentity,
NullLogger.Instance);
return(new LocalPackageArchiveDownloaderTest(
testDirectory,
packageIdentity,
new FileInfo(sourcePackageFilePath),
downloader));
}
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 packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Nuspec | PackageSaveMode.Nupkg,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
logger: NullLogger.Instance,
signedPackageVerifier: null,
signedPackageVerifierSettings: null);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDirectory);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
packageFileInfo,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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 Test_ExtractPackage()
{
// 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 packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
clientPolicyContext: null,
logger: NullLogger.Instance);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDirectory);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
packageFileInfo,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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");
AssertFileExists(packageVersionDirectory, "lib", "test.dll");
}
}
private static void AssertMyPackage(PhysicalFileSystem fileSystem, LocalPackageInfo package, LocalPackageInfo addedPackage)
{
string expectedPath = Path.Combine(fileSystem.Root, "mypackage", "1.0.0-beta2", "mypackage.1.0.0-beta2.nupkg");
Assert.Equal(expectedPath, addedPackage.Path);
// Assert
using (var fs = fileSystem.OpenFile(Path.Combine("mypackage", "1.0.0-beta2", "mypackage.nuspec"))){
var reader = Manifest.ReadFrom(fs, validateSchema: true);
Assert.Equal("MyPackage", reader.Metadata.Id);
Assert.Equal(NuGetVersion.Parse("1.0.0-beta2"), reader.Metadata.Version);
using (var file = File.OpenRead(package.Path))
{
Assert.True(file.ContentEquals(fileSystem.OpenFile(Path.Combine("mypackage", "1.0.0-beta2", "mypackage.1.0.0-beta2.nupkg"))));
file.Seek(0, SeekOrigin.Begin);
}
using (var downloader = new LocalPackageArchiveDownloader(package.Path, package.Identity, NullLogger.Instance)) {
var sha = downloader.GetPackageHashAsync("SHA512", CancellationToken.None).Result;
Assert.Equal(sha, fileSystem.ReadAllText(Path.Combine("mypackage", "1.0.0-beta2", "mypackage.1.0.0-beta2.nupkg.sha512")));
}
}
}
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 packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
logger: logger,
signedPackageVerifier: null,
signedPackageVerifierSettings: null);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDir);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
Assert.False(Directory.Exists(packageDir), packageDir + " exist");
var filePathToLock = Path.Combine(packageDir, "lib", "net40", "two.dll");
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
package.File.FullName,
identity,
logger))
{
var cts = new CancellationTokenSource(DefaultTimeOut);
Func <CancellationToken, Task <bool> > action = (ct) =>
{
Assert.ThrowsAnyAsync <IOException>(async() =>
await PackageExtractor.InstallFromSourceAsync(
identity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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 packageDownloader = new LocalPackageArchiveDownloader(
null,
package.File.FullName,
identity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
identity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
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));
}
}
public async Task CopyPackagesToOriginalCaseAsync(IEnumerable <RestoreTargetGraph> graphs, CancellationToken token)
{
// Keep track of the packages we've already converted to original case.
var converted = new HashSet <PackageIdentity>();
var originalCaseContext = GetPathContext();
var versionFolderPathResolver = new VersionFolderPathResolver(_request.PackagesDirectory, _request.IsLowercasePackagesDirectory);
// Iterate over every package node.
foreach (var graph in graphs)
{
var packages = graph
.Flattened
.Select(graphItem => graphItem.Data.Match)
.Where(remoteMatch => remoteMatch.Library.Type == LibraryType.Package);
foreach (var remoteMatch in packages)
{
var identity = GetPackageIdentity(remoteMatch);
var hashPath = _pathResolver.GetNupkgMetadataPath(identity.Id, identity.Version);
// No need to re-install the same package identity more than once or if it is
// already installed.
if (!converted.Add(identity) || File.Exists(hashPath))
{
continue;
}
var localPackageSourceInfo = GetLocalPackageSourceInfo(remoteMatch);
var packageIdentity = new PackageIdentity(remoteMatch.Library.Name, remoteMatch.Library.Version);
IPackageDownloader packageDependency = null;
if (string.IsNullOrEmpty(localPackageSourceInfo?.Package.ZipPath))
{
packageDependency = await remoteMatch.Provider.GetPackageDownloaderAsync(
packageIdentity,
_request.CacheContext,
_request.Log,
token);
}
else
{
packageDependency = new LocalPackageArchiveDownloader(
localPackageSourceInfo.Repository.RepositoryRoot,
localPackageSourceInfo.Package.ZipPath,
packageIdentity,
_request.Log);
}
// Install the package.
using (packageDependency)
{
var result = await PackageExtractor.InstallFromSourceAsync(
identity,
packageDependency,
versionFolderPathResolver,
originalCaseContext,
token,
ParentId);
if (result)
{
_request.Log.LogMinimal(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_ConvertedPackageToOriginalCase,
identity));
}
}
}
}
}
public static async Task AddPackageToSource(
OfflineFeedAddContext offlineFeedAddContext,
CancellationToken token)
{
if (offlineFeedAddContext == null)
{
throw new ArgumentNullException(nameof(offlineFeedAddContext));
}
token.ThrowIfCancellationRequested();
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
{
var packageSaveMode = offlineFeedAddContext.Expand
? PackageSaveMode.Defaultv3
: PackageSaveMode.Nuspec | PackageSaveMode.Nupkg;
var signedPackageVerifier = new PackageSignatureVerifier(
SignatureVerificationProviderFactory.GetSignatureVerificationProviders(),
SignedPackageVerifierSettings.Default);
var packageExtractionContext = new PackageExtractionContext(
packageSaveMode,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier);
var versionFolderPathResolver = new VersionFolderPathResolver(source);
using (var packageDownloader = new LocalPackageArchiveDownloader(
packagePath,
packageIdentity,
logger))
{
// Set Empty parentId here.
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
token,
Guid.Empty);
}
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);
}
}
}
}
