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); } }
public VisualStudioUIContext( NuGetPackage package, ISourceRepositoryProvider sourceProvider, ISolutionManager solutionManager, NuGetPackageManager packageManager, UIActionEngine uiActionEngine, IPackageRestoreManager packageRestoreManager, IOptionsPageActivator optionsPageActivator, IEnumerable<NuGet.ProjectManagement.NuGetProject> projects) : base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects) { _package = package; }
public static Task AcceptLicenses ( IEnumerable<SourceRepository> sources, IEnumerable<NuGetProjectAction> actions, NuGetPackageManager packageManager, CancellationToken cancellationToken) { return AcceptLicenses ( sources, actions, new MonoDevelopNuGetPackageManager (packageManager), new LicenseAcceptanceService (), cancellationToken); }
public MonoDevelopNuGetPackageManager (IMonoDevelopSolutionManager solutionManager) { var restartManager = new DeleteOnRestartManager (); settings = solutionManager.Settings; packageManager = new NuGetPackageManager ( solutionManager.CreateSourceRepositoryProvider (), settings, solutionManager, restartManager ); }
public StandaloneUIContext( string settingsFile, ISourceRepositoryProvider sourceProvider, ISolutionManager solutionManager, NuGetPackageManager packageManager, UIActionEngine uiActionEngine, IPackageRestoreManager packageRestoreManager, IOptionsPageActivator optionsPageActivator, IEnumerable<NuGet.ProjectManagement.NuGetProject> projects) : base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects) { _settingsFile = settingsFile; LoadSettings(); }
public INuGetUIContext Create(string settingsFile, IEnumerable<NuGetProject> projects) { if (String.IsNullOrEmpty(settingsFile)) { throw new ArgumentException("settingsFile"); } if (projects == null || !projects.Any()) { throw new ArgumentNullException("projects"); } NuGetPackageManager packageManager = new NuGetPackageManager(_repositoryProvider, _settings, _solutionManager); UIActionEngine actionEngine = new UIActionEngine(_repositoryProvider, packageManager); return new StandaloneUIContext(settingsFile, _repositoryProvider, _solutionManager, packageManager, actionEngine, _restoreManager, _optionsPage, projects); }
public async Task TestPackageRestoredEvent() { // Arrange var testSolutionManager = new TestSolutionManager(); var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = Packages[0]; var testNuGetProjectContext = new TestNuGetProjectContext(); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = NullSettings.Instance; var resolutionContext = new ResolutionContext(); var token = CancellationToken.None; var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager); var restoredPackages = new List<PackageIdentity>(); packageRestoreManager.PackageRestoredEvent += delegate(object sender, PackageRestoredEventArgs args) { if(args.Restored) { restoredPackages.Add(args.Package); } }; Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(packageIdentity)); // Delete packages folder Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); // Act await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(CancellationToken.None); Assert.Equal(1, restoredPackages.Count); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); }
public async Task TestPacManInstallPackage() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder(); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath); var packageIdentity = NoDependencyLibPackages[0]; // Pre-Assert // Check that the packages.config file does not exist Assert.False(File.Exists(randomPackagesConfigPath)); // Check that there are no packages returned by PackagesConfigProject var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, packagesInPackagesConfig.Count); Assert.Equal(0, msBuildNuGetProjectSystem.References.Count); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, packagesInPackagesConfig.Count); Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath); }
public INuGetUIContext Create(NuGetPackage package, IEnumerable<NuGet.ProjectManagement.NuGetProject> projects) { if (projects == null || !projects.Any()) { throw new ArgumentNullException("projects"); } NuGetPackageManager packageManager = new NuGetPackageManager(_repositoryProvider, _settings, _solutionManager); UIActionEngine actionEngine = new UIActionEngine(_repositoryProvider, packageManager); return new VisualStudioUIContext( package, _repositoryProvider, _solutionManager, packageManager, actionEngine, _restoreManager, _optionsPage, projects); }
public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (String.IsNullOrEmpty(packageId)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId")); } NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager); UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false); VSAPIProjectContext projectContext = new VSAPIProjectContext(); // find the project NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext); // uninstall the package PackageManagementHelpers.RunSync(async () => await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None)); }
private static async Task<bool> RestorePackageAsync(NuGetPackageManager nuGetPackageManager, PackageIdentity packageIdentity, INuGetProjectContext nuGetProjectContext, EventHandler<PackageRestoredEventArgs> packageRestoredEvent, IEnumerable<SourceRepository> sourceRepositories, CancellationToken token) { bool restored = await nuGetPackageManager.RestorePackageAsync(packageIdentity, nuGetProjectContext, sourceRepositories, token); // At this point, it is guaranteed that package restore did not fail if(packageRestoredEvent != null) { packageRestoredEvent(null, new PackageRestoredEventArgs(packageIdentity, restored)); } return restored; }
public async virtual Task<bool> RestoreMissingPackagesAsync(IEnumerable<PackageReference> packageReferences, CancellationToken token) { if(packageReferences == null) { throw new ArgumentNullException("packageReferences"); } var nuGetPackageManager = new NuGetPackageManager(SourceRepositoryProvider, Settings, SolutionManager); return await RestoreMissingPackages(nuGetPackageManager, packageReferences, SolutionManager.NuGetProjectContext ?? new EmptyNuGetProjectContext(), token, PackageRestoredEvent); }
public static async Task<bool> RestoreMissingPackages(NuGetPackageManager nuGetPackageManager, IEnumerable<PackageReference> packageReferences, INuGetProjectContext nuGetProjectContext, CancellationToken token, EventHandler<PackageRestoredEventArgs> packageRestoredEvent = null, IEnumerable<SourceRepository> sourceRepositories = null) { if(nuGetPackageManager == null) { throw new ArgumentNullException("nuGetPackageManager"); } if(packageReferences == null) { throw new ArgumentNullException("packageReferences"); } if(nuGetProjectContext == null) { throw new ArgumentNullException("nuGetProjectContext"); } if (!packageReferences.Any()) return false; var hashSetOfMissingPackageReferences = new HashSet<PackageReference>(packageReferences, new PackageReferenceComparer()); // Before starting to restore package, set the nuGetProjectContext such that satellite files are not copied yet // Satellite files will be copied as a post operation. This helps restore packages in parallel // and not have to determine if the package is a satellite package beforehand if(nuGetProjectContext.PackageExtractionContext == null) { nuGetProjectContext.PackageExtractionContext = new PackageExtractionContext(); } nuGetProjectContext.PackageExtractionContext.CopySatelliteFiles = false; token.ThrowIfCancellationRequested(); // TODO: Update this to use the locked version bool[] results = await Task.WhenAll(hashSetOfMissingPackageReferences.Select(uniqueMissingPackage => RestorePackageAsync(nuGetPackageManager, uniqueMissingPackage.PackageIdentity, nuGetProjectContext, packageRestoredEvent, sourceRepositories, token))); token.ThrowIfCancellationRequested(); bool[] satelliteFileResults = await Task.WhenAll(hashSetOfMissingPackageReferences.Select(uniqueMissingPackage => nuGetPackageManager.CopySatelliteFilesAsync(uniqueMissingPackage.PackageIdentity, nuGetProjectContext, token))); return results.Any() || satelliteFileResults.Any(); }
public IEnumerable<PackageReference> GetMissingPackages(IEnumerable<PackageReference> packageReferences) { var nuGetPackageManager = new NuGetPackageManager(SourceRepositoryProvider, Settings, SolutionManager); return GetMissingPackages(nuGetPackageManager, packageReferences); }
public static IEnumerable<PackageReference> GetMissingPackages(NuGetPackageManager nuGetPackageManager, IEnumerable<PackageReference> packageReferences) { try { return new HashSet<PackageReference>(packageReferences.Where(pr => !nuGetPackageManager.PackageExistsInPackagesFolder(pr.PackageIdentity)), new PackageReferenceComparer()); } catch (Exception) { // if an exception happens during the check, assume no missing packages and move on. // TODO : Write to NuGetProjectContext return Enumerable.Empty<PackageReference>(); } }
public async Task TestPacManPreviewInstallWithAllowedVersionsConstraint() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder(); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath); var newtonsoftJsonPackageId = "newtonsoft.json"; var newtonsoftJsonPackageIdentity = new PackageIdentity(newtonsoftJsonPackageId, NuGetVersion.Parse("4.5.11")); var primarySourceRepository = sourceRepositoryProvider.GetRepositories().Single(); var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, newtonsoftJsonPackageIdentity, resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token); // Assert // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, packagesInPackagesConfig.Count); Assert.Equal(newtonsoftJsonPackageIdentity, packagesInPackagesConfig[0].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework); var installedPackages = await msBuildNuGetProject.GetInstalledPackagesAsync(token); var newtonsoftJsonPackageReference = installedPackages.Where(pr => pr.PackageIdentity.Equals(newtonsoftJsonPackageIdentity)).FirstOrDefault(); Assert.Null(newtonsoftJsonPackageReference.AllowedVersions); const string newPackagesConfig = @"<?xml version='1.0' encoding='utf-8'?> <packages> <package id='Newtonsoft.Json' version='4.5.11' allowedVersions='[4.0,5.0)' targetFramework='net45' /> </packages> "; File.WriteAllText(randomPackagesConfigPath, newPackagesConfig); // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, packagesInPackagesConfig.Count); Assert.Equal(newtonsoftJsonPackageIdentity, packagesInPackagesConfig[0].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework); installedPackages = await msBuildNuGetProject.GetInstalledPackagesAsync(token); newtonsoftJsonPackageReference = installedPackages.Where(pr => pr.PackageIdentity.Equals(newtonsoftJsonPackageIdentity)).FirstOrDefault(); Assert.NotNull(newtonsoftJsonPackageReference.AllowedVersions); Exception exception = null; try { // Main Act await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, newtonsoftJsonPackageId, resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token); } catch (Exception ex) { exception = ex; } Assert.NotNull(exception); }
public MonoDevelopNuGetPackageManager (NuGetPackageManager packageManager) { this.packageManager = packageManager; }
private void ExecuteInitScripts() { // Fix for Bug 1426 Disallow ExecuteInitScripts from being executed concurrently by multiple threads. lock (_initScriptsLock) { if (!_solutionManager.IsSolutionOpen) { return; } Debug.Assert(_settings != null); if (_settings == null) { return; } try { // invoke init.ps1 files in the order of package dependency. // if A -> B, we invoke B's init.ps1 before A's. IEnumerable<NuGetProject> projects = _solutionManager.GetNuGetProjects(); NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager); List<PackageIdentity> sortedPackages = new List<PackageIdentity>(); foreach (NuGetProject project in projects) { // Skip project K projects. if (project is NuGet.ProjectManagement.Projects.ProjectKNuGetProjectBase) { continue; } IEnumerable<PackageReference> installedRefs = project.GetInstalledPackagesAsync(CancellationToken.None).Result; if (installedRefs != null && installedRefs.Any()) { IEnumerable<PackageIdentity> installedPackages = packageManager.GetInstalledPackagesInDependencyOrder(project, new EmptyNuGetProjectContext(), CancellationToken.None).Result; sortedPackages.AddRange(installedPackages); } } // Get the path to the Packages folder. string packagesFolderPath = packageManager.PackagesFolderSourceRepository.PackageSource.Source; foreach (var package in sortedPackages) { PackagePathResolver packagePathResolver = new PackagePathResolver(packagesFolderPath); string pathToPackage = packagePathResolver.GetInstalledPath(package); string toolsPath = Path.Combine(pathToPackage, "tools"); AddPathToEnvironment(toolsPath); Runspace.ExecuteScript(toolsPath, PowerShellScripts.Init, package); } } catch (Exception ex) { // When Packages folder is not present, NuGetResolverInputException will be thrown // as resolving DependencyInfo requires the presence of Packages folder. if (ex.InnerException is NuGetResolverInputException) { // Silently fail. } else { // if execution of Init scripts fails, do not let it crash our console ReportError(ex); } ExceptionHelper.WriteToActivityLog(ex); } } }
public async Task TestPacManUninstallPackageOnMultipleProjects() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packagePathResolver = new PackagePathResolver(packagesFolderPath); var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = NoDependencyLibPackages[0]; // Act await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); var projectBInstalled = (await projectB.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, projectAInstalled.Count); Assert.Equal(1, projectBInstalled.Count); // Main Act var uninstallationContext = new UninstallationContext(); await nuGetPackageManager.UninstallPackageAsync(projectA, packageIdentity.Id, uninstallationContext, testNuGetProjectContext, token); // Assert projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); projectBInstalled = (await projectB.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, projectAInstalled.Count); Assert.Equal(1, projectBInstalled.Count); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity))); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory); }
public async Task TestPacManPreviewUpdateWithAllowedVersionsConstraint() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder(); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath); var newtonsoftJsonPackageId = "newtonsoft.json"; var newtonsoftJsonPackageIdentity = new PackageIdentity(newtonsoftJsonPackageId, NuGetVersion.Parse("4.5.11")); var primarySourceRepository = sourceRepositoryProvider.GetRepositories().Single(); var resolutionContext = new ResolutionContext(DependencyBehavior.Highest); var testNuGetProjectContext = new TestNuGetProjectContext(); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, newtonsoftJsonPackageIdentity, resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token); await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, new PackageIdentity("Microsoft.Web.Infrastructure", new NuGetVersion("1.0.0.0")), resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token); // Assert // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, packagesInPackagesConfig.Count); Assert.Equal(newtonsoftJsonPackageIdentity, packagesInPackagesConfig[1].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework); var installedPackages = await msBuildNuGetProject.GetInstalledPackagesAsync(token); var newtonsoftJsonPackageReference = installedPackages.Where(pr => pr.PackageIdentity.Equals(newtonsoftJsonPackageIdentity)).FirstOrDefault(); Assert.Null(newtonsoftJsonPackageReference.AllowedVersions); const string newPackagesConfig = @"<?xml version='1.0' encoding='utf-8'?> <packages> <package id='Microsoft.Web.Infrastructure' version='1.0.0.0' targetFramework='net45' /> <package id='Newtonsoft.Json' version='4.5.11' allowedVersions='[4.0,5.0)' targetFramework='net45' /> </packages> "; File.WriteAllText(randomPackagesConfigPath, newPackagesConfig); // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, packagesInPackagesConfig.Count); Assert.Equal(newtonsoftJsonPackageIdentity, packagesInPackagesConfig[1].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework); installedPackages = await msBuildNuGetProject.GetInstalledPackagesAsync(token); newtonsoftJsonPackageReference = installedPackages.Where(pr => pr.PackageIdentity.Equals(newtonsoftJsonPackageIdentity)).FirstOrDefault(); Assert.NotNull(newtonsoftJsonPackageReference.AllowedVersions); // Main Act var nuGetProjectActions = (await nuGetPackageManager.PreviewUpdatePackagesAsync(new List<string>() { newtonsoftJsonPackageId, "Microsoft.Web.Infrastructure" }, msBuildNuGetProject, resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token)).ToList(); // Microsoft.Web.Infrastructure has no updates. However, newtonsoft.json has updates but does not satisfy the version range // Hence, no nuget project actions to perform Assert.Equal(0, nuGetProjectActions.Count); }
public async Task<NuGetInstallResult> InstallPackage( string packageId, NuGetVersion version, bool prerelease) { var installPath = Path.Combine(Path.GetTempPath(), "testnuget"); var projectContext = new EmptyNuGetProjectContext { PackageExtractionContext = new PackageExtractionContext() }; var references = new List<string>(); var frameworkReferences = new List<string>(); var projectSystem = new DelegateNuGetProjectSystem(projectContext, (reference, isFrameworkReference) => { if (isFrameworkReference) frameworkReferences.Add(reference); else references.Add(reference); }); var project = new MSBuildNuGetProject(projectSystem, installPath, installPath); OverrideProject(project); var packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, installPath); var primaryRepositories = _packageSources.Select(_sourceRepositoryProvider.CreateRepository).ToArray(); var resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, includePrelease: prerelease, includeUnlisted: true, versionConstraints: VersionConstraints.None); if (version == null) { // Find the latest version using NuGetPackageManager version = await NuGetPackageManager.GetLatestVersionAsync( packageId, project, resolutionContext, primaryRepositories, NullLogger.Instance, CancellationToken.None).ConfigureAwait(false); if (version == null) { throw new Exception("Unable to find package"); } } var packageIdentity = new PackageIdentity(packageId, version); await packageManager.InstallPackageAsync( project, packageIdentity, resolutionContext, projectContext, primaryRepositories, Enumerable.Empty<SourceRepository>(), CancellationToken.None).ConfigureAwait(false); return new NuGetInstallResult(references.AsReadOnly(), frameworkReferences.AsReadOnly()); }
/// <summary> /// Core install method. All installs from the VS API and template wizard end up here. /// </summary> internal async Task InstallInternal(Project project, List<PackageIdentity> packages, ISourceRepositoryProvider repoProvider, VSAPIProjectContext projectContext, bool ignoreDependencies, CancellationToken token) { // store expanded node state IDictionary<string, ISet<VsHierarchyItem>> expandedNodes = VsHierarchyHelper.GetAllExpandedNodes(_solutionManager); try { DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest; bool includePrerelease = false; ResolutionContext resolution = new ResolutionContext(depBehavior, includePrerelease, false); NuGetPackageManager packageManager = new NuGetPackageManager(repoProvider, _settings, _solutionManager); // find the project NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext); // install the package foreach (PackageIdentity package in packages) { if (package.Version == null) { if (!_packageServices.IsPackageInstalled(project, package.Id)) { await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty<SourceRepository>(), token); } } else { if (!_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToString())) { await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty<SourceRepository>(), token); } } } } finally { // collapse nodes VsHierarchyHelper.CollapseAllNodes(_solutionManager, expandedNodes); } }
public async Task TestPacManPreviewInstallOrderOfDependencies() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder(); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath); var packageIdentity = MorePackageWithDependents[3]; // Pre-Assert // Check that the packages.config file does not exist Assert.False(File.Exists(randomPackagesConfigPath)); // Check that there are no packages returned by PackagesConfigProject var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, packagesInPackagesConfig.Count); Assert.Equal(0, msBuildNuGetProjectSystem.References.Count); // Act var packageActions = (await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, packageIdentity, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token)).ToList(); // Assert Assert.Equal(3, packageActions.Count); Assert.True(MorePackageWithDependents[0].Equals(packageActions[0].PackageIdentity)); Assert.Equal(NuGetProjectActionType.Install, packageActions[0].NuGetProjectActionType); Assert.Equal(sourceRepositoryProvider.GetRepositories().Single().PackageSource.Source, packageActions[0].SourceRepository.PackageSource.Source); Assert.True(MorePackageWithDependents[2].Equals(packageActions[1].PackageIdentity)); Assert.Equal(NuGetProjectActionType.Install, packageActions[1].NuGetProjectActionType); Assert.Equal(sourceRepositoryProvider.GetRepositories().Single().PackageSource.Source, packageActions[0].SourceRepository.PackageSource.Source); Assert.True(MorePackageWithDependents[3].Equals(packageActions[2].PackageIdentity)); Assert.Equal(NuGetProjectActionType.Install, packageActions[2].NuGetProjectActionType); Assert.Equal(sourceRepositoryProvider.GetRepositories().Single().PackageSource.Source, packageActions[0].SourceRepository.PackageSource.Source); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath); }
public async Task Install(IReadOnlyList<SourceRepository> remoteRepositories, NuGetPackageManager packageManager) { if (_versionMatch == null) { return; } IReadOnlyList<SourceRepository> sourceRepositories = GetSourceRepositories(remoteRepositories); Trace.Verbose($"Installing package {_packageId} {_versionMatch.Version}"); ResolutionContext resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, _allowPrereleaseVersions, _allowUnlisted, VersionConstraints.None); INuGetProjectContext projectContext = new NuGetProjectContext(); await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject, new PackageIdentity(_packageId, _versionMatch), resolutionContext, projectContext, sourceRepositories, Array.Empty<SourceRepository>(), CancellationToken.None); Trace.Verbose($"Installed package {_packageId} {_versionMatch.Version}"); }
public async Task TestPacManInstallPackageWhichUsesExistingDependency() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packagePathResolver = new PackagePathResolver(packagesFolderPath); var projectA = testSolutionManager.AddNewMSBuildProject(); var packageIdentity0 = PackageWithDependents[0]; var packageIdentity1 = PackageWithDependents[1]; var packageIdentity2 = PackageWithDependents[2]; var packageIdentity3 = PackageWithDependents[3]; // Act await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity3, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, projectAInstalled.Count); Assert.Equal(packageIdentity1, projectAInstalled[0].PackageIdentity); Assert.Equal(packageIdentity3, projectAInstalled[1].PackageIdentity); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity1))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity3))); // Main Act await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity2, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(3, projectAInstalled.Count); Assert.Equal(packageIdentity1, projectAInstalled[0].PackageIdentity); Assert.Equal(packageIdentity2, projectAInstalled[2].PackageIdentity); Assert.Equal(packageIdentity3, projectAInstalled[1].PackageIdentity); Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity1))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity3))); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory); }
public async Task TestPacManInstallLowerSpecificVersionOfDependencyPackage() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(DependencyBehavior.Highest); var testNuGetProjectContext = new TestNuGetProjectContext(); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packagePathResolver = new PackagePathResolver(packagesFolderPath); var projectA = testSolutionManager.AddNewMSBuildProject(); var packageIdentity0 = PackageWithDependents[0]; var dependentPackage = PackageWithDependents[2]; var latestVersion = await NuGetPackageManager.GetLatestVersionAsync(packageIdentity0.Id, resolutionContext, sourceRepositoryProvider.GetRepositories().First(), token); var packageLatest = new PackageIdentity(packageIdentity0.Id, latestVersion); // Act await nuGetPackageManager.InstallPackageAsync(projectA, dependentPackage, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, projectAInstalled.Count); Assert.Equal(packageLatest, projectAInstalled[0].PackageIdentity); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageLatest))); Assert.Equal(dependentPackage, projectAInstalled[1].PackageIdentity); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(dependentPackage))); Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0))); // Main Act await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity0, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, projectAInstalled.Count); Assert.Equal(packageIdentity0, projectAInstalled[0].PackageIdentity); Assert.Equal(dependentPackage, projectAInstalled[1].PackageIdentity); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(dependentPackage))); Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageLatest))); Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0))); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory); }
/// <summary> /// Устанавливает пакет. /// </summary> /// <param name="packageId">ID пакета.</param> /// <param name="packageVersion">Версия пакета.</param> /// <param name="allowPrerelease">Разрешена ли установка предварительного релиза.</param> /// <returns>Содержимое установленного пакета.</returns> public async Task<PackageContent> InstallPackage(string packageId, string packageVersion = null, bool allowPrerelease = false) { NuGetVersion packageNuGetVersion = null; if (!string.IsNullOrWhiteSpace(packageVersion)) { packageNuGetVersion = NuGetVersion.Parse(packageVersion); } // Конфигурационный файл NuGet.config по умолчанию var settings = new NuGet.Configuration.Settings(_packagesPath, "NuGet.config"); // Фабрика источников пактов на основе конфигурационного файла var packageSourceProvider = new PackageSourceProvider(settings); // Добавление в фабрику источников пакетов дополнительных источников packageSourceProvider.SavePackageSources(_packageSources.Select(i => new PackageSource(i))); // Фабрика хранилищ пакетов на основе фабрики источников пакетов var packageRepositoryProvider = new CachingSourceProvider(packageSourceProvider); // Получение всех хранилищ пакетов на основе указанных источников var packageRepositories = packageRepositoryProvider.GetRepositories().ToList(); // Определение возможности установки prerelease-версии пакетов allowPrerelease = allowPrerelease || (packageNuGetVersion != null && packageNuGetVersion.IsPrerelease); // Создание правил разрешения зависимостей при установке пакета var resolutionContext = new ResolutionContext( dependencyBehavior: DependencyBehavior.Lowest, includePrelease: allowPrerelease, includeUnlisted: true, versionConstraints: VersionConstraints.None); // Если версия пакета не указана, поиск последней версии if (packageNuGetVersion == null) { packageNuGetVersion = await NuGetPackageManager.GetLatestVersionAsync( packageId, NuGetFramework.AnyFramework, resolutionContext, packageRepositories, _logger, CancellationToken.None); if (packageNuGetVersion == null) { throw new InvalidOperationException(string.Format(Properties.Resources.PackageNotFound, packageId)); } } // Уникальный идентификатор версии пакета для установки var packageIdentity = new PackageIdentity(packageId, packageNuGetVersion); // Каталог для установки пакетов (каталог packages) NuGetProject folderProject = new InfinniFolderNuGetProject(_packagesPath); // Менеджер для управления пакетами var packageManager = new NuGetPackageManager(packageRepositoryProvider, settings, _packagesPath); // Правила установки пакетов var projectContext = new NuGetLoggerProjectContext(_logger) { PackageExtractionContext = new PackageExtractionContext { PackageSaveMode = PackageSaveMode.Defaultv3 } }; // Определение порядка действий при установке пакета var installActions = (await packageManager.PreviewInstallPackageAsync( folderProject, packageIdentity, resolutionContext, projectContext, packageRepositories, Enumerable.Empty<SourceRepository>(), CancellationToken.None)).ToList(); // Применение действий по установке пакета await packageManager.ExecuteNuGetProjectActionsAsync( folderProject, installActions, projectContext, CancellationToken.None); return GetPackageContent(packageIdentity, installActions.Select(i => i.PackageIdentity).ToList()); }
internal void InstallPackages() { DirectoryPath packagesPath = GetAbsolutePackagesPath(); Trace.Verbose($"Installing packages to {packagesPath.FullPath} (using {(UseLocalPackagesFolder ? "local" : "global")} packages folder)"); try { // Add the global default sources if requested if (UseGlobalPackageSources) { _sourceRepositories.AddGlobalDefaults(); } // Get the local repository SourceRepository localRepository = _sourceRepositories.CreateRepository(packagesPath.FullPath); // Get the package manager and repositories WyamFolderNuGetProject nuGetProject = new WyamFolderNuGetProject(_fileSystem, _assemblyLoader, _currentFramework, packagesPath.FullPath); NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositories, _settings, packagesPath.FullPath) { PackagesFolderNuGetProject = nuGetProject }; IReadOnlyList<SourceRepository> remoteRepositories = _sourceRepositories.GetDefaultRepositories(); // Resolve all the versions IReadOnlyList<SourceRepository> installationRepositories = remoteRepositories; try { ResolveVersions(localRepository, remoteRepositories); } catch (Exception ex) { Trace.Warning("Exception while resolving package versions, attempting without remote repositories"); Trace.Verbose($"Exception while resolving package versions: {ex.Message}"); installationRepositories = new[] {localRepository}; ResolveVersions(localRepository, Array.Empty<SourceRepository>()); } // Install the packages (doing this synchronously since doing it in parallel triggers file lock errors in NuGet on a clean system) try { InstallPackages(packageManager, installationRepositories); } catch (Exception ex) { Trace.Warning("Exception while installing packages, attempting without remote repositories"); Trace.Verbose($"Exception while installing packages: {(ex is AggregateException ? string.Join("; ", ((AggregateException)ex).InnerExceptions.Select(x => x.Message)) : ex.Message)}"); InstallPackages(packageManager, new[] { localRepository }); } // Process the package (do this after all packages have been installed) nuGetProject.ProcessAssembliesAndContent(); } catch (Exception ex) { Trace.Warning("Unexpected exception while installing packages, attempting to continue anyway"); Trace.Verbose($"Unexpected exception while installing packages: {(ex is AggregateException ? string.Join("; ", ((AggregateException)ex).InnerExceptions.Select(x => x.Message)) : ex.Message)}"); } }
private void InstallPackages(NuGetPackageManager packageManager, IReadOnlyList<SourceRepository> installationRepositories) { foreach (Package package in _packages.Values) { package.Install(installationRepositories, packageManager).Wait(); } }
public async Task TestPacManPreviewUninstallDependencyPackage() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSolutionManager = new TestSolutionManager(); var testSettings = new NullSettings(); var token = CancellationToken.None; var resolutionContext = new ResolutionContext(); var testNuGetProjectContext = new TestNuGetProjectContext(); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder(); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath); var packageIdentity = PackageWithDependents[2]; // Pre-Assert // Check that the packages.config file does not exist Assert.False(File.Exists(randomPackagesConfigPath)); // Check that there are no packages returned by PackagesConfigProject var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, packagesInPackagesConfig.Count); Assert.Equal(0, msBuildNuGetProjectSystem.References.Count); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(2, packagesInPackagesConfig.Count); Assert.Equal(packageIdentity, packagesInPackagesConfig[1].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework); Assert.Equal(PackageWithDependents[0], packagesInPackagesConfig[0].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework); // Main Act Exception exception = null; try { var uninstallationContext = new UninstallationContext(); var packageActions = await nuGetPackageManager.PreviewUninstallPackageAsync(msBuildNuGetProject, "jQuery", uninstallationContext, testNuGetProjectContext, token); } catch (InvalidOperationException ex) { exception = ex; } catch (AggregateException ex) { exception = ExceptionUtility.Unwrap(ex); } Assert.NotNull(exception); Assert.True(exception is InvalidOperationException); Assert.Equal("Unable to uninstall 'jQuery.1.4.4' because 'jQuery.Validation.1.13.1' depends on it.", exception.Message); // Clean-up TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath); }