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); } } } }