/// <summary> /// Execute the installs/uninstalls /// </summary> private async Task ExecuteActionsAsync( IEnumerable <ResolvedAction> actions, INuGetProjectContext projectContext, ICommonOperations commonOperations, UserAction userAction, SourceCacheContext sourceCacheContext, CancellationToken token) { var processedDirectInstalls = new HashSet <PackageIdentity>(PackageIdentity.Comparer); foreach (var projectActions in actions.GroupBy(e => e.Project)) { var nuGetProjectActions = projectActions.Select(e => e.Action); var directInstall = GetDirectInstall(nuGetProjectActions, userAction, commonOperations); if (directInstall != null && !processedDirectInstalls.Contains(directInstall)) { NuGetPackageManager.SetDirectInstall(directInstall, projectContext); processedDirectInstalls.Add(directInstall); } await _packageManager.ExecuteNuGetProjectActionsAsync(projectActions.Key, nuGetProjectActions, projectContext, sourceCacheContext, token); NuGetPackageManager.ClearDirectInstall(projectContext); } }
/// <summary> /// Install package by Identity /// </summary> /// <param name="project"></param> /// <param name="identity"></param> /// <param name="resolutionContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <param name="isForce"></param> /// <param name="uninstallContext"></param> /// <returns></returns> protected async Task InstallPackageByIdentityAsync(NuGetProject project, PackageIdentity identity, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview) { try { var actions = await PackageManager.PreviewInstallPackageAsync(project, identity, resolutionContext, projectContext, PrimarySourceRepositories, null, CancellationToken.None); if (!actions.Any()) { // nuget operation status is set to NoOp to log under telemetry event _status = NuGetOperationStatus.NoOp; } else { // update packages count to be logged under telemetry event _packageCount = actions.Select(action => action.PackageIdentity.Id).Distinct(StringComparer.OrdinalIgnoreCase).Count(); } // stop telemetry event timer to avoid UI interaction TelemetryServiceUtility.StopTimer(); if (!ShouldContinueDueToDotnetDeprecation(actions, isPreview)) { // resume telemetry event timer after ui confirmation TelemetryServiceUtility.StartOrResumeTimer(); return; } // resume telemetry event timer after ui confirmation TelemetryServiceUtility.StartOrResumeTimer(); if (isPreview) { PreviewNuGetPackageActions(actions); } else { NuGetPackageManager.SetDirectInstall(identity, projectContext); await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, resolutionContext.SourceCacheContext, CancellationToken.None); NuGetPackageManager.ClearDirectInstall(projectContext); // Refresh Manager UI if needed RefreshUI(actions); } } catch (InvalidOperationException ex) { if (ex.InnerException is PackageAlreadyInstalledException) { // Set nuget operation status to NoOp for telemetry event when package // is already installed. _status = NuGetOperationStatus.NoOp; Log(MessageLevel.Info, ex.Message); } else { throw ex; } } }
/// <summary> /// Install package by Identity /// </summary> /// <param name="project"></param> /// <param name="identity"></param> /// <param name="resolutionContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <param name="isForce"></param> /// <param name="uninstallContext"></param> /// <returns></returns> protected async Task InstallPackageByIdentityAsync(NuGetProject project, PackageIdentity identity, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview) { try { var actions = await PackageManager.PreviewInstallPackageAsync(project, identity, resolutionContext, projectContext, PrimarySourceRepositories, null, CancellationToken.None); if (isPreview) { PreviewNuGetPackageActions(actions); } else { NuGetPackageManager.SetDirectInstall(identity, projectContext); await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None); NuGetPackageManager.ClearDirectInstall(projectContext); } } catch (InvalidOperationException ex) { if (ex.InnerException is PackageAlreadyInstalledException) { Log(ProjectManagement.MessageLevel.Info, ex.Message); } else { throw ex; } } }
/// <summary> /// Execute the installs/uninstalls /// </summary> private async Task ExecuteActionsAsync( IEnumerable <ResolvedAction> actions, INuGetProjectContext projectContext, ICommonOperations commonOperations, UserAction userAction, SourceCacheContext sourceCacheContext, CancellationToken token) { var nuGetProjects = actions.Select(action => action.Project); var nuGetActions = actions.Select(action => action.Action); var directInstall = GetDirectInstall(nuGetActions, userAction, commonOperations); if (directInstall != null) { NuGetPackageManager.SetDirectInstall(directInstall, projectContext); } await _packageManager.ExecuteNuGetProjectActionsAsync( nuGetProjects, nuGetActions, projectContext, sourceCacheContext, token); NuGetPackageManager.ClearDirectInstall(projectContext); }
/// <summary> /// Install package by Id /// </summary> /// <param name="project"></param> /// <param name="packageId"></param> /// <param name="resolutionContext"></param> /// <param name="projectContext"></param> /// <param name="isPreview"></param> /// <param name="isForce"></param> /// <param name="uninstallContext"></param> /// <returns></returns> protected async Task InstallPackageByIdAsync(NuGetProject project, string packageId, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview) { try { var actions = await PackageManager.PreviewInstallPackageAsync(project, packageId, resolutionContext, projectContext, PrimarySourceRepositories, null, CancellationToken.None); if (isPreview) { PreviewNuGetPackageActions(actions); } else { var identity = actions.Select(v => v.PackageIdentity).Where(p => p.Id.Equals(packageId, StringComparison.OrdinalIgnoreCase)).FirstOrDefault(); NuGetPackageManager.SetDirectInstall(identity, projectContext); await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None); NuGetPackageManager.ClearDirectInstall(projectContext); } } catch (InvalidOperationException ex) { if (ex.InnerException is PackageAlreadyInstalledException) { Log(ProjectManagement.MessageLevel.Info, ex.Message); } else { throw ex; } } }
protected async Task InstallPackageByIdAsync( NuGetProject project, string packageId, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview) { try { var packageManager = ConsoleHost.CreatePackageManager(); var latestVersion = await packageManager.GetLatestVersionAsync( packageId, project, resolutionContext, PrimarySourceRepositories, new LoggerAdapter (projectContext), ConsoleHost.Token); if (latestVersion == null) { throw new InvalidOperationException(GettextCatalog.GetString("Unable to find package '{0}", packageId)); } var identity = new PackageIdentity(Id, latestVersion.LatestVersion); var actions = await packageManager.PreviewInstallPackageAsync( project, identity, resolutionContext, projectContext, PrimarySourceRepositories, null, CancellationToken.None); if (isPreview) { PreviewNuGetPackageActions(actions); } else { NuGetPackageManager.SetDirectInstall(identity, projectContext); await packageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, ConsoleHost.Token); NuGetPackageManager.ClearDirectInstall(projectContext); } } catch (InvalidOperationException ex) { if (ex.InnerException is PackageAlreadyInstalledException) { Log(ProjectManagement.MessageLevel.Info, ex.Message); } else { throw ex; } } }
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 Task Do(string package, string version, string rootPath, string mainFile, bool skipSha256) { if (rootPath == null) { rootPath = Directory.GetCurrentDirectory(); } var logger = new Logger(); var providers = new List <Lazy <INuGetResourceProvider> >(); providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support var packageSource = new PackageSource("https://api.nuget.org/v3/index.json"); var sourceRepository = new SourceRepository(packageSource, providers); var packageMetadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>(); var verParsed = NuGetVersion.Parse(version); var identity = new NuGet.Packaging.Core.PackageIdentity(package, verParsed); var content = new SourceCacheContext(); var found = await packageMetadataResource.GetMetadataAsync(identity, content, logger, CancellationToken.None); var settings = Settings.LoadDefaultSettings(rootPath, null, new MachineWideSettings()); var project = new ProjectBazel(rootPath, mainFile, skipSha256); var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers); var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, rootPath) { PackagesFolderNuGetProject = project }; const bool allowPrereleaseVersions = false; const bool allowUnlisted = false; var resolutionContext = new ResolutionContext( DependencyBehavior.HighestMinor, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None); var projectContext = new ProjectContext(); var actions = await packageManager.PreviewInstallPackageAsync(packageManager.PackagesFolderNuGetProject, identity, resolutionContext, projectContext, sourceRepository, Array.Empty <SourceRepository>(), // This is a list of secondary source respositories, probably empty CancellationToken.None); project.NuGetProjectActions = actions; await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject, identity, resolutionContext, projectContext, sourceRepository, Array.Empty <SourceRepository>(), // This is a list of secondary source respositories, probably empty CancellationToken.None); NuGetPackageManager.ClearDirectInstall(projectContext); }
public async Task DoWithProject(string nugetSource, string package, string version, ProjectBazelManipulator project, bool lowest) { var logger = new Logger(); var providers = new List <Lazy <INuGetResourceProvider> >(); providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support var packageSource = new PackageSource(nugetSource); var sourceRepository = new SourceRepository(packageSource, providers); var packageMetadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>(); var verParsed = NuGetVersion.Parse(version); var identity = new NuGet.Packaging.Core.PackageIdentity(package, verParsed); var content = new SourceCacheContext(); var found = await packageMetadataResource.GetMetadataAsync(identity, content, logger, CancellationToken.None); //var settings = Settings.LoadDefaultSettings(project.ProjectConfig.RootPath, null, new MachineWideSettings()); var settings = Settings.LoadDefaultSettings(project.ProjectConfig.RootPath, null, null); var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers); var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, project.ProjectConfig.RootPath) { PackagesFolderNuGetProject = project }; const bool allowPrereleaseVersions = true; const bool allowUnlisted = false; var resolutionContext = new ResolutionContext( lowest ? DependencyBehavior.Lowest : DependencyBehavior.HighestMinor, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None); var projectContext = new ProjectContext(settings); var actions = await packageManager.PreviewInstallPackageAsync(packageManager.PackagesFolderNuGetProject, identity, resolutionContext, projectContext, sourceRepository, sourceRepositoryProvider.GetRepositories(), CancellationToken.None); project.NuGetProjectActions = actions; await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject, identity, resolutionContext, projectContext, sourceRepository, sourceRepositoryProvider.GetRepositories(), CancellationToken.None); NuGetPackageManager.ClearDirectInstall(projectContext); }
public async Task DoWithProject(string package, string version, ProjectBazelManipulator project, bool lowest) { var logger = new Logger(); var providers = new List <Lazy <INuGetResourceProvider> >(); providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support var packageSource = new PackageSource("https://api.nuget.org/v3/index.json"); var sourceRepository = new SourceRepository(packageSource, providers); var packageMetadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>(); var verParsed = NuGetVersion.Parse(version); var identity = new NuGet.Packaging.Core.PackageIdentity(package, verParsed); var content = new SourceCacheContext(); var found = await packageMetadataResource.GetMetadataAsync(identity, content, logger, CancellationToken.None); var settings = Settings.LoadDefaultSettings(project.ProjectConfig.RootPath, null, new MachineWideSettings()); var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers); var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, project.ProjectConfig.RootPath) { PackagesFolderNuGetProject = project }; const bool allowPrereleaseVersions = true; const bool allowUnlisted = false; var resolutionContext = new ResolutionContext( lowest ? DependencyBehavior.Lowest : DependencyBehavior.HighestMinor, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None); var projectContext = new ProjectContext(settings); var projects = new ProjectBazelManipulator[] { project }; var actions = await packageManager.PreviewUpdatePackagesAsync(identity, projects, resolutionContext, projectContext, new SourceRepository[] { sourceRepository }, Array.Empty <SourceRepository>(), // This is a list of secondary source respositories, probably empty CancellationToken.None); project.NuGetProjectActions = actions; var sourceCacheContext = new SourceCacheContext(); await packageManager.ExecuteNuGetProjectActionsAsync(project, actions, projectContext, sourceCacheContext, CancellationToken.None); NuGetPackageManager.ClearDirectInstall(projectContext); }
/// <summary> /// Execute the installs/uninstalls /// </summary> /// <param name="actions"></param> /// <param name="projectContext"></param> /// <param name="token"></param> /// <returns></returns> protected async Task ExecuteActions(IEnumerable <Tuple <NuGetProject, NuGetProjectAction> > actions, NuGetUIProjectContext projectContext, UserAction userAction, CancellationToken token) { HashSet <PackageIdentity> processedDirectInstalls = new HashSet <PackageIdentity>(PackageIdentity.Comparer); foreach (var projectActions in actions.GroupBy(e => e.Item1)) { var nuGetProjectActions = projectActions.Select(e => e.Item2); var directInstall = GetDirectInstall(nuGetProjectActions, userAction, projectContext.CommonOperations); if (directInstall != null && !processedDirectInstalls.Contains(directInstall)) { NuGetPackageManager.SetDirectInstall(directInstall, projectContext); processedDirectInstalls.Add(directInstall); } await _packageManager.ExecuteNuGetProjectActionsAsync(projectActions.Key, nuGetProjectActions, projectContext, token); NuGetPackageManager.ClearDirectInstall(projectContext); } }
private async Task ExecuteActionsAsync(IEnumerable <ResolvedAction> actions, PackageIdentity packageIdentity, INuGetProjectContext projectContext, SourceCacheContext sourceCacheContext, CancellationToken token) { NuGetProject[] nuGetProjects = actions.Select(action => action.Project).Distinct().ToArray(); IEnumerable <NuGetProjectAction> nuGetActions = actions.Select(action => action.Action); if (packageIdentity != null) { NuGetPackageManager.SetDirectInstall(packageIdentity, projectContext); } await _packageManager.ExecuteNuGetProjectActionsAsync(nuGetProjects, nuGetActions, projectContext, sourceCacheContext, token); NuGetPackageManager.ClearDirectInstall(projectContext); }
public async Task InstallPackageAsync(CancellationToken token) { using (var sourceCacheContext = new SourceCacheContext()) { var actions = await PreviewInstallPackage(sourceCacheContext, token); if (!actions.Any()) { return; } NuGetPackageManager.SetDirectInstall(identity, projectContext); await packageManager.ExecuteNuGetProjectActionsAsync( nugetProject, actions, projectContext, sourceCacheContext, token); NuGetPackageManager.ClearDirectInstall(projectContext); } }
public void ClearDirectInstall(INuGetProjectContext nuGetProjectContext) { NuGetPackageManager.ClearDirectInstall(nuGetProjectContext); }
/// <summary> /// Fetch, if not already downloaded, and install the package represented by /// (<paramref name="packageId"/>, <paramref name="version"/>). /// </summary> /// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks> /// <param name="packageId">Name of package to install.</param> /// <param name="version">Version of package to install.</param> public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, ProgressReport progress) { // Xenko 2.x still installs in GamePackages var currentManager = IsPackageV2(packageId, version) ? managerV2 : manager; using (GetLocalRepositoryLock()) { currentProgressReport = progress; try { var identity = new PackageIdentity(packageId, version.ToNuGetVersion()); var resolutionContext = new ResolutionContext( DependencyBehavior.Lowest, true, true, VersionConstraints.None); var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray(); var projectContext = new EmptyNuGetProjectContext() { ActionType = NuGetActionType.Install, PackageExtractionContext = new PackageExtractionContext(NativeLogger), }; ActivityCorrelationId.StartNew(); { // Equivalent to: // await manager.InstallPackageAsync(manager.PackagesFolderNuGetProject, // identity, resolutionContext, projectContext, repositories, // Array.Empty<SourceRepository>(), // This is a list of secondary source respositories, probably empty // CancellationToken.None); using (var sourceCacheContext = new SourceCacheContext()) { var nuGetProject = currentManager.PackagesFolderNuGetProject; var packageIdentity = identity; var nuGetProjectContext = projectContext; var primarySources = repositories; var secondarySources = Array.Empty <SourceRepository>(); var token = CancellationToken.None; var downloadContext = new PackageDownloadContext(sourceCacheContext); // Step-1 : Call PreviewInstallPackageAsync to get all the nuGetProjectActions var nuGetProjectActions = await currentManager.PreviewInstallPackageAsync(nuGetProject, packageIdentity, resolutionContext, nuGetProjectContext, primarySources, secondarySources, token); // Notify that installations started. foreach (var operation in nuGetProjectActions) { if (operation.NuGetProjectActionType == NuGetProjectActionType.Install) { var installPath = GetInstalledPath(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion()); OnPackageInstalling(this, new PackageOperationEventArgs(new PackageName(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion()), installPath)); } } NuGetPackageManager.SetDirectInstall(packageIdentity, nuGetProjectContext); // Step-2 : Execute all the nuGetProjectActions if (IsPackageV2(packageId, version)) { await currentManager.ExecuteNuGetProjectActionsAsync( nuGetProject, nuGetProjectActions, nuGetProjectContext, downloadContext, token); } else { // Download and install package in the global cache (can't use NuGetPackageManager anymore since it is designed for V2) foreach (var operation in nuGetProjectActions) { if (operation.NuGetProjectActionType == NuGetProjectActionType.Install) { using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(primarySources, packageIdentity, downloadContext, InstallPath, NativeLogger, token)) { if (downloadResult.Status != DownloadResourceResultStatus.Available) { throw new InvalidOperationException($"Could not download package {packageIdentity}"); } using (var installResult = await GlobalPackagesFolderUtility.AddPackageAsync(packageIdentity, downloadResult.PackageStream, InstallPath, NativeLogger, token)) { if (installResult.Status != DownloadResourceResultStatus.Available) { throw new InvalidOperationException($"Could not install package {packageIdentity}"); } } } } } } NuGetPackageManager.ClearDirectInstall(nuGetProjectContext); // Notify that installations completed. foreach (var operation in nuGetProjectActions) { if (operation.NuGetProjectActionType == NuGetProjectActionType.Install) { var installPath = GetInstalledPath(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion()); OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion()), installPath)); } } } } // Load the recently installed package var installedPackages = GetPackagesInstalled(new[] { packageId }); return(installedPackages.FirstOrDefault(p => p.Version == version)); } finally { currentProgressReport = null; } } }