public async ValueTask UninstallPackagesAsync( string projectId, IReadOnlyList <PackageIdentity> packageIdentities, CancellationToken cancellationToken) { Assumes.NotNullOrEmpty(projectId); Assumes.NotNullOrEmpty(packageIdentities); cancellationToken.ThrowIfCancellationRequested(); MSBuildNuGetProject project = await GetMsBuildNuGetProjectAsync(projectId, cancellationToken); IEnumerable <NuGetProjectAction>?actions = packageIdentities .Select(packageIdentity => NuGetProjectAction.CreateUninstallProjectAction(packageIdentity, project)); NuGetPackageManager packageManager = await _state.GetPackageManagerAsync(cancellationToken); Assumes.NotNull(packageManager); INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>(); Assumes.NotNull(projectContext); await packageManager.ExecuteNuGetProjectActionsAsync( project, actions, projectContext, NullSourceCacheContext.Instance, CancellationToken.None); }
/// <summary> /// Get the list of packages to be reinstalled given the project framework and packageReferences /// </summary> /// <param name="projectFramework">Current target framework of the project</param> /// <param name="packageReferences">List of package references in the project from which packages to be reinstalled are determined</param> /// <returns>List of package identities to be reinstalled</returns> public static async Task <List <PackageIdentity> > GetPackagesToBeReinstalledAsync(NuGetFramework projectFramework, IEnumerable <Packaging.PackageReference> packageReferences) { Debug.Assert(projectFramework != null); Debug.Assert(packageReferences != null); var packagesToBeReinstalled = new List <PackageIdentity>(); var sourceRepositoryProvider = await ServiceLocator.GetComponentModelServiceAsync <ISourceRepositoryProvider>(); var solutionManager = await ServiceLocator.GetComponentModelServiceAsync <ISolutionManager>(); var settings = await ServiceLocator.GetComponentModelServiceAsync <Configuration.ISettings>(); var deleteOnRestartManager = await ServiceLocator.GetComponentModelServiceAsync <IDeleteOnRestartManager>(); var restoreProgressReporter = await ServiceLocator.GetComponentModelServiceAsync <IRestoreProgressReporter>(); var packageManager = new NuGetPackageManager( sourceRepositoryProvider, settings, solutionManager, deleteOnRestartManager, restoreProgressReporter); foreach (var packageReference in packageReferences) { var identity = packageReference.PackageIdentity; if (identity != null && ShouldPackageBeReinstalled(projectFramework, packageReference.TargetFramework, identity, packageManager)) { packagesToBeReinstalled.Add(identity); } } return(packagesToBeReinstalled); }
private async Task<SourceRepository> GetPackagesFolderSourceRepositoryAsync() { IVsSolutionManager solutionManager = await _sharedServiceState.SolutionManager.GetValueAsync(); ISettings settings = await ServiceLocator.GetComponentModelServiceAsync<ISettings>(); return _sharedServiceState.SourceRepositoryProvider.CreateRepository( new PackageSource(PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, settings)), FeedType.FileSystemPackagesConfig); }
private static async Task <NuGetProject> GetNuGetProject(Project envDTEProject) { var solutionManager = await ServiceLocator.GetComponentModelServiceAsync <IVsSolutionManager>(); var projectSafeName = await envDTEProject.GetCustomUniqueNameAsync(); var nuGetProject = await solutionManager.GetNuGetProjectAsync(projectSafeName); return(nuGetProject); }
public async ValueTask ExecuteActionsAsync(IReadOnlyList <ProjectAction> actions, CancellationToken cancellationToken) { Assumes.NotNullOrEmpty(actions); cancellationToken.ThrowIfCancellationRequested(); await CatchAndRethrowExceptionAsync(async() => { INuGetProjectContext?projectContext = null; try { projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>(); Assumes.NotNull(projectContext); if (IsDirectInstall(actions)) { NuGetPackageManager.SetDirectInstall(_state.PackageIdentity, projectContext); } var nugetProjectActions = new List <NuGetProjectAction>(); foreach (ProjectAction action in actions) { if (_state.ResolvedActions.TryGetValue(action.Id, out ResolvedAction resolvedAction)) { nugetProjectActions.Add(resolvedAction.Action); } } Assumes.NotNullOrEmpty(nugetProjectActions); NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken); IEnumerable <NuGetProject> projects = nugetProjectActions.Select(action => action.Project); await packageManager.ExecuteNuGetProjectActionsAsync( projects, nugetProjectActions, projectContext, _state.SourceCacheContext, cancellationToken); } finally { if (projectContext != null) { NuGetPackageManager.ClearDirectInstall(projectContext); } } }); }
public async ValueTask <IReadOnlyList <ProjectAction> > GetUninstallActionsAsync( IReadOnlyCollection <string> projectIds, PackageIdentity packageIdentity, bool removeDependencies, bool forceRemove, CancellationToken cancellationToken) { Assumes.NotNullOrEmpty(projectIds); Assumes.NotNull(packageIdentity); Assumes.False(packageIdentity.HasVersion); Assumes.NotNull(_state.SourceCacheContext); Assumes.Null(_state.PackageIdentity); Assumes.True(_state.ResolvedActions.Count == 0); cancellationToken.ThrowIfCancellationRequested(); return(await CatchAndRethrowExceptionAsync(async() => { INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>(); IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken); var projectActions = new List <ProjectAction>(); var uninstallationContext = new UninstallationContext(removeDependencies, forceRemove); NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken); IEnumerable <NuGetProjectAction> projectsWithActions = await packageManager.PreviewProjectsUninstallPackageAsync( projects, packageIdentity.Id, uninstallationContext, projectContext, cancellationToken); foreach (NuGetProjectAction projectWithActions in projectsWithActions) { var resolvedAction = new ResolvedAction(projectWithActions.Project, projectWithActions); var projectAction = new ProjectAction( CreateProjectActionId(), projectWithActions.Project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId), projectWithActions.PackageIdentity, projectWithActions.NuGetProjectActionType, implicitActions: null); _state.ResolvedActions[projectAction.Id] = resolvedAction; projectActions.Add(projectAction); } return projectActions; })); }
public async ValueTask <NuGetPackageManager> GetPackageManagerAsync(CancellationToken cancellationToken) { IDeleteOnRestartManager deleteOnRestartManager = await ServiceLocator.GetComponentModelServiceAsync <IDeleteOnRestartManager>(); ISettings settings = await ServiceLocator.GetComponentModelServiceAsync <ISettings>(); IVsSolutionManager solutionManager = await SolutionManager.GetValueAsync(cancellationToken); return(new NuGetPackageManager( SourceRepositoryProvider, settings, solutionManager, deleteOnRestartManager)); }
internal static async Task <bool> IsExperimentEnabledAsync(ExperimentationConstants exp) { bool isExpEnabled; try { var svc = await ServiceLocator.GetComponentModelServiceAsync <INuGetExperimentationService>(); isExpEnabled = svc?.IsExperimentEnabled(exp) ?? false; } catch (ServiceUnavailableException) { isExpEnabled = false; } return(isExpEnabled); }
public async ValueTask InstallPackagesAsync( string projectId, IReadOnlyList <PackageIdentity> packageIdentities, CancellationToken cancellationToken) { Assumes.NotNullOrEmpty(projectId); Assumes.NotNullOrEmpty(packageIdentities); cancellationToken.ThrowIfCancellationRequested(); NuGetProject?project = await SolutionUtility.GetNuGetProjectAsync( _state.SolutionManager, projectId, cancellationToken); Assumes.NotNull(project); SourceRepository?sourceRepository = await GetSourceRepositoryAsync(cancellationToken); IEnumerable <NuGetProjectAction>?actions = packageIdentities .Select(packageIdentity => NuGetProjectAction.CreateInstallProjectAction(packageIdentity, sourceRepository, project)); NuGetPackageManager packageManager = await _state.GetPackageManagerAsync(cancellationToken); Assumes.NotNull(packageManager); INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>(); Assumes.NotNull(projectContext); await packageManager.ExecuteBuildIntegratedProjectActionsAsync( project as BuildIntegratedNuGetProject, actions, projectContext, cancellationToken); }
public async ValueTask <IReadOnlyList <ProjectAction> > GetUpdateActionsAsync( IReadOnlyCollection <string> projectIds, IReadOnlyCollection <PackageIdentity> packageIdentities, VersionConstraints versionConstraints, bool includePrelease, DependencyBehavior dependencyBehavior, IReadOnlyList <string> packageSourceNames, CancellationToken cancellationToken) { Assumes.NotNullOrEmpty(projectIds); Assumes.NotNullOrEmpty(packageIdentities); Assumes.NotNullOrEmpty(packageSourceNames); Assumes.NotNull(_state.SourceCacheContext); Assumes.NotNull(_state.ResolvedActions); Assumes.Null(_state.PackageIdentity); return(await CatchAndRethrowExceptionAsync(async() => { var primarySources = new List <SourceRepository>(); var secondarySources = new List <SourceRepository>(); IEnumerable <SourceRepository> sourceRepositories = _sharedState.SourceRepositoryProvider.GetRepositories(); var packageSourceNamesSet = new HashSet <string>(packageSourceNames, StringComparer.OrdinalIgnoreCase); foreach (SourceRepository sourceRepository in sourceRepositories) { if (packageSourceNamesSet.Contains(sourceRepository.PackageSource.Name)) { primarySources.Add(sourceRepository); } if (sourceRepository.PackageSource.IsEnabled) { secondarySources.Add(sourceRepository); } } INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>(); IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken); var resolutionContext = new ResolutionContext( dependencyBehavior, includePrelease, includeUnlisted: true, versionConstraints, new GatherCache(), _state.SourceCacheContext); NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken); IEnumerable <NuGetProjectAction> actions = await packageManager.PreviewUpdatePackagesAsync( packageIdentities.ToList(), projects, resolutionContext, projectContext, primarySources, secondarySources, cancellationToken); var projectActions = new List <ProjectAction>(); foreach (NuGetProjectAction action in actions) { var resolvedAction = new ResolvedAction(action.Project, action); ProjectAction projectAction = CreateProjectAction(resolvedAction); _state.ResolvedActions[projectAction.Id] = resolvedAction; projectActions.Add(projectAction); } return projectActions; })); }
public async ValueTask <IReadOnlyList <ProjectAction> > GetInstallActionsAsync( IReadOnlyCollection <string> projectIds, PackageIdentity packageIdentity, VersionConstraints versionConstraints, bool includePrelease, DependencyBehavior dependencyBehavior, IReadOnlyList <string> packageSourceNames, CancellationToken cancellationToken) { Assumes.NotNullOrEmpty(projectIds); Assumes.NotNull(packageIdentity); Assumes.NotNullOrEmpty(packageSourceNames); Assumes.Null(_state.PackageIdentity); Assumes.True(_state.ResolvedActions.Count == 0); Assumes.NotNull(_state.SourceCacheContext); cancellationToken.ThrowIfCancellationRequested(); return(await CatchAndRethrowExceptionAsync(async() => { _state.PackageIdentity = packageIdentity; IReadOnlyList <SourceRepository> sourceRepositories = GetSourceRepositories( packageSourceNames, cancellationToken); Assumes.NotNullOrEmpty(sourceRepositories); INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>(); IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken); var resolutionContext = new ResolutionContext( dependencyBehavior, includePrelease, includeUnlisted: false, versionConstraints, new GatherCache(), _state.SourceCacheContext); NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken); IEnumerable <ResolvedAction> resolvedActions = await packageManager.PreviewProjectsInstallPackageAsync( projects, _state.PackageIdentity, resolutionContext, projectContext, sourceRepositories, cancellationToken); var projectActions = new List <ProjectAction>(); foreach (ResolvedAction resolvedAction in resolvedActions) { ProjectAction projectAction = CreateProjectAction(resolvedAction); _state.ResolvedActions[projectAction.Id] = resolvedAction; projectActions.Add(projectAction); } return projectActions; })); }
public static async ValueTask <SharedServiceState> CreateAsync(CancellationToken cancellationToken) { var sourceRepositoryProvider = await ServiceLocator.GetComponentModelServiceAsync <ISourceRepositoryProvider>(); return(new SharedServiceState(sourceRepositoryProvider)); }
internal async Task <(IPackageFeed?mainFeed, IPackageFeed?recommenderFeed)> CreatePackageFeedAsync( IReadOnlyCollection <IProjectContextInfo> projectContextInfos, IReadOnlyCollection <string> targetFrameworks, ItemFilter itemFilter, bool isSolution, bool recommendPackages, IEnumerable <SourceRepository> sourceRepositories, CancellationToken cancellationToken) { var logger = new VisualStudioActivityLogger(); var uiLogger = await ServiceLocator.GetComponentModelServiceAsync <INuGetUILogger>(); var packageFeeds = (mainFeed: (IPackageFeed?)null, recommenderFeed: (IPackageFeed?)null); if (itemFilter == ItemFilter.All && recommendPackages == false) { packageFeeds.mainFeed = new MultiSourcePackageFeed(sourceRepositories, uiLogger, TelemetryActivity.NuGetTelemetryService); return(packageFeeds); } IInstalledAndTransitivePackages installedAndTransitivePackages = await GetInstalledAndTransitivePackagesAsync(projectContextInfos, cancellationToken); PackageCollection installedPackageCollection = PackageCollection.FromPackageReferences(installedAndTransitivePackages.InstalledPackages); PackageCollection transitivePackageCollection = PackageCollection.FromPackageReferences(installedAndTransitivePackages.TransitivePackages); IEnumerable <SourceRepository> globalPackageFolderRepositories = await GetAllPackageFoldersAsync(projectContextInfos, cancellationToken); SourceRepository packagesFolderSourceRepository = await _packagesFolderLocalRepositoryLazy.GetValueAsync(cancellationToken); var metadataProvider = new MultiSourcePackageMetadataProvider( sourceRepositories, packagesFolderSourceRepository, globalPackageFolderRepositories, logger); if (itemFilter == ItemFilter.All) { // if we get here, recommendPackages == true packageFeeds.mainFeed = new MultiSourcePackageFeed(sourceRepositories, uiLogger, TelemetryActivity.NuGetTelemetryService); packageFeeds.recommenderFeed = new RecommenderPackageFeed( sourceRepositories, installedPackageCollection, transitivePackageCollection, targetFrameworks, metadataProvider, logger); return(packageFeeds); } if (itemFilter == ItemFilter.Installed) { if (isSolution) { packageFeeds.mainFeed = new InstalledPackageFeed(installedPackageCollection, metadataProvider); } else // is Project { CounterfactualLoggers.PMUITransitiveDependencies.EmitIfNeeded(); if (await ExperimentUtility.IsTransitiveOriginExpEnabled.GetValueAsync(cancellationToken)) { packageFeeds.mainFeed = new InstalledAndTransitivePackageFeed(installedPackageCollection, transitivePackageCollection, metadataProvider); } else { packageFeeds.mainFeed = new InstalledPackageFeed(installedPackageCollection, metadataProvider); } } return(packageFeeds); } if (itemFilter == ItemFilter.Consolidate) { packageFeeds.mainFeed = new ConsolidatePackageFeed(installedPackageCollection, metadataProvider, logger); return(packageFeeds); } // Search all / updates available cannot work without a source repo if (sourceRepositories == null) { return(packageFeeds); } if (itemFilter == ItemFilter.UpdatesAvailable) { packageFeeds.mainFeed = new UpdatePackageFeed( _serviceBroker, installedPackageCollection, metadataProvider, projectContextInfos.ToArray()); return(packageFeeds); } throw new InvalidOperationException( string.Format(CultureInfo.CurrentCulture, Strings.UnsupportedFeedType, itemFilter)); }