private PackageData[] GetPackageDependencies(string targetPackagesPath, NuGetFramework targetFramework) { List <PackageData> dependencies = new List <PackageData>(); PackageDependencyGroup group = this.nReader.GetDependencyGroups().GetNearest(targetFramework); if (group != null) { foreach (var pkg in group.Packages) { var repository = new NuGetv3LocalRepository(targetPackagesPath); var dependencyPkgs = repository.FindPackagesById(pkg.Id); var allVersions = dependencyPkgs.Select(d => d.Version); NuGetVersion selectedVersion = pkg.VersionRange.FindBestMatch(allVersions); var selectedPkg = dependencyPkgs.FirstOrDefault(d => d.Version == selectedVersion); if (selectedPkg != null) { var pkgData = PackageData.GetPackageData(selectedPkg.Id, selectedPkg.Version.ToString()); if (pkgData != null) { dependencies.Add(pkgData); } } } } else { Console.WriteLine($"ERROR: Group not found for {this.SourceFileName} TFM {targetFramework}."); } return(dependencies.ToArray()); }
private LockFile BuildLockFile( LockFile existingLockFile, PackageSpec project, IEnumerable <RestoreTargetGraph> graphs, NuGetv3LocalRepository localRepository, RemoteWalkContext contextForProject, IEnumerable <ToolRestoreResult> toolRestoreResults, bool relockFile) { // Build the lock file LockFile lockFile; if (existingLockFile != null && existingLockFile.IsLocked) { // No lock file to write! lockFile = existingLockFile; } else { lockFile = new LockFileBuilder(_request.LockFileVersion, _logger, _includeFlagGraphs) .CreateLockFile( existingLockFile, project, graphs, localRepository, contextForProject, toolRestoreResults); // If the lock file was locked originally but we are re-locking it, well... re-lock it :) lockFile.IsLocked = relockFile; } return(lockFile); }
public static RestoreCommandProviders Create( string globalFolderPath, IEnumerable <SourceRepository> sources, SourceCacheContext cacheContext, ILogger log) { var globalPackages = new NuGetv3LocalRepository(globalFolderPath); var globalPackagesSource = Repository.Factory.GetCoreV3(globalFolderPath); var localProviders = new List <IRemoteDependencyProvider>() { // Do not throw or warn for gloabal cache new SourceRepositoryDependencyProvider(globalPackagesSource, log, cacheContext, ignoreFailedSources: true, ignoreWarning: true) }; var remoteProviders = new List <IRemoteDependencyProvider>(); foreach (var source in sources) { var provider = new SourceRepositoryDependencyProvider(source, log, cacheContext); remoteProviders.Add(provider); } return(new RestoreCommandProviders(globalPackages, localProviders, remoteProviders, cacheContext)); }
/// <summary> /// Providers used by the restore command. These can be shared across restores. /// </summary> /// <param name="globalPackages">Path to the global packages folder.</param> /// <param name="localProviders">This is typically just a provider for the global packages folder.</param> /// <param name="remoteProviders">All dependency providers.</param> /// <param name="cacheContext">Web cache context.</param> public RestoreCommandProviders( NuGetv3LocalRepository globalPackages, IReadOnlyList <IRemoteDependencyProvider> localProviders, IReadOnlyList <IRemoteDependencyProvider> remoteProviders, SourceCacheContext cacheContext) { if (globalPackages == null) { throw new ArgumentNullException(nameof(globalPackages)); } if (localProviders == null) { throw new ArgumentNullException(nameof(localProviders)); } if (remoteProviders == null) { throw new ArgumentNullException(nameof(remoteProviders)); } if (cacheContext == null) { throw new ArgumentNullException(nameof(cacheContext)); } GlobalPackages = globalPackages; LocalProviders = localProviders; RemoteProviders = remoteProviders; CacheContext = cacheContext; }
public async Task NuGetv3LocalRepository_FindPackagesById_LeavesVersionCaseFoundOnFileSystem() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "Foo"; var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, new SimpleTestPackageContext(id, "1.0.0"), new SimpleTestPackageContext(id, "2.0.0-Beta")); // Act var packages = target.FindPackagesById(id); // Assert Assert.Equal(2, packages.Count()); packages = packages.OrderBy(x => x.Version); Assert.Equal(id, packages.ElementAt(0).Id); Assert.Equal("1.0.0", packages.ElementAt(0).Version.ToNormalizedString()); Assert.Equal(id, packages.ElementAt(1).Id); Assert.Equal("2.0.0-beta", packages.ElementAt(1).Version.ToNormalizedString()); } }
private async Task <bool> InstallPackageAsync(RemoteMatch installItem, NuGetv3LocalRepository userPackageFolder, PackageExtractionContext packageExtractionContext, CancellationToken token) { var packageIdentity = new PackageIdentity(installItem.Library.Name, installItem.Library.Version); // Check if the package has already been installed. if (!userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version)) { var versionFolderPathResolver = new VersionFolderPathResolver(_request.PackagesDirectory); try { using (var packageDependency = await installItem.Provider.GetPackageDownloaderAsync( packageIdentity, _request.CacheContext, _logger, token)) { // Install, returns true if the package was actually installed. // Returns false if the package was a noop once the lock // was acquired. var installed = await PackageExtractor.InstallFromSourceAsync( packageIdentity, packageDependency, versionFolderPathResolver, packageExtractionContext, token, ParentId); // 1) If another project in this process installs the package this will return false but userPackageFolder will contain the package. // 2) If another process installs the package then this will also return false but we still need to update the cache. // For #2 double check that the cache has the package now otherwise clear if (installed || !userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version)) { // If the package was added, clear the cache so that the next caller can see it. // Avoid calling this for packages that were not actually installed. userPackageFolder.ClearCacheForIds(new string[] { packageIdentity.Id }); } } } catch (SignatureException e) { if (!string.IsNullOrEmpty(e.Message)) { await _logger.LogAsync(e.AsLogMessage()); } // If the package is unsigned and unsigned packages are not allowed a SignatureException // will be thrown but it won't have results because it didn't went through any // verification provider. if (e.Results != null) { await _logger.LogMessagesAsync(e.Results.SelectMany(p => p.Issues)); } return(false); } } return(true); }
public static RestoreCommandProviders Create( string globalFolderPath, IEnumerable <string> fallbackPackageFolderPaths, IEnumerable <SourceRepository> sources, SourceCacheContext cacheContext, ILogger log) { var globalPackages = new NuGetv3LocalRepository(globalFolderPath); var globalPackagesSource = Repository.Factory.GetCoreV3(globalFolderPath, FeedType.FileSystemV3); var localProviders = new List <IRemoteDependencyProvider>() { // Do not throw or warn for global cache new SourceRepositoryDependencyProvider( globalPackagesSource, log, cacheContext, ignoreFailedSources: true, ignoreWarning: true) }; // Add fallback sources as local providers also var fallbackPackageFolders = new List <NuGetv3LocalRepository>(); foreach (var path in fallbackPackageFolderPaths) { var fallbackRepository = new NuGetv3LocalRepository(path); var fallbackSource = Repository.Factory.GetCoreV3(path, FeedType.FileSystemV3); var provider = new SourceRepositoryDependencyProvider( fallbackSource, log, cacheContext, ignoreFailedSources: false, ignoreWarning: false); fallbackPackageFolders.Add(fallbackRepository); localProviders.Add(provider); } var remoteProviders = new List <IRemoteDependencyProvider>(); foreach (var source in sources) { var provider = new SourceRepositoryDependencyProvider( source, log, cacheContext, cacheContext.IgnoreFailedSources, ignoreWarning: false); remoteProviders.Add(provider); } return(new RestoreCommandProviders( globalPackages, fallbackPackageFolders, localProviders, remoteProviders)); }
/// <summary> /// Providers used by the restore command. These can be shared across restores. /// </summary> /// <param name="globalPackages">Path to the global packages folder.</param> /// <param name="fallbackPackageFolders">Path to any fallback package folders.</param> /// <param name="localProviders">This is typically just a provider for the global packages folder.</param> /// <param name="remoteProviders">All dependency providers.</param> public RestoreCommandProviders( NuGetv3LocalRepository globalPackages, IReadOnlyList <NuGetv3LocalRepository> fallbackPackageFolders, IReadOnlyList <IRemoteDependencyProvider> localProviders, IReadOnlyList <IRemoteDependencyProvider> remoteProviders) { if (globalPackages == null) { throw new ArgumentNullException(nameof(globalPackages)); } if (fallbackPackageFolders == null) { throw new ArgumentNullException(nameof(fallbackPackageFolders)); } if (localProviders == null) { throw new ArgumentNullException(nameof(localProviders)); } if (remoteProviders == null) { throw new ArgumentNullException(nameof(remoteProviders)); } GlobalPackages = globalPackages; LocalProviders = localProviders; RemoteProviders = remoteProviders; FallbackPackageFolders = fallbackPackageFolders; }
private Task <RestoreTargetGraph[]> WalkRuntimeDependenciesAsync(LibraryRange projectRange, RestoreTargetGraph graph, IEnumerable <string> runtimeIds, RemoteDependencyWalker walker, RemoteWalkContext context, NuGetv3LocalRepository localRepository, RuntimeGraph runtimes, bool writeToLockFile, CancellationToken token) { var resultGraphs = new List <Task <RestoreTargetGraph> >(); foreach (var runtimeName in runtimeIds) { _logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoringPackages, FrameworkRuntimePair.GetName(graph.Framework, runtimeName))); resultGraphs.Add(WalkDependenciesAsync(projectRange, graph.Framework, runtimeName, runtimes, walker, context, writeToLockFile, token)); } return(Task.WhenAll(resultGraphs)); }
public async Task NuGetv3LocalRepository_FindPackage_VerifyNuspecsCached() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "Foo"; var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, new SimpleTestPackageContext(id, "1.0.0"), new SimpleTestPackageContext(id, "2.0.0-Beta")); // Act var package1 = target.FindPackage(id, NuGetVersion.Parse("2.0.0-beta")); var package2 = target.FindPackage(id, NuGetVersion.Parse("2.0.0-BETA")); var package3 = target.FindPackage(id, NuGetVersion.Parse("2.0.0-beta")); // Assert Assert.True(ReferenceEquals(package1, package3)); Assert.True(ReferenceEquals(package1.Nuspec, package2.Nuspec)); Assert.True(ReferenceEquals(package1.Nuspec, package3.Nuspec)); // These should contain different versions Assert.False(ReferenceEquals(package1, package2)); } }
public async Task NuGetv3LocalRepository_FindPackagesById_InstallStress() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "a"; var target = new NuGetv3LocalRepository(workingDir); var packages = new ConcurrentQueue <PackageIdentity>(); var limit = 100; for (int i = 0; i < limit; i++) { packages.Enqueue(new PackageIdentity(id, NuGetVersion.Parse($"{i + 1}.0.0"))); } var tasks = new List <Task>(); var sem = new ManualResetEventSlim(false); for (int i = 0; i < 10; i++) { tasks.Add(Task.Run(async() => { sem.Wait(); PackageIdentity identity; while (packages.TryDequeue(out identity)) { // Fetch var result = target.FindPackagesById(identity.Id) .FirstOrDefault(f => f.Version == identity.Version); Assert.Null(result); // Create package await SimpleTestPackageUtility.CreateFolderFeedV3(workingDir, PackageSaveMode.Defaultv3, identity); // Clear target.ClearCacheForIds(new[] { identity.Id }); result = target.FindPackagesById(identity.Id) .FirstOrDefault(f => f.Version == identity.Version); // Assert the package was found Assert.NotNull(result); } })); } sem.Set(); await Task.WhenAll(tasks); // Assert var results2 = target.FindPackagesById(id); Assert.Equal(limit, results2.Count()); } }
private static IList <CompatibilityCheckResult> VerifyCompatibility( PackageSpec project, Dictionary <RestoreTargetGraph, Dictionary <string, LibraryIncludeFlags> > includeFlagGraphs, NuGetv3LocalRepository localRepository, LockFile lockFile, IEnumerable <RestoreTargetGraph> graphs, ILogger logger) { // Scan every graph for compatibility, as long as there were no unresolved packages var checkResults = new List <CompatibilityCheckResult>(); if (graphs.All(g => !g.Unresolved.Any())) { var checker = new CompatibilityChecker(localRepository, lockFile, logger); foreach (var graph in graphs) { logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_CheckingCompatibility, graph.Name)); var includeFlags = IncludeFlagUtils.FlattenDependencyTypes(includeFlagGraphs, project, graph); var res = checker.Check(graph, includeFlags); checkResults.Add(res); if (res.Success) { logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_PackagesAndProjectsAreCompatible, graph.Name)); } else { // Get error counts on a project vs package basis var projectCount = res.Issues.Count(issue => issue.Type == CompatibilityIssueType.ProjectIncompatible); var packageCount = res.Issues.Count(issue => issue.Type != CompatibilityIssueType.ProjectIncompatible); // Log a summary with compatibility error counts if (projectCount > 0) { logger.LogError( string.Format(CultureInfo.CurrentCulture, Strings.Log_ProjectsIncompatible, graph.Name)); logger.LogDebug($"Incompatible projects: {projectCount}"); } if (packageCount > 0) { logger.LogError( string.Format(CultureInfo.CurrentCulture, Strings.Log_PackagesIncompatible, graph.Name)); logger.LogDebug($"Incompatible packages: {packageCount}"); } } } } return(checkResults); }
public LocalPackageHelper() { var settings = Settings.LoadDefaultSettings(Directory.GetCurrentDirectory()); m_globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings); m_localRepository = new NuGetv3LocalRepository(m_globalPackagesFolder); var psp = new PackageSourceProvider(settings); var sources = psp.LoadPackageSources(); m_repositories = sources.Select(x => Repository.Factory.GetCoreV3(x.Source)); }
public async Task NuGetv3LocalRepository_Exists_WorksForAllCases(string id) { using (var workingDir = TestDirectory.Create()) { var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, new SimpleTestPackageContext("foo", "1.0.0")); target.Exists(id, NuGetVersion.Parse("1.0.0")).Should().BeTrue(); } }
/// <summary> /// Providers used by the restore command. These can be shared across restores. /// </summary> /// <param name="globalPackages">Path to the global packages folder.</param> /// <param name="fallbackPackageFolders">Path to any fallback package folders.</param> /// <param name="localProviders">This is typically just a provider for the global packages folder.</param> /// <param name="remoteProviders">All dependency providers.</param> /// <param name="packageFileCache">Nuspec and package file cache.</param> public RestoreCommandProviders( NuGetv3LocalRepository globalPackages, IReadOnlyList <NuGetv3LocalRepository> fallbackPackageFolders, IReadOnlyList <IRemoteDependencyProvider> localProviders, IReadOnlyList <IRemoteDependencyProvider> remoteProviders, LocalPackageFileCache packageFileCache) { GlobalPackages = globalPackages ?? throw new ArgumentNullException(nameof(globalPackages)); LocalProviders = localProviders ?? throw new ArgumentNullException(nameof(localProviders)); RemoteProviders = remoteProviders ?? throw new ArgumentNullException(nameof(remoteProviders)); FallbackPackageFolders = fallbackPackageFolders ?? throw new ArgumentNullException(nameof(fallbackPackageFolders)); PackageFileCache = packageFileCache ?? throw new ArgumentNullException(nameof(packageFileCache)); }
public NuGetv3PackageFolder( string physicalPath, bool ignoreFailure, ILogger logger) { _logger = logger; // We need to help "kpm restore" to ensure case-sensitivity here // Turn on the flag to get package ids in accurate casing _repository = new NuGetv3LocalRepository(physicalPath, checkPackageIdCase: true); Source = physicalPath; _ignored = false; _ignoreFailure = ignoreFailure; }
public async Task NuGetv3LocalRepository_FindPackagesById_Stress() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "a"; var target = new NuGetv3LocalRepository(workingDir); var packages = new List <PackageIdentity>(); for (int i = 0; i < 100; i++) { packages.Add(new PackageIdentity(id, NuGetVersion.Parse($"{i + 1}.0.0"))); } await SimpleTestPackageUtility.CreateFolderFeedV3(workingDir, packages.ToArray()); var tasks = new List <Task>(); var sem = new ManualResetEventSlim(false); for (int i = 0; i < 10; i++) { tasks.Add(Task.Run(() => { sem.Wait(); for (int j = 0; j < 100; j++) { // Fetch var result = target.FindPackagesById(id); // Assert Assert.Equal(100, result.Count()); // Clear for (int k = 0; k < 100; k++) { target.ClearCacheForIds(new[] { id }); } } })); } sem.Set(); await Task.WhenAll(tasks); // Assert var results2 = target.FindPackagesById(id); Assert.Equal(100, results2.Count()); } }
public async Task NuGetv3LocalRepository_Exists_DoesNotExist() { using (var workingDir = TestDirectory.Create()) { var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, new SimpleTestPackageContext("foo", "1.0.0")); target.Exists("foo", NuGetVersion.Parse("2.0.0")).Should().BeFalse(); target.Exists("bar", NuGetVersion.Parse("1.0.0")).Should().BeFalse(); } }
public void NuGetv3LocalRepository_FindPackagesById_ReturnsEmptySequenceWithIdNotFound() { // Arrange using (var workingDir = TestDirectory.Create()) { var target = new NuGetv3LocalRepository(workingDir); // Act var packages = target.FindPackagesById("Foo"); // Assert Assert.Empty(packages); } }
public void NuGetv3LocalRepository_FindPackage_ReturnsNullWithIdNotFound() { // Arrange using (var workingDir = TestDirectory.Create()) { var target = new NuGetv3LocalRepository(workingDir); // Act var package = target.FindPackage("Foo", NuGetVersion.Parse("2.0.0-BETA")); // Assert Assert.Null(package); } }
private async Task <bool> InstallPackagesAsync( HashSet <LibraryIdentity> uniquePackages, IEnumerable <RestoreTargetGraph> graphs, IList <DownloadDependencyResolutionResult> downloadDependencyInformations, NuGetv3LocalRepository userPackageFolder, CancellationToken token) { var packagesToInstall = graphs .SelectMany(g => g.Install.Where(match => uniquePackages.Add(match.Library))).ToList(); packagesToInstall.AddRange( downloadDependencyInformations. SelectMany(ddi => ddi.Install.Where(match => uniquePackages.Add(match.Library)))); var success = true; if (packagesToInstall.Count > 0) { // Use up to MaxDegreeOfConcurrency, create less threads if less packages exist. var threadCount = Math.Min(packagesToInstall.Count, _request.MaxDegreeOfConcurrency); if (threadCount <= 1) { foreach (var match in packagesToInstall) { success &= (await InstallPackageAsync(match, userPackageFolder, _request.PackageExtractionContext, token)); } } else { var bag = new ConcurrentBag <RemoteMatch>(packagesToInstall); var tasks = Enumerable.Range(0, threadCount) .Select(async _ => { RemoteMatch match; var result = true; while (bag.TryTake(out match)) { result &= await InstallPackageAsync(match, userPackageFolder, _request.PackageExtractionContext, token); } return(result); }); success = (await Task.WhenAll(tasks)).All(p => p); } } return(success); }
private RuntimeGraph GetRuntimeGraph(RestoreTargetGraph graph, NuGetv3LocalRepository localRepository) { // TODO: Caching! RuntimeGraph runtimeGraph; if (_request.RuntimeGraphCache.TryGetValue(graph.Framework, out runtimeGraph)) { return(runtimeGraph); } _logger.LogVerbose(Strings.Log_ScanningForRuntimeJson); runtimeGraph = RuntimeGraph.Empty; graph.Graphs.ForEach(node => { var match = node?.Item?.Data?.Match; if (match == null) { return; } // Ignore runtime.json from rejected nodes if (node.Disposition == Disposition.Rejected) { return; } // Locate the package in the local repository var package = localRepository.FindPackagesById(match.Library.Name) .FirstOrDefault(p => p.Version == match.Library.Version); if (package != null) { var nextGraph = LoadRuntimeGraph(package); if (nextGraph != null) { _logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_MergingRuntimes, match.Library)); runtimeGraph = RuntimeGraph.Merge(runtimeGraph, nextGraph); } } }); _request.RuntimeGraphCache[graph.Framework] = runtimeGraph; return(runtimeGraph); }
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 NuGetv3LocalRepository_FindPackage_ReturnsNullWithVersionNotFound() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "Foo"; var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, new SimpleTestPackageContext(id, "1.0.0"), new SimpleTestPackageContext(id, "2.0.0-Beta")); // Act var package = target.FindPackage(id, NuGetVersion.Parse("3.0.0-BETA")); // Assert Assert.Null(package); } }
public async Task NuGetv3LocalRepository_FindPackage_VerifyRuntimeGraphCached() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "packageX"; var runtimeJsonX1 = @"{ ""runtimes"": { ""unix"": { ""packageX"": { ""runtime.packageX"": ""1.0.0"" } } }, ""supports"": { ""x1.app"": { ""uap10.0"": [ ""win10-x86"" ] } } }"; var package = new SimpleTestPackageContext(id, "1.0.0"); package.RuntimeJson = runtimeJsonX1; var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, package); // Act var packageResultA = target.FindPackage(id, NuGetVersion.Parse("1.0.0")); var packageResultB = target.FindPackage(id, NuGetVersion.Parse("1.0.0")); // Assert Assert.True(ReferenceEquals(packageResultA.RuntimeGraph, packageResultB.RuntimeGraph)); } }
public async Task NuGetv3LocalRepository_FindPackagesById_UsesProvidedIdCase() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "Foo"; var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, new SimpleTestPackageContext("foo", "1.0.0")); // Act var packages = target.FindPackagesById(id); // Assert Assert.Equal(1, packages.Count()); Assert.Equal(id, packages.ElementAt(0).Id); Assert.Equal("1.0.0", packages.ElementAt(0).Version.ToNormalizedString()); } }
public async Task NuGetv3LocalRepository_FindPackage_VerifyRuntimeGraphIsNullForNonExistantFile() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "packageX"; var package = new SimpleTestPackageContext(id, "1.0.0"); var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, package); // Act var packageResultA = target.FindPackage(id, NuGetVersion.Parse("1.0.0")); // Assert packageResultA.RuntimeGraph.Should().BeNull(); } }
public async Task NuGetv3LocalRepository_FindPackage_UsesProvidedVersionCase() { // Arrange using (var workingDir = TestDirectory.Create()) { var id = "Foo"; var target = new NuGetv3LocalRepository(workingDir); await SimpleTestPackageUtility.CreateFolderFeedV3( workingDir, PackageSaveMode.Defaultv3, new SimpleTestPackageContext(id, "1.0.0"), new SimpleTestPackageContext(id, "2.0.0-Beta")); // Act var package = target.FindPackage(id, NuGetVersion.Parse("2.0.0-BETA")); // Assert Assert.NotNull(package); Assert.Equal(id, package.Id); Assert.Equal("2.0.0-BETA", package.Version.ToNormalizedString()); } }
private void GenerateImportsFile(NuGetv3LocalRepository repository, string path, List <string> imports) { var ns = XNamespace.Get("http://schemas.microsoft.com/developer/msbuild/2003"); var doc = new XDocument( new XDeclaration("1.0", "utf-8", "no"), new XElement(ns + "Project", new XAttribute("ToolsVersion", "14.0"), new XElement(ns + "PropertyGroup", new XAttribute("Condition", "'$(NuGetPackageRoot)' == ''"), new XElement(ns + "NuGetPackageRoot", repository.RepositoryRoot)), new XElement(ns + "ImportGroup", imports.Select(i => new XElement(ns + "Import", new XAttribute("Project", Path.Combine("$(NuGetPackageRoot)", i)), new XAttribute("Condition", $"Exists('{Path.Combine("$(NuGetPackageRoot)", i)}')")))))); using (var output = new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) { doc.Save(output); } }
private async Task InstallPackageAsync(RemoteMatch installItem, NuGetv3LocalRepository userPackageFolder, CancellationToken token) { var packageIdentity = new PackageIdentity(installItem.Library.Name, installItem.Library.Version); // Check if the package has already been installed. if (!userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version)) { var versionFolderPathContext = new VersionFolderPathContext( packageIdentity, _request.PackagesDirectory, _logger, _request.PackageSaveMode, _request.XmlDocFileSaveMode); using (var packageDependency = await installItem.Provider.GetPackageDownloaderAsync( packageIdentity, _request.CacheContext, _logger, token)) { // Install, returns true if the package was actually installed. // Returns false if the package was a noop once the lock // was acquired. var installed = await PackageExtractor.InstallFromSourceAsync( packageDependency, versionFolderPathContext, token); if (installed) { // If the package was added, clear the cache so that the next caller can see it. // Avoid calling this for packages that were not actually installed. userPackageFolder.ClearCacheForIds(new string[] { packageIdentity.Id }); } } } }