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);
}
private string GetPackageDirectoryFullPath(LockFilePackageLibrary library, string nugetPackagesRoot)
{
var packageDirectory = new VersionFolderPathResolver(nugetPackagesRoot)
.GetInstallPath(library.Name, library.Version);
return packageDirectory;
}
private string GetCommandFilePath(string nugetPackagesRoot, LockFileTargetLibrary toolLibrary, LockFileItem runtimeAssembly)
{
var packageDirectory = new VersionFolderPathResolver(nugetPackagesRoot)
.GetInstallPath(toolLibrary.Name, toolLibrary.Version);
var filePath = Path.Combine(packageDirectory, runtimeAssembly.Path);
return filePath;
}
public async Task PackageExpander_ExpandsPackage()
{
// 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);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
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 void AddCommand_Fail_PackageAlreadyExistsAndInvalid()
{
// Arrange
using (var testInfo = new TestInfo())
{
testInfo.Init();
var args = new string[]
{
"add",
testInfo.RandomNupkgFilePath,
"-Source",
testInfo.SourceParamFolder
};
// Act
var result = CommandRunner.Run(
testInfo.NuGetExePath,
testInfo.WorkingPath,
string.Join(" ", args),
waitForExit: true);
// Assert
Util.VerifyResultSuccess(result);
Util.VerifyPackageExists(testInfo.Package, testInfo.SourceParamFolder);
var versionFolderPathResolver = new VersionFolderPathResolver(testInfo.SourceParamFolder);
File.Delete(
versionFolderPathResolver.GetManifestFilePath(testInfo.Package.Id, testInfo.Package.Version));
// Main Act
result = CommandRunner.Run(
testInfo.NuGetExePath,
testInfo.WorkingPath,
string.Join(" ", args),
waitForExit: true);
// Assert
Util.VerifyResultFailure(result, string.Format(
NuGetResources.AddCommand_ExistingPackageInvalid,
testInfo.Package.ToString(),
testInfo.SourceParamFolder));
}
}
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);
}
}
protected void CreateInitNuGetProject()
{
var solutionManager = PackageManagementServices.Workspace.GetSolutionManager(project.ParentSolution);
nugetProject = solutionManager.GetNuGetProject(project);
if (nugetProject is INuGetIntegratedProject)
{
PackagesFolderPath = SettingsUtility.GetGlobalPackagesFolder(solutionManager.Settings);
packagePathResolver = new VersionFolderPathResolver(
PackagesFolderPath);
}
else
{
PackagesFolderPath = nugetProject.GetPackagesFolderPath(solutionManager);
folder = new FolderNuGetProject(PackagesFolderPath);
}
}
public static LockFileTargetLibrary CreateLockFileTargetLibrary(
LockFileLibrary library,
LocalPackageInfo package,
RestoreTargetGraph targetGraph,
VersionFolderPathResolver defaultPackagePathResolver,
string correctedPackageName,
LibraryIncludeFlags dependencyType)
{
return(CreateLockFileTargetLibrary(
library,
package,
targetGraph,
defaultPackagePathResolver,
correctedPackageName,
dependencyType: dependencyType,
targetFrameworkOverride: null,
dependencies: null));
}
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 FallbackPackagePathResolver_FindPackageInFallbackFolder_WithOnlyHashFile()
{
// Arrange
using (var mockBaseDirectory = TestDirectory.Create())
{
var userFolder = Path.Combine(mockBaseDirectory, "global");
var fallbackFolders = new List <string>()
{
Path.Combine(mockBaseDirectory, "fallback1"),
Path.Combine(mockBaseDirectory, "fallback2"),
};
Directory.CreateDirectory(userFolder);
foreach (var fallback in fallbackFolders)
{
Directory.CreateDirectory(fallback);
}
var saveMode = PackageSaveMode.Nuspec | PackageSaveMode.Files;
var targetFolder = fallbackFolders[0];
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
targetFolder,
saveMode,
new PackageIdentity("a", NuGetVersion.Parse("1.0.0")));
// delete .nupkg.metadata file
var localResolver = new VersionFolderPathResolver(targetFolder);
File.Delete(localResolver.GetNupkgMetadataPath("a", NuGetVersion.Parse("1.0.0")));
var expected = Path.Combine(targetFolder, "a", "1.0.0");
var resolver = new FallbackPackagePathResolver(userFolder, fallbackFolders);
// Act
var path = resolver.GetPackageDirectory("a", "1.0.0");
// Assert
Assert.Equal(expected, path);
}
}
public void LocalPackageFileCache_DirNotFoundVerifyFailure()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
var nuspec = pathResolver.GetManifestFilePath(identity.Id, identity.Version);
var expanded = pathResolver.GetInstallPath(identity.Id, identity.Version);
// Verify does not throw
var result = cache.GetOrAddNuspec(nuspec, expanded);
// This should throw
Assert.Throws <DirectoryNotFoundException>(() => result.Value);
}
}
public async Task NuGetv3LocalRepository_GenerateNupkgMetadataFile()
{
using (var workingDir = TestDirectory.Create())
{
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext("foo", "1.0.0"));
var pathResolver = new VersionFolderPathResolver(workingDir);
File.Delete(pathResolver.GetNupkgMetadataPath("foo", new NuGetVersion("1.0.0")));
// Assert
target.Exists("foo", NuGetVersion.Parse("1.0.0")).Should().BeTrue();
File.Exists(pathResolver.GetNupkgMetadataPath("foo", new NuGetVersion("1.0.0")));
}
}
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");
}
}
public AppDomainContext LoadPackageAssemblies(
string appDomainId,
NuGetFramework framework,
PackageIdentity packageIdentity)
{
var pathResolver = new VersionFolderPathResolver(_settings.GlobalPackagesFolder);
var hashPath = pathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version);
if (!File.Exists(hashPath))
{
throw new InvalidOperationException($"The package '{packageIdentity}' could not found.");
}
var installPath = pathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);
using (var packageReader = new PackageFolderReader(installPath))
{
var conventions = new ManagedCodeConventions(null);
var criteria = conventions.Criteria.ForFramework(framework);
var files = packageReader
.GetFiles()
.Select(p => p.Replace(Path.DirectorySeparatorChar, AssetDirectorySeparator))
.ToList();
var contentItems = new ContentItemCollection();
contentItems.Load(files);
var runtimeGroup = contentItems.FindBestItemGroup(
criteria,
conventions.Patterns.RuntimeAssemblies);
var appDomainContext = _loader.GetAppDomainContext(appDomainId);
foreach (var asset in runtimeGroup.Items)
{
var absolutePath = Path.Combine(installPath, asset.Path.Replace(AssetDirectorySeparator, Path.DirectorySeparatorChar));
_loader.LoadAssembly(appDomainContext, absolutePath);
}
return(appDomainContext);
}
}
/// <summary>
/// Discover nupkgs from a v3 local folder.
/// </summary>
/// <param name="root">Folder root.</param>
/// <param name="id">Package id or package id prefix.</param>
public static IEnumerable <LocalPackageInfo> GetPackagesV3(string root, string id, ILogger log)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
// Check for package files one level deep.
DirectoryInfo rootDirectoryInfo = GetAndVerifyRootDirectory(root);
var idRoot = new DirectoryInfo(Path.Combine(rootDirectoryInfo.FullName, id));
if (!idRoot.Exists)
{
// Directory is missing
yield break;
}
var pathResolver = new VersionFolderPathResolver(root);
foreach (var versionDir in GetDirectoriesSafe(idRoot, log))
{
var package = GetPackageV3(root, id, versionDir.Name, log);
if (package != null)
{
yield return(package);
}
}
yield break;
}
public LoginViewModel(IModuleManager moduleManager, IModuleCatalog catalog, IRegionManager regionManager, IWindowService windowService,
ModulesOptions options, VersionFolderPathResolver versionResolver, MazeRestClientWrapper restClientWrapper)
{
_moduleManager = moduleManager;
_catalog = catalog;
_regionManager = regionManager;
_windowService = windowService;
_options = options;
_versionResolver = versionResolver;
_restClientWrapper = restClientWrapper;
var settingsFile = new FileInfo(SettingsFilename);
if (settingsFile.Exists)
{
var settings = JsonConvert.DeserializeObject <ServerConnectionInfo>(File.ReadAllText(settingsFile.FullName));
ServerUrl = settings.ServerUrl;
Username = settings.Username;
}
}
public async Task LocalPackageFileCache_FallbackToFolderReaderVerifyResult()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
identity);
var nuspec = pathResolver.GetManifestFilePath(identity.Id, identity.Version) + "invalid.nuspec";
var expanded = pathResolver.GetInstallPath(identity.Id, identity.Version);
var result = cache.GetOrAddNuspec(nuspec, expanded);
result.Value.GetIdentity().Should().Be(identity);
}
}
public OriginalCaseGlobalPackageFolder(RestoreRequest request, Guid parentId)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
_request = request;
_localRepositories = new List <NuGetv3LocalRepository>();
_localRepositories.Add(request.DependencyProviders.GlobalPackages);
_localRepositories.AddRange(request.DependencyProviders.FallbackPackageFolders);
_pathResolver = new VersionFolderPathResolver(
_request.PackagesDirectory,
_request.IsLowercasePackagesDirectory);
_toolPathResolver = new ToolPathResolver(
_request.PackagesDirectory,
_request.IsLowercasePackagesDirectory);
}
public static async Task <bool> DownloadPackage(NuGetVersion packageVersion, string installPath)
{
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3(ApiNugetUrl);
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
string packageId = PackageName;
var packageIdentity = new PackageIdentity(packageId, packageVersion);
var downloader = await resource.GetPackageDownloaderAsync(packageIdentity, cache, logger, cancellationToken);
var settings = Settings.LoadDefaultSettings(installPath);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(settings, logger), logger);
var versionFolderPathResolver = new VersionFolderPathResolver(installPath);
return(await PackageExtractor.InstallFromSourceAsync(packageIdentity, downloader, versionFolderPathResolver, packageExtractionContext, cancellationToken));
}
public async Task CopyPackagesToOriginalCaseAsync_WhenPackageComesFromLocalFolder_ConvertsPackagesAsync()
{
// Arrange
using (var workingDirectory = TestDirectory.Create())
{
var packagesDirectory = Path.Combine(workingDirectory, "packages");
var sourceDirectory = Path.Combine(workingDirectory, "source");
var fallbackDirectory = Path.Combine(workingDirectory, "fallback");
// Add a different package to the source.
var identityA = new PackageIdentity("PackageA", NuGetVersion.Parse("1.0.0-Beta"));
var packagePath = await SimpleTestPackageUtility.CreateFullPackageAsync(
sourceDirectory,
identityA.Id,
identityA.Version.ToString());
var logger = new TestLogger();
var identityB = new PackageIdentity("PackageB", NuGetVersion.Parse("2.0.0-Beta"));
var graph = GetRestoreTargetGraph(sourceDirectory, identityB, packagePath, logger);
// Add the package to the fallback directory.
await SimpleTestPackageUtility.CreateFolderFeedV3Async(fallbackDirectory, identityB);
var request = GetRestoreRequest(packagesDirectory, logger, fallbackDirectory);
var resolver = new VersionFolderPathResolver(packagesDirectory, isLowercase: false);
var target = new OriginalCaseGlobalPackageFolder(request);
// Act
await target.CopyPackagesToOriginalCaseAsync(
new[] { graph },
CancellationToken.None);
// Assert
Assert.False(File.Exists(resolver.GetPackageFilePath(identityA.Id, identityA.Version)));
Assert.True(File.Exists(resolver.GetPackageFilePath(identityB.Id, identityB.Version)));
Assert.Equal(1, logger.Messages.Count(x => x.Contains(identityB.ToString())));
}
}
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 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");
}
}
public async Task LocalPackageFileCache_GetFilesTwiceVerifySameInstance()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
var path = pathResolver.GetInstallPath(identity.Id, identity.Version);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
identity);
var filesA = cache.GetOrAddFiles(path);
var filesB = cache.GetOrAddFiles(path);
// Verify both file lists are the exact same instance
Assert.Same(filesA.Value, filesB.Value);
filesA.Value.Should().NotBeEmpty();
}
}
public DependencyContextBuilder(SingleProjectInfo mainProjectInfo, ProjectContext projectContext, bool includeRuntimeFileVersions)
{
_mainProjectInfo = mainProjectInfo;
_projectContext = projectContext;
_includeRuntimeFileVersions = includeRuntimeFileVersions;
// This resolver is only used for building file names, so that base path is not required.
_versionFolderPathResolver = new VersionFolderPathResolver(rootPath: null);
if (_includeRuntimeFileVersions)
{
// This is used to look up the paths to package files on disk, which is only needed in this class if
// it needs to read the file versions
_packageResolver = NuGetPackageResolver.CreateResolver(projectContext.LockFile);
}
if (_projectContext.CompilationLockFileTarget != _projectContext.LockFileTarget)
{
_compilationTargetLibraries = _projectContext.CompilationLockFileTarget.Libraries
.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase);
}
}
public async Task CopyPackagesToOriginalCaseAsync_DoesNothingIfPackageIsAlreadyInstalledAsync()
{
// Arrange
using (var workingDirectory = TestDirectory.Create())
{
var packagesDirectory = Path.Combine(workingDirectory, "packages");
var sourceDirectory = Path.Combine(workingDirectory, "source");
var identity = new PackageIdentity("PackageA", NuGetVersion.Parse("1.0.0-Beta"));
var packagePath = await SimpleTestPackageUtility.CreateFullPackageAsync(
sourceDirectory,
identity.Id,
identity.Version.ToString());
var logger = new TestLogger();
var graph = GetRestoreTargetGraph(sourceDirectory, identity, packagePath, logger);
var request = GetRestoreRequest(packagesDirectory, logger);
var resolver = new VersionFolderPathResolver(packagesDirectory, isLowercase: false);
var hashPath = resolver.GetNupkgMetadataPath(identity.Id, identity.Version);
Directory.CreateDirectory(Path.GetDirectoryName(hashPath));
// The hash file is what determines if the package is installed or not.
File.WriteAllText(hashPath, string.Empty);
var target = new OriginalCaseGlobalPackageFolder(request);
// Act
await target.CopyPackagesToOriginalCaseAsync(
new[] { graph },
CancellationToken.None);
// Assert
Assert.True(File.Exists(resolver.GetNupkgMetadataPath(identity.Id, identity.Version)));
Assert.Equal(0, logger.Messages.Count(x => x.Contains(identity.ToString())));
}
}
public async Task LocalPackageFileCache_GetNuspecTwiceVerifySameInstance()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
identity);
var nuspec = pathResolver.GetManifestFilePath(identity.Id, identity.Version);
var expanded = pathResolver.GetInstallPath(identity.Id, identity.Version);
var result1 = cache.GetOrAddNuspec(nuspec, expanded);
var result2 = cache.GetOrAddNuspec(nuspec, expanded);
Assert.Same(result1.Value, result2.Value);
result1.Value.GetIdentity().Should().Be(identity);
}
}
public static async Task Extract(
Solution solution,
PackageIdentity packageIdentity,
DownloadResourceResult downloadResult,
INuGetProjectContext context,
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 logger = new LoggerAdapter(context);
var solutionManager = new MonoDevelopSolutionManager(solution);
var clientPolicyContext = ClientPolicyContext.GetClientPolicy(solutionManager.Settings, logger);
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext,
logger);
downloadResult.PackageStream.Position = 0;
await PackageExtractor.InstallFromSourceAsync(
downloadResult.PackageSource,
packageIdentity,
stream => downloadResult.PackageStream.CopyToAsync(stream, BufferSize, token),
defaultPackagePathResolver,
packageExtractionContext,
token);
}
public async Task Test_ExtractionDoesNotExtractFiles_IfPackageSaveModeDoesNotIncludeFiles()
{
// 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.Nupkg | PackageSaveMode.Nuspec,
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 void BasicPackage()
{
PackageRepository.Create(TestRootPath)
.Package("PackageD", "1.2.3-beta", out PackageIdentity package);
package.ShouldNotBeNull();
package.Id.ShouldBe("PackageD");
package.Version.ShouldBe(NuGetVersion.Parse("1.2.3-beta"));
FileInfo manifestFilePath = new FileInfo(VersionFolderPathResolver.GetManifestFilePath(package.Id, package.Version))
.ShouldExist();
using (Stream stream = File.OpenRead(manifestFilePath.FullName))
{
Manifest manifest = Manifest.ReadFrom(stream, validateSchema: true);
manifest.Metadata.Authors.ShouldBe(new[] { "UserA" });
manifest.Metadata.Description.ShouldBe("Description");
manifest.Metadata.DevelopmentDependency.ShouldBeFalse();
manifest.Metadata.Id.ShouldBe("PackageD");
manifest.Metadata.RequireLicenseAcceptance.ShouldBeFalse();
}
}
public PackageDependencyProvider(string packagesPath)
{
_packagePathResolver = new VersionFolderPathResolver(packagesPath);
}
/// <summary>
/// Get the view of installed packages. Use for Get-Package command.
/// </summary>
internal static List <PowerShellInstalledPackage> GetPowerShellPackageView(
Dictionary <NuGetProject, IEnumerable <Packaging.PackageReference> > dictionary,
ISolutionManager solutionManager,
Configuration.ISettings settings)
{
var views = new List <PowerShellInstalledPackage> ();
foreach (var entry in dictionary)
{
var nugetProject = entry.Key;
string packageFolder = null;
FolderNuGetProject packageFolderProject = null;
if (nugetProject is BuildIntegratedNuGetProject)
{
packageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
}
else
{
var project = nugetProject as MSBuildNuGetProject;
if (project != null)
{
packageFolderProject = project.FolderNuGetProject;
}
}
// entry.Value is an empty list if no packages are installed
foreach (var package in entry.Value)
{
string installPackagePath = null;
string licenseUrl = null;
if (packageFolder != null)
{
var defaultPackagePathResolver = new VersionFolderPathResolver(packageFolder);
installPackagePath = defaultPackagePathResolver.GetPackageFilePath(package.PackageIdentity.Id, package.PackageIdentity.Version);
}
else if (packageFolderProject != null)
{
installPackagePath = packageFolderProject.GetInstalledPackageFilePath(package.PackageIdentity);
}
using (var reader = GetPackageReader(installPackagePath)) {
var nuspecReader = new NuspecReader(reader.GetNuspec());
licenseUrl = nuspecReader.GetLicenseUrl();
}
var view = new PowerShellInstalledPackage()
{
Id = package.PackageIdentity.Id,
AsyncLazyVersions = new AsyncLazy <IEnumerable <NuGetVersion> > (() => {
return(Task.FromResult <IEnumerable <NuGetVersion> > (new [] { package.PackageIdentity.Version }));
}),
ProjectName = entry.Key.GetMetadata <string> (NuGetProjectMetadataKeys.Name),
LicenseUrl = licenseUrl
};
views.Add(view);
}
}
return(views);
}
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 bool IsMissing (
IMonoDevelopSolutionManager solutionManager,
PackageIdentity packageIdentity)
{
string globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder (solutionManager.Settings);
var defaultPackagePathResolver = new VersionFolderPathResolver (globalPackagesFolder);
string hashPath = defaultPackagePathResolver.GetHashPath (packageIdentity.Id, packageIdentity.Version);
return !File.Exists (hashPath);
}
public PackagePathResolverV3(string rootDirectory) : base(rootDirectory, true)
{
pathResolver = new VersionFolderPathResolver(rootDirectory);
}
/// <summary>
/// Write a zip file to a stream.
/// </summary>
public static void CreatePackage(Stream stream, SimpleTestPackageContext packageContext)
{
var id = packageContext.Id;
var version = packageContext.Version;
var runtimeJson = packageContext.RuntimeJson;
var pathResolver = new VersionFolderPathResolver(null);
var testLogger = new TestLogger();
var tempStream = stream;
var isUsingTempStream = false;
if (packageContext.AuthorSignatureCertificate != null)
{
tempStream = new MemoryStream();
isUsingTempStream = true;
}
using (var zip = new ZipArchive(tempStream, ZipArchiveMode.Create, leaveOpen: true))
{
if (packageContext.Files.Any())
{
foreach (var entryFile in packageContext.Files)
{
zip.AddEntry(entryFile.Key, entryFile.Value);
}
}
else
{
zip.AddEntry("contentFiles/any/any/config.xml", new byte[] { 0 });
zip.AddEntry("contentFiles/cs/net45/code.cs", new byte[] { 0 });
zip.AddEntry("lib/net45/a.dll", new byte[] { 0 });
zip.AddEntry("lib/netstandard1.0/a.dll", new byte[] { 0 });
zip.AddEntry($"build/net45/{id}.targets", @"<targets />", Encoding.UTF8);
zip.AddEntry("runtimes/any/native/a.dll", new byte[] { 0 });
zip.AddEntry("tools/a.exe", new byte[] { 0 });
}
if (!string.IsNullOrEmpty(runtimeJson))
{
zip.AddEntry("runtime.json", runtimeJson, Encoding.UTF8);
}
var frameworkAssembliesAndContentFiles = packageContext.UseDefaultRuntimeAssemblies ?
$@"<frameworkAssemblies>
<frameworkAssembly assemblyName=""System.Runtime""/>
</frameworkAssemblies>
<contentFiles>
<files include=""cs/net45/config/config.xml"" buildAction=""none"" />
<files include=""cs/net45/config/config.xml"" copyToOutput=""true"" flatten=""false"" />
<files include=""cs/net45/images/image.jpg"" buildAction=""embeddedresource"" />
</contentFiles>" :
string.Empty;
var nuspecXml = packageContext.Nuspec?.ToString() ??
$@"<?xml version=""1.0"" encoding=""utf-8""?>
<package>
<metadata>
<id>{id}</id>
<version>{version.ToString()}</version>
<title />
{frameworkAssembliesAndContentFiles}
</metadata>
</package>";
var xml = XDocument.Parse(nuspecXml);
// Add the min client version if it exists
if (!string.IsNullOrEmpty(packageContext.MinClientVersion))
{
xml.Root.Element(XName.Get("metadata"))
.Add(new XAttribute(XName.Get("minClientVersion"), packageContext.MinClientVersion));
}
var dependencies = packageContext.Dependencies.Select(e =>
new PackageDependency(
e.Id,
VersionRange.Parse(e.Version),
string.IsNullOrEmpty(e.Include)
? new List <string>()
: e.Include.Split(',').ToList(),
string.IsNullOrEmpty(e.Exclude)
? new List <string>()
: e.Exclude.Split(',').ToList()));
if (dependencies.Any())
{
var metadata = xml.Element(XName.Get("package")).Element(XName.Get("metadata"));
var dependenciesNode = new XElement(XName.Get("dependencies"));
var groupNode = new XElement(XName.Get("group"));
dependenciesNode.Add(groupNode);
metadata.Add(dependenciesNode);
foreach (var dependency in dependencies)
{
var node = new XElement(XName.Get("dependency"));
groupNode.Add(node);
node.Add(new XAttribute(XName.Get("id"), dependency.Id));
node.Add(new XAttribute(XName.Get("version"), dependency.VersionRange.ToNormalizedString()));
if (dependency.Include.Count > 0)
{
node.Add(new XAttribute(XName.Get("include"), string.Join(",", dependency.Include)));
}
if (dependency.Exclude.Count > 0)
{
node.Add(new XAttribute(XName.Get("exclude"), string.Join(",", dependency.Exclude)));
}
}
}
if (packageContext.PackageTypes.Count > 0)
{
var metadata = xml.Element("package").Element("metadata");
var packageTypes = new XElement("packageTypes");
metadata.Add(packageTypes);
foreach (var packageType in packageContext.PackageTypes)
{
var packageTypeElement = new XElement("packageType");
packageTypeElement.Add(new XAttribute("name", packageType.Name));
if (packageType.Version != PackageType.EmptyVersion)
{
packageTypeElement.Add(new XAttribute("version", packageType.Version));
}
packageTypes.Add(packageTypeElement);
}
}
zip.AddEntry($"{id}.nuspec", xml.ToString(), Encoding.UTF8);
}
if (isUsingTempStream)
{
using (var signPackage = new SignedPackageArchive(tempStream, stream))
{
var testSignatureProvider = new X509SignatureProvider(timestampProvider: null);
var signer = new Signer(signPackage, testSignatureProvider);
var request = new AuthorSignPackageRequest(packageContext.AuthorSignatureCertificate, hashAlgorithm: HashAlgorithmName.SHA256);
signer.SignAsync(request, testLogger, CancellationToken.None).Wait();
}
tempStream.Dispose();
}
// Reset position
stream.Position = 0;
}
public PackageDependencyProvider(string packagesPath, FrameworkReferenceResolver frameworkReferenceResolver)
{
_packagePathResolver = new VersionFolderPathResolver(packagesPath);
_frameworkReferenceResolver = frameworkReferenceResolver;
}
/// <summary>
/// Write a zip file to a stream.
/// </summary>
public static void CreatePackage(Stream stream, SimpleTestPackageContext packageContext)
{
var id = packageContext.Id;
var version = packageContext.Version;
var runtimeJson = packageContext.RuntimeJson;
var pathResolver = new VersionFolderPathResolver(null);
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
if (packageContext.Files.Any())
{
foreach (var entryFile in packageContext.Files)
{
zip.AddEntry(entryFile.Key, entryFile.Value);
}
}
else
{
zip.AddEntry("contentFiles/any/any/config.xml", new byte[] { 0 });
zip.AddEntry("contentFiles/cs/net45/code.cs", new byte[] { 0 });
zip.AddEntry("lib/net45/a.dll", new byte[] { 0 });
zip.AddEntry("lib/netstandard1.0/a.dll", new byte[] { 0 });
zip.AddEntry($"build/net45/{id}.targets", @"<targets />", Encoding.UTF8);
zip.AddEntry("runtimes/any/native/a.dll", new byte[] { 0 });
zip.AddEntry("tools/a.exe", new byte[] { 0 });
}
if (!string.IsNullOrEmpty(runtimeJson))
{
zip.AddEntry("runtime.json", runtimeJson, Encoding.UTF8);
}
var nuspecXml = packageContext.Nuspec?.ToString() ?? $@"<?xml version=""1.0"" encoding=""utf-8""?>
<package>
<metadata>
<id>{id}</id>
<version>{version.ToString()}</version>
<title />
<frameworkAssemblies>
<frameworkAssembly assemblyName=""System.Runtime"" />
</frameworkAssemblies>
<contentFiles>
<files include=""cs/net45/config/config.xml"" buildAction=""none"" />
<files include=""cs/net45/config/config.xml"" copyToOutput=""true"" flatten=""false"" />
<files include=""cs/net45/images/image.jpg"" buildAction=""embeddedresource"" />
</contentFiles>
</metadata>
</package>";
var xml = XDocument.Parse(nuspecXml);
// Add the min client version if it exists
if (!string.IsNullOrEmpty(packageContext.MinClientVersion))
{
xml.Root.Element(XName.Get("metadata"))
.Add(new XAttribute(XName.Get("minClientVersion"), packageContext.MinClientVersion));
}
var dependencies = packageContext.Dependencies.Select(e =>
new PackageDependency(
e.Id,
VersionRange.Parse(e.Version),
string.IsNullOrEmpty(e.Include)
? new List <string>()
: e.Include.Split(',').ToList(),
string.IsNullOrEmpty(e.Exclude)
? new List <string>()
: e.Exclude.Split(',').ToList()));
if (dependencies.Any())
{
var metadata = xml.Element(XName.Get("package")).Element(XName.Get("metadata"));
var dependenciesNode = new XElement(XName.Get("dependencies"));
var groupNode = new XElement(XName.Get("group"));
dependenciesNode.Add(groupNode);
metadata.Add(dependenciesNode);
foreach (var dependency in dependencies)
{
var node = new XElement(XName.Get("dependency"));
groupNode.Add(node);
node.Add(new XAttribute(XName.Get("id"), dependency.Id));
node.Add(new XAttribute(XName.Get("version"), dependency.VersionRange.ToNormalizedString()));
if (dependency.Include.Count > 0)
{
node.Add(new XAttribute(XName.Get("include"), string.Join(",", dependency.Include)));
}
if (dependency.Exclude.Count > 0)
{
node.Add(new XAttribute(XName.Get("exclude"), string.Join(",", dependency.Exclude)));
}
}
}
if (packageContext.PackageTypes.Count > 0)
{
var metadata = xml.Element("package").Element("metadata");
var packageTypes = new XElement("packageTypes");
metadata.Add(packageTypes);
foreach (var packageType in packageContext.PackageTypes)
{
var packageTypeElement = new XElement("packageType");
packageTypeElement.Add(new XAttribute("name", packageType.Name));
if (packageType.Version != PackageType.EmptyVersion)
{
packageTypeElement.Add(new XAttribute("version", packageType.Version));
}
packageTypes.Add(packageTypeElement);
}
}
if (packageContext.Signatures.Count > 0)
{
throw new NotImplementedException();
}
zip.AddEntry($"{id}.nuspec", xml.ToString(), Encoding.UTF8);
}
// Reset position
stream.Position = 0;
}
public static void GenerateNuGetBuildPackagingTargets (PackageIdentity packageIdentity, PackagingProject project)
{
var packagePathResolver = new VersionFolderPathResolver (string.Empty);
string packageDirectory = packagePathResolver.GetPackageDirectory (packageIdentity.Id, packageIdentity.Version);
string buildDirectory = Path.Combine (packageDirectory, "build");
string prop = Path.Combine (buildDirectory, "NuGet.Build.Packaging.props");
string target = Path.Combine (buildDirectory, "NuGet.Build.Packaging.targets");
MSBuildNuGetImportGenerator.CreateImports (project, prop, target);
}
protected void CreateInitNuGetProject ()
{
var solutionManager = PackageManagementServices.Workspace.GetSolutionManager (project.ParentSolution);
nugetProject = solutionManager.GetNuGetProject (project);
if (nugetProject is INuGetIntegratedProject) {
PackagesFolderPath = SettingsUtility.GetGlobalPackagesFolder (solutionManager.Settings);
packagePathResolver = new VersionFolderPathResolver (
PackagesFolderPath,
normalizePackageId: false);
} else {
PackagesFolderPath = nugetProject.GetPackagesFolderPath (solutionManager);
folder = new FolderNuGetProject (PackagesFolderPath);
}
}
public static CommandSpec ResolveFromProjectTools(string commandName, IEnumerable<string> args)
{
var context = GetProjectContext(FrameworkConstants.CommonFrameworks.DnxCore50);
if (context == null)
{
return null;
}
var commandLibrary = context.ProjectFile.Tools
.FirstOrDefault(l => l.Name == commandName);
if (commandLibrary == default(LibraryRange))
{
return null;
}
var lockPath = Path.Combine(context.ProjectDirectory, "artifacts", "Tools", commandName,
"project.lock.json");
if (!File.Exists(lockPath))
{
return null;
}
var lockFile = LockFileReader.Read(lockPath);
var lib = lockFile.PackageLibraries.FirstOrDefault(l => l.Name == commandName);
var packageDir = new VersionFolderPathResolver(context.PackagesDirectory)
.GetInstallPath(lib.Name, lib.Version);
return Directory.Exists(packageDir)
? ConfigureCommandFromPackage(commandName, args, lib.Files, packageDir)
: null;
}
