private void InitPackageUpgradeIssues(FolderNuGetProject folderNuGetProject, NuGetProjectUpgradeDependencyItem package, NuGetFramework framework) { _notFoundPackages = new HashSet <PackageIdentity>(); var packageIdentity = new PackageIdentity(package.Id, NuGetVersion.Parse(package.Version)); // Confirm package exists var packagePath = folderNuGetProject.GetInstalledPackageFilePath(packageIdentity); if (string.IsNullOrEmpty(packagePath)) { HasIssues = true; HasNotFoundPackages = true; _notFoundPackages.Add(packageIdentity); package.Issues.Add(PackagingLogMessage.CreateWarning( string.Format(CultureInfo.CurrentCulture, Resources.Upgrader_PackageNotFound, packageIdentity.Id), NuGetLogCode.NU5500)); } else { using (var reader = new PackageArchiveReader(packagePath)) { var packageRules = RuleSet.PackagesConfigToPackageReferenceMigrationRuleSet; var issues = package.Issues; foreach (var rule in packageRules) { var foundIssues = rule.Validate(reader).OrderBy(p => p.Code.ToString(), StringComparer.CurrentCulture); if (foundIssues != null && foundIssues.Any()) { HasIssues = true; } issues.AddRange(foundIssues); } } } }
public async void installPackagesFromProvidedAppSettingsFileAsync() { var serachResult = await _packageSearcher.GetSinglePackageMetaDataAsync(); var identity = serachResult.Identity; var rootPath = @"myPathToTheFolder"; ISettings settings = Settings.LoadDefaultSettings(rootPath, null, new MachineWideSettings()); PackageSourceProvider packageSourceProvider = new PackageSourceProvider(settings); ISourceRepositoryProvider sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, GetV3AndV2Providers()); var project = new FolderNuGetProject(rootPath); string packagesPath = "..."; NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, packagesPath) { PackagesFolderNuGetProject = project }; bool allowPrereleaseVersions = true; bool allowUnlisted = false; ResolutionContext resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None); INuGetProjectContext projectContext = new DefaultProjectContext(); IEnumerable <SourceRepository> sourceRepositories = Enumerable.Repeat(_packageSearcher.GetSourceRepository(), 1); await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject, identity, resolutionContext, projectContext, sourceRepositories, Array.Empty <SourceRepository>(), CancellationToken.None); }
public NuGetDownloader(TargetFramework targetFramework, string?outputDir = null, bool includePrerelease = false, bool recursive = false, bool extract = true, IEnumerable <string>?sources = null) : base(sources) { TargetFramework = targetFramework; Recursive = recursive; Extract = extract; IncludePrerelease = includePrerelease; outputDir ??= Directory.GetCurrentDirectory(); (_downloadDir, _extractDir) = extract ? (Path.Combine(Path.GetTempPath(), $"NuGetPackageDownloader.{Guid.NewGuid():N}"), outputDir) : (outputDir, null); _framework = targetFramework.ToNuGetFramework(); _project = new FolderNuGetProject(_downloadDir); var packageSourceProvider = new PackageSourceProvider(Settings); var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders); _packageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, _downloadDir) { PackagesFolderNuGetProject = _project, }; }
public async override Task ExecuteCommand() { CalculateEffectivePackageSaveMode(); string installPath = ResolveInstallPath(); var packageSourceProvider = new NuGet.Configuration.PackageSourceProvider(Settings); var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders); IEnumerable <SourceRepository> primarySources; IEnumerable <SourceRepository> secondarySources; GetEffectiveSources(sourceRepositoryProvider, out primarySources, out secondarySources); if (Arguments.Count == 0) { throw new InvalidOperationException(NuGetResources.InstallCommandPackageIdMustBeProvided); } string packageId = Arguments[0]; NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, installPath); ResolutionContext resolutionContext = new ResolutionContext(dependencyBehavior: DependencyBehavior, includePrelease: Prerelease); FolderNuGetProject nugetProject = new FolderNuGetProject(installPath); nugetProject.PackageSaveMode = EffectivePackageSaveMode; if (Version == null) { await packageManager.InstallPackageAsync(nugetProject, packageId, resolutionContext, new Common.Console(), primarySources, secondarySources, CancellationToken.None); } else { await packageManager.InstallPackageAsync(nugetProject, new PackageIdentity(packageId, new NuGetVersion(Version)), resolutionContext, new Common.Console(), primarySources, secondarySources, CancellationToken.None); } }
/// <summary> /// Installs application package. /// </summary> /// <remarks> /// На текущий момент это вся документация по использованию библиотек Nuget: /// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-1 /// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-2 /// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-3 /// </remarks> /// <returns></returns> public async Task Install(AppInfo appInfo) { var sourceRepository = new SourceRepository(_nugetSettings.PackageSource.Value, _nugetSettings.ResourceProviders); var sourceRepositoryProvider = new SourceRepositoryProvider(_nugetSettings.Configuration.Value, _nugetSettings.ResourceProviders); var project = new FolderNuGetProject(_appSettings.InstallDirectoryPath); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, _nugetSettings.Configuration.Value, PackagesFolderPath) { PackagesFolderNuGetProject = project }; var resolutionContext = new ResolutionContext(DependencyBehavior.Lowest, true, false, VersionConstraints.None); var emptyNuGetProjectContext = new EmptyNuGetProjectContext(); var sourceRepositories = Array.Empty <SourceRepository>(); await nuGetPackageManager.InstallPackageAsync(project, new PackageIdentity(appInfo.PackageId, NuGetVersion.Parse(appInfo.Version)), resolutionContext, emptyNuGetProjectContext, sourceRepository, sourceRepositories, CancellationToken.None); if (appInfo.HasInstance()) { var directoryName = Path.Combine(_appSettings.InstallDirectoryPath, $"{appInfo.PackageId}.{appInfo.Version}"); var directoryForInstanceName = Path.Combine(_appSettings.InstallDirectoryPath, appInfo.ToString()); var directoryInfo = new DirectoryInfo(directoryName); if (directoryInfo.Exists && !Directory.Exists(directoryForInstanceName)) { directoryInfo.MoveTo(directoryForInstanceName); } } }
public async Task InstallPackageAsync_InstallsPackage() { // Arrange var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); using (var randomTestSourcePath = TestDirectory.Create()) using (var randomTestDestinationPath = TestDirectory.Create()) { var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage( randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath); var packagePathResolver = new PackagePathResolver(randomTestDestinationPath); var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity); var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity)); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using (var packageStream = GetDownloadResourceResult(packageFileInfo)) { // Act await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } // Assert Assert.True(File.Exists(nupkgFilePath)); Assert.True(File.Exists(Path.Combine(packageInstallPath, "lib/test.dll"))); using (var packageStream = File.OpenRead(nupkgFilePath)) { var zipArchive = new ZipArchive(packageStream); Assert.Equal(5, zipArchive.Entries.Count); } } }
/// <summary>Returns the referenced .dll/.exe file paths</summary> public IEnumerable <FilePath> GetReferencedAssembliesFilePaths(FolderNuGetProject project, NuGetFramework targetFramework) { var pkgPath = GetPackageDirectoryPath(project); var archiveReader = GetArchiveReader(project); List <FrameworkSpecificGroup> referenceItems = archiveReader.GetReferenceItems().ToList(); FrameworkSpecificGroup referenceGroup = SelectFrameworkMostCompatibleGroup(targetFramework, referenceItems); if (referenceGroup != null) { LogTo.Verbose( $"Found compatible reference group {referenceGroup.TargetFramework.DotNetFrameworkName} for package {Identity}"); foreach (FilePath assemblyPath in referenceGroup.Items .Select(x => new FilePath(x)) .Where(x => x.Extension == ".dll" || x.Extension == ".exe") .Select(pkgPath.CombineFile)) { LogTo.Verbose($"Found NuGet reference {assemblyPath} from package {Identity}"); yield return(assemblyPath); } } else if (referenceItems.Count == 0) { // Only show a verbose message if there were no reference items (I.e., it's probably a content-only package or a metapackage and not a mismatch) LogTo.Verbose($"Could not find any reference items in package {Identity}"); } else { LogTo.Verbose( $"Could not find compatible reference group for package {Identity} (found {string.Join(",", referenceItems.Select(x => x.TargetFramework.DotNetFrameworkName))})"); } }
public async Task PackagePreFetcher_NoActionsInput() { using (var packagesFolderDir = TestDirectory.Create()) using (var globalPackagesFolder = TestDirectory.Create()) { // Arrange var actions = new List <NuGetProjectAction>(); var packagesFolder = new FolderNuGetProject(packagesFolderDir); var testSettings = new Configuration.NullSettings(); var logger = new TestLogger(); // Act using (var cacheContext = new SourceCacheContext()) { var result = await PackagePreFetcher.GetPackagesAsync( actions, packagesFolder, new PackageDownloadContext(cacheContext), globalPackagesFolder, logger, CancellationToken.None); // Assert Assert.Equal(0, result.Count); } } }
public async Task PackagePreFetcher_NoInstallActionsInput() { using (var packagesFolderDir = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var actions = new List <NuGetProjectAction>(); var packagesFolder = new FolderNuGetProject(packagesFolderDir); var testSettings = new Configuration.NullSettings(); var logger = new TestLogger(); var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")); var target2 = new PackageIdentity("packageB", NuGetVersion.Parse("1.0.0")); actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target)); actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target2)); // Act var result = await PackagePreFetcher.GetPackagesAsync( actions, packagesFolder, testSettings, logger, CancellationToken.None); // Assert Assert.Equal(0, result.Count); } }
public async Task PackagePreFetcher_NoInstallActionsInput() { using (var packagesFolderDir = TestDirectory.Create()) using (var globalPackagesFolder = TestDirectory.Create()) { // Arrange var actions = new List <NuGetProjectAction>(); var packagesFolder = new FolderNuGetProject(packagesFolderDir); var testSettings = new Configuration.NullSettings(); var logger = new TestLogger(); var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")); var target2 = new PackageIdentity("packageB", NuGetVersion.Parse("1.0.0")); actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target, packagesFolder)); actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target2, packagesFolder)); // Act using (var cacheContext = new SourceCacheContext()) { var result = await PackagePreFetcher.GetPackagesAsync( actions, packagesFolder, new PackageDownloadContext(cacheContext), globalPackagesFolder, logger, CancellationToken.None); // Assert Assert.Equal(0, result.Count); } } }
public void PackageExists_PackageIdentity_ThrowsForNullPackageIdentity() { var project = new FolderNuGetProject(root: "a"); var exception = Assert.Throws <ArgumentNullException>(() => project.PackageExists(packageIdentity: null)); Assert.Equal("packageIdentity", exception.ParamName); }
public void Constructor_StringPackagePathResolver_InitializesRootProperty() { var project = new FolderNuGetProject( root: "a", packagePathResolver: new PackagePathResolver(rootDirectory: "a")); Assert.Equal("a", project.Root); }
public async Task GetInstalledPackagesAsync_ReturnsEmptyEnumerable() { var project = new FolderNuGetProject(root: "a"); var packages = await project.GetInstalledPackagesAsync(CancellationToken.None); Assert.Empty(packages); }
/// <summary> /// No solution manager provided so only global packages cache will be considered. /// </summary> public PackageManagementPathResolver() { var settings = SettingsLoader.LoadDefaultSettings(); var pathContext = NuGetPathContext.Create(settings); pathResolver = new FallbackPackagePathResolver(pathContext); globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder); folderNuGetProject = new FolderNuGetProject(pathContext.UserPackageFolder); }
public PackageManagementPathResolver(IMonoDevelopSolutionManager solutionManager) { var pathContext = NuGetPathContext.Create(solutionManager.Settings); pathResolver = new FallbackPackagePathResolver(pathContext); globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder); string packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, solutionManager.Settings); folderNuGetProject = new FolderNuGetProject(packagesFolderPath); }
private static PackageArchiveReader GetArchiveReader(this NuGetPackage pkg, FolderNuGetProject project) { var pkgPath = pkg.GetPackageFilePath(project)?.FullPath; if (pkgPath == null) { return(null); } return(new PackageArchiveReader(pkgPath, null, null)); }
public async Task UninstallPackageAsync_DoesNothing() { var project = new FolderNuGetProject(root: "a"); var wasUninstalled = await project.UninstallPackageAsync( new PackageIdentity(id : "a", version : NuGetVersion.Parse("1.0.0")), new Mock <INuGetProjectContext>(MockBehavior.Strict).Object, CancellationToken.None); Assert.True(wasUninstalled); }
public async Task InstallPackageAsync_WithSourceControlDisabled() { // Arrange var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); using (var randomTestSourcePath = TestDirectory.Create()) using (var randomTestDestinationPath = TestDirectory.Create()) { var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage( randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); // Create a nuget.config file with source control disabled File.WriteAllText( Path.Combine(randomTestSourcePath, "nuget.config"), @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <solution> <add key=""disableSourceControlIntegration"" value=""true"" /> </solution > </configuration>"); var settings = new Settings(randomTestSourcePath); var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath); var packagePathResolver = new PackagePathResolver(randomTestDestinationPath); var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity); var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity)); var testSourceControlManager = new TestSourceControlManager(settings); var testNuGetProjectContext = new TestNuGetProjectContext() { SourceControlManagerProvider = new TestSourceControlManagerProvider(testSourceControlManager) }; var token = CancellationToken.None; using (var packageStream = GetDownloadResourceResult(packageFileInfo)) { // Act await folderNuGetProject.InstallPackageAsync( packageIdentity, packageStream, testNuGetProjectContext, token); } // Assert Assert.True(File.Exists(nupkgFilePath)); Assert.Equal(0, testSourceControlManager.PendAddedFiles.Count); } }
public async Task InstallPackageAsync_WithSourceControlEnabled() { // Arrange var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); using (var randomTestSourcePath = TestDirectory.Create()) using (var randomTestDestinationPath = TestDirectory.Create()) { var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage( randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath); var packagePathResolver = new PackagePathResolver(randomTestDestinationPath); var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity); var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity)); var testSourceControlManager = new TestSourceControlManager(); var testNuGetProjectContext = new TestNuGetProjectContext() { SourceControlManagerProvider = new TestSourceControlManagerProvider(testSourceControlManager) }; var token = CancellationToken.None; using (var packageStream = GetDownloadResourceResult(packageFileInfo)) { // Act await folderNuGetProject.InstallPackageAsync( packageIdentity, packageStream, testNuGetProjectContext, token); } // Assert Assert.True(File.Exists(nupkgFilePath)); Assert.Equal(5, testSourceControlManager.PendAddedFiles.Count); Assert.True(testSourceControlManager.PendAddedFiles.Contains(nupkgFilePath)); var expectedEntries = new[] { "lib/test.dll", "lib/net40/test40.dll", "lib/net40/test40b.dll", "lib/net45/test45.dll" }; Assert.All( expectedEntries.Select(e => Path.Combine(packageInstallPath, e.Replace('/', Path.DirectorySeparatorChar))), item => Assert.Contains(item, testSourceControlManager.PendAddedFiles)); } }
public string GetPackagePathInOutputDirectory(PackageIdentity identity) { var project = new FolderNuGetProject(OutputPackagesPath); var path = project.GetInstalledPath(identity); if (string.IsNullOrEmpty(path)) { return(null); } return(path); }
public async Task DeletePackage_DeletesPackage() { // Arrange using (var randomTestSourcePath = TestDirectory.Create()) using (var randomTestDestinationPath = TestDirectory.Create()) { var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyContentPackage( randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath); var packagePathResolver = new PackagePathResolver(randomTestDestinationPath); var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity); var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity)); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using (var packageStream = GetDownloadResourceResult(packageFileInfo)) { // Act await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } var unNormalizedPackageIdentity = new PackageIdentity(packageIdentity.Id, new NuGetVersion(packageIdentity.Version + ".0")); // Assert Assert.True(File.Exists(nupkgFilePath)); Assert.True(File.Exists(Path.Combine(packageInstallPath, "Content/Scripts/test1.js"))); using (var packageStream = File.OpenRead(nupkgFilePath)) { var zipArchive = new ZipArchive(packageStream); Assert.Equal(6, zipArchive.Entries.Count); } Assert.True(folderNuGetProject.PackageExists(packageIdentity)); var packageDirectoryPath = folderNuGetProject.GetInstalledPath(unNormalizedPackageIdentity); Assert.True(!string.IsNullOrEmpty(packageDirectoryPath)); Assert.True(Directory.Exists(packageDirectoryPath)); // Main Act await folderNuGetProject.DeletePackage(packageIdentity, testNuGetProjectContext, CancellationToken.None); // Assert Assert.False(folderNuGetProject.PackageExists(unNormalizedPackageIdentity)); // Check that the package directories are deleted Assert.False(Directory.Exists(packageDirectoryPath)); } }
/// <summary> /// Constructor /// </summary> /// <param name="packageSource">package source</param> /// <param name="destinationPath">destination path where the packages should be downloaded</param> internal NuGetPackageDownloader(string packageSource, string destinationPath) { _logger = new Logger(); _providers = new List <Lazy <INuGetResourceProvider> >(); _providers.AddRange(Repository.Provider.GetCoreV3()); _packageSource = new PackageSource(packageSource); _sourceRepository = new SourceRepository(_packageSource, _providers); _searchResource = _sourceRepository.GetResource <PackageSearchResource>(); _settings = Settings.LoadDefaultSettings(destinationPath); _project = new FolderNuGetProject(destinationPath); _packageManager = new NuGetPackageManager(new SourceRepositoryProvider(new PackageSourceProvider(_settings), _providers), _settings, destinationPath); _projectContext = new ProjectContext(_logger); _searchFilter = new SearchFilter(true, SearchFilterType.IsAbsoluteLatestVersion); _resolutionContext = new ResolutionContext(NuGet.Resolver.DependencyBehavior.Ignore, false, false, VersionConstraints.None); _secondarySources = new List <SourceRepository>(); }
public async Task PackagePreFetcher_PackageAlreadyExistsReinstall() { using (var sourceDir = TestDirectory.Create()) using (var packagesFolderDir = TestDirectory.Create()) using (var globalPackagesFolder = TestDirectory.Create()) { // Arrange var actions = new List <NuGetProjectAction>(); var packagesFolder = new FolderNuGetProject(packagesFolderDir); var testSettings = NullSettings.Instance; var logger = new TestLogger(); var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")); var source = Repository.Factory.GetVisualStudio(new Configuration.PackageSource(sourceDir.Path)); // Add package AddToPackagesFolder(target, packagesFolderDir); actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target, packagesFolder)); actions.Add(NuGetProjectAction.CreateInstallProjectAction(target, source, packagesFolder)); AddToSource(target, sourceDir); // Act using (var cacheContext = new SourceCacheContext()) { var result = await PackagePreFetcher.GetPackagesAsync( actions, packagesFolder, new PackageDownloadContext(cacheContext), globalPackagesFolder, logger, CancellationToken.None); using (var downloadResult = await result[target].GetResultAsync()) { // Assert Assert.Equal(1, result.Count); Assert.False(result[target].InPackagesFolder); Assert.Equal(source.PackageSource, result[target].Source); Assert.Equal(target, result[target].Package); Assert.True(result[target].IsComplete); Assert.Equal(target, downloadResult.PackageReader.GetIdentity()); Assert.NotNull(downloadResult.PackageStream); Assert.Equal(DownloadResourceResultStatus.Available, downloadResult.Status); } } } }
public async Task PackagePreFetcher_PackageDoesNotExistAnywhere() { using (var sourceDir = TestDirectory.Create()) using (var packagesFolderDir = TestDirectory.Create()) using (var globalPackagesFolder = TestDirectory.Create()) { // Arrange var actions = new List <NuGetProjectAction>(); var packagesFolder = new FolderNuGetProject(packagesFolderDir); var testSettings = NullSettings.Instance; var logger = new TestLogger(); var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")); var source = Repository.Factory.GetVisualStudio(new Configuration.PackageSource(sourceDir.Path)); actions.Add(NuGetProjectAction.CreateInstallProjectAction(target, source, packagesFolder)); // Act using (var cacheContext = new SourceCacheContext()) { var result = await PackagePreFetcher.GetPackagesAsync( actions, packagesFolder, new PackageDownloadContext(cacheContext), globalPackagesFolder, logger, CancellationToken.None); Exception exception = null; try { using (await result[target].GetResultAsync()) { } Assert.True(false); } catch (Exception ex) { exception = ex; } // Assert Assert.StartsWith("Package 'packageA.1.0.0' is not found on source", exception.Message); } } }
internal FolderNuGetProjectTest(bool useSideBySidePaths = true) { PackageIdentity = new PackageIdentity(id: "a", version: NuGetVersion.Parse("1.0.0")); TestDirectory = TestDirectory.Create(); ProjectDirectory = Directory.CreateDirectory(Path.Combine(TestDirectory.Path, "project")); Resolver = new PackagePathResolver(ProjectDirectory.FullName, useSideBySidePaths); Project = new FolderNuGetProject(ProjectDirectory.FullName, Resolver); var sourcePackageDirectoryPath = Path.Combine(TestDirectory.Path, "source"); Directory.CreateDirectory(sourcePackageDirectoryPath); Package = TestPackagesGroupedByFolder.GetLegacyTestPackage( sourcePackageDirectoryPath, PackageIdentity.Id, PackageIdentity.Version.ToNormalizedString()); }
public void TryGetMetadata_GetsProjectMetadata() { // Arrange using (var randomTestFolder = TestDirectory.Create()) { var folderNuGetProject = new FolderNuGetProject(randomTestFolder); // Act & Assert NuGetFramework targetFramework; Assert.True(folderNuGetProject.TryGetMetadata(NuGetProjectMetadataKeys.TargetFramework, out targetFramework)); string name; Assert.True(folderNuGetProject.TryGetMetadata(NuGetProjectMetadataKeys.Name, out name)); Assert.Equal(NuGetFramework.AnyFramework, targetFramework); Assert.Equal(randomTestFolder, name); Assert.Equal(2, folderNuGetProject.Metadata.Count); } }
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); } }
private static async Task InstallPackage(PackageIdentity packageIdentity, string packageRoot, NuGetFramework framework) { var packagesPath = Path.Combine(packageRoot, "packages"); var settings = Settings.LoadDefaultSettings(packageRoot, null, new XPlatMachineWideSetting()); var sourceRepositoryProvider = new SourceRepositoryProvider(settings); var folder = new FolderNuGetProject(packageRoot, new PackagePathResolver(packageRoot), framework ?? FrameworkConstants.CommonFrameworks.NetStandard20); var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, packagesPath) { PackagesFolderNuGetProject = folder }; var resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, includePrelease: false, includeUnlisted: false, VersionConstraints.None); var projectContext = new NuGetProjectContext(settings); var retryPolicy = Policy .Handle <Exception>() .WaitAndRetryAsync( 5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (exception, _, __) => { Log.Warning( "An exception was thrown whilst retrieving or installing {0}: {1}", packageIdentity, exception); }); await retryPolicy.ExecuteAsync(async() => { await packageManager.InstallPackageAsync( packageManager.PackagesFolderNuGetProject, packageIdentity, resolutionContext, projectContext, sourceRepositoryProvider.GetDefaultRepositories(), Array.Empty <SourceRepository>(), CancellationToken.None).ConfigureAwait(false); }).ConfigureAwait(false); }
private void ExtractPackageAssemblies(IEnumerable <PackageIdentity> identities) { if (!Extract) { return; } var project = new FolderNuGetProject(_downloadDir); if (!Directory.Exists(_extractDir)) { Directory.CreateDirectory(_extractDir); } foreach (PackageIdentity identity in identities) { string packageFilePath = project.GetInstalledPackageFilePath(identity); if (string.IsNullOrWhiteSpace(packageFilePath)) { continue; } FrameworkSpecificGroup?referenceGroup; using (var archiveReader = new PackageArchiveReader(packageFilePath, null, null)) referenceGroup = GetMostCompatibleGroup(_framework, archiveReader.GetReferenceItems()); if (referenceGroup is null || referenceGroup.Items is null || !referenceGroup.Items.Any()) { continue; } string nugetPackagePath = project.GetInstalledPath(identity); Parallel.ForEach(referenceGroup.Items, x => { string sourceAssemblyPath = Path.Combine(nugetPackagePath, x); string assemblyName = Path.GetFileName(sourceAssemblyPath); string destinationAssemblyPath = Path.Combine(_extractDir, assemblyName); File.Copy(sourceAssemblyPath, destinationAssemblyPath, true); }); } }
public void TestFolderNuGetProjectMetadata() { // Arrange var randomTestFolder = TestFilesystemUtility.CreateRandomTestFolder(); var folderNuGetProject = new FolderNuGetProject(randomTestFolder); // Act & Assert NuGetFramework targetFramework; Assert.True(folderNuGetProject.TryGetMetadata <NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework, out targetFramework)); string name; Assert.True(folderNuGetProject.TryGetMetadata <string>(NuGetProjectMetadataKeys.Name, out name)); Assert.Equal(NuGetFramework.AnyFramework, targetFramework); Assert.Equal(randomTestFolder, name); Assert.Equal(2, folderNuGetProject.Metadata.Count); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(randomTestFolder); }