/// <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> /// Execute the project actions /// </summary> /// <param name="actions"></param> /// <returns></returns> private async Task ExecuteActions(IEnumerable <NuGetProjectAction> actions, SourceCacheContext sourceCacheContext) { // stop telemetry event timer to avoid ui interaction TelemetryServiceUtility.StopTimer(); if (!ShouldContinueDueToDotnetDeprecation(actions, WhatIf.IsPresent)) { // resume telemetry event timer after ui interaction TelemetryServiceUtility.StartOrResumeTimer(); return; } // resume telemetry event timer after ui interaction TelemetryServiceUtility.StartOrResumeTimer(); if (WhatIf.IsPresent) { // For -WhatIf, only preview the actions PreviewNuGetPackageActions(actions); } else { // Execute project actions by Package Manager await PackageManager.ExecuteNuGetProjectActionsAsync(Projects, actions, this, sourceCacheContext, Token); // Refresh Manager UI if needed RefreshUI(actions); } }
protected override void ProcessRecordCore() { var startTime = DateTimeOffset.Now; // start timer for telemetry event TelemetryServiceUtility.StartOrResumeTimer(); // Run Preprocess outside of JTF Preprocess(); NuGetUIThreadHelper.JoinableTaskFactory.Run(async() => { await _lockService.ExecuteNuGetOperationAsync(() => { SubscribeToProgressEvents(); WarnIfParametersAreNotSupported(); if (!_readFromPackagesConfig && !_readFromDirectPackagePath && _nugetVersion == null) { Task.Run(InstallPackageByIdAsync); } else { var identities = GetPackageIdentities(); Task.Run(() => InstallPackagesAsync(identities)); } WaitAndLogPackageActions(); UnsubscribeFromProgressEvents(); return(Task.FromResult(true)); }, Token); }); // stop timer for telemetry event and create action telemetry event instance TelemetryServiceUtility.StopTimer(); var isPackageSourceMappingEnabled = PackageSourceMappingUtility.IsMappingEnabled(ConfigSettings); var actionTelemetryEvent = VSTelemetryServiceUtility.GetActionTelemetryEvent( OperationId.ToString(), new[] { Project }, NuGetOperationType.Install, OperationSource.PMC, startTime, _status, _packageCount, TelemetryServiceUtility.GetTimerElapsedTimeInSeconds(), isPackageSourceMappingEnabled: isPackageSourceMappingEnabled); // emit telemetry event along with granular level events TelemetryActivity.EmitTelemetryEvent(actionTelemetryEvent); }
protected override void ProcessRecordCore() { var startTime = DateTimeOffset.Now; // Set to log telemetry granular events for this update operation TelemetryService = new NuGetVSActionTelemetryService(); // start timer for telemetry event TelemetryServiceUtility.StartOrResumeTimer(); // Run Preprocess outside of JTF Preprocess(); NuGetUIThreadHelper.JoinableTaskFactory.Run(async() => { await _lockService.ExecuteNuGetOperationAsync(() => { SubscribeToProgressEvents(); WarnIfParametersAreNotSupported(); // Update-Package without ID specified if (!_idSpecified) { Task.Run(UpdateOrReinstallAllPackagesAsync); } // Update-Package with Id specified else { Task.Run(UpdateOrReinstallSinglePackageAsync); } WaitAndLogPackageActions(); UnsubscribeFromProgressEvents(); return(Task.FromResult(true)); }, Token); }); // stop timer for telemetry event and create action telemetry event instance TelemetryServiceUtility.StopTimer(); var actionTelemetryEvent = VSTelemetryServiceUtility.GetActionTelemetryEvent( new[] { Project }, NuGetOperationType.Update, OperationSource.PMC, startTime, _status, _packageCount, TelemetryServiceUtility.GetTimerElapsedTimeInSeconds()); // emit telemetry event along with granular level for update operation TelemetryService.EmitTelemetryEvent(actionTelemetryEvent); }
/// <summary> /// Warns the user about the fact that the dotnet TFM is deprecated. /// </summary> /// <returns>Returns true if the user wants to ignore the warning or if the warning does not apply.</returns> private bool ShouldContinueDueToDotnetDeprecation( INuGetUI uiService, IEnumerable <ResolvedAction> actions, CancellationToken token) { var projects = DotnetDeprecatedPrompt.GetAffectedProjects(actions); TelemetryServiceUtility.StopTimer(); if (projects.Any()) { return(uiService.WarnAboutDotnetDeprecation(projects)); } return(true); }
protected override void ProcessRecordCore() { var startTime = DateTimeOffset.Now; _packageCount = 1; // Enable granular level events for this uninstall operation TelemetryService = new NuGetVSActionTelemetryService(); TelemetryServiceUtility.StartOrResumeTimer(); // Run Preprocess outside of JTF Preprocess(); NuGetUIThreadHelper.JoinableTaskFactory.Run(async() => { await _lockService.ExecuteNuGetOperationAsync(() => { SubscribeToProgressEvents(); Task.Run(UninstallPackageAsync); WaitAndLogPackageActions(); UnsubscribeFromProgressEvents(); return(Task.FromResult(true)); }, Token); }); TelemetryServiceUtility.StopTimer(); var actionTelemetryEvent = VSTelemetryServiceUtility.GetActionTelemetryEvent( new[] { Project }, NuGetOperationType.Uninstall, OperationSource.PMC, startTime, _status, _packageCount, TelemetryServiceUtility.GetTimerElapsedTimeInSeconds()); // emit telemetry event with granular level events TelemetryService.EmitTelemetryEvent(actionTelemetryEvent); }
// Returns false if user doesn't accept license agreements. private async Task <bool> CheckLicenseAcceptanceAsync( INuGetUI uiService, IEnumerable <PreviewResult> results, CancellationToken token) { // find all the packages that might need a license acceptance var licenseCheck = new HashSet <PackageIdentity>(PackageIdentity.Comparer); foreach (var result in results) { foreach (var pkg in result.Added) { licenseCheck.Add(pkg); } foreach (var pkg in result.Updated) { licenseCheck.Add(pkg.New); } } var sources = _sourceProvider.GetRepositories().Where(e => e.PackageSource.IsEnabled); var licenseMetadata = await GetPackageMetadataAsync(sources, licenseCheck, token); TelemetryServiceUtility.StopTimer(); // show license agreement if (licenseMetadata.Any(e => e.RequireLicenseAcceptance)) { var licenseInfoItems = licenseMetadata .Where(p => p.RequireLicenseAcceptance) .Select(e => new PackageLicenseInfo(e.Identity.Id, e.LicenseUrl, e.Authors)); return(uiService.PromptForLicenseAcceptance(licenseInfoItems)); } return(true); }
/// <summary> /// The internal implementation to perform user action. /// </summary> /// <param name="resolveActionsAsync">A function that returns a task that resolves the user /// action into project actions.</param> /// <param name="executeActionsAsync">A function that returns a task that executes /// the project actions.</param> private async Task PerformActionImplAsync( INuGetUI uiService, Func <SourceCacheContext, Task <IReadOnlyList <ResolvedAction> > > resolveActionsAsync, Func <IReadOnlyList <ResolvedAction>, SourceCacheContext, Task> executeActionsAsync, NuGetOperationType operationType, CancellationToken token) { var status = NuGetOperationStatus.Succeeded; var startTime = DateTimeOffset.Now; var packageCount = 0; // Enable granular level telemetry events for nuget ui operation uiService.ProjectContext.OperationId = Guid.NewGuid(); await _lockService.ExecuteNuGetOperationAsync(async() => { try { uiService.BeginOperation(); var acceptedFormat = await CheckPackageManagementFormat(uiService, token); if (!acceptedFormat) { return; } TelemetryServiceUtility.StartOrResumeTimer(); using (var sourceCacheContext = new SourceCacheContext()) { var actions = await resolveActionsAsync(sourceCacheContext); var results = GetPreviewResults(actions); if (operationType == NuGetOperationType.Uninstall) { packageCount = results.SelectMany(result => result.Deleted). Select(package => package.Id).Distinct().Count(); } else { var addCount = results.SelectMany(result => result.Added). Select(package => package.Id).Distinct().Count(); var updateCount = results.SelectMany(result => result.Updated). Select(result => result.New.Id).Distinct().Count(); // update packages count packageCount = addCount + updateCount; if (updateCount > 0) { // set operation type to update when there are packages being updated operationType = NuGetOperationType.Update; } } TelemetryServiceUtility.StopTimer(); // Show the preview window. if (uiService.DisplayPreviewWindow) { var shouldContinue = uiService.PromptForPreviewAcceptance(results); if (!shouldContinue) { return; } } TelemetryServiceUtility.StartOrResumeTimer(); // Show the license acceptance window. var accepted = await CheckLicenseAcceptanceAsync(uiService, results, token); TelemetryServiceUtility.StartOrResumeTimer(); if (!accepted) { return; } // Warn about the fact that the "dotnet" TFM is deprecated. if (uiService.DisplayDeprecatedFrameworkWindow) { var shouldContinue = ShouldContinueDueToDotnetDeprecation(uiService, actions, token); TelemetryServiceUtility.StartOrResumeTimer(); if (!shouldContinue) { return; } } if (!token.IsCancellationRequested) { // execute the actions await executeActionsAsync(actions, sourceCacheContext); // fires ActionsExecuted event to update the UI uiService.OnActionsExecuted(actions); } } } catch (System.Net.Http.HttpRequestException ex) { status = NuGetOperationStatus.Failed; if (ex.InnerException != null) { uiService.ShowError(ex.InnerException); } else { uiService.ShowError(ex); } } catch (Exception ex) { status = NuGetOperationStatus.Failed; uiService.ShowError(ex); } finally { TelemetryServiceUtility.StopTimer(); var duration = TelemetryServiceUtility.GetTimerElapsedTime(); uiService.ProjectContext.Log(MessageLevel.Info, string.Format(CultureInfo.CurrentCulture, Resources.Operation_TotalTime, duration)); uiService.EndOperation(); var actionTelemetryEvent = VSTelemetryServiceUtility.GetActionTelemetryEvent( uiService.ProjectContext.OperationId.ToString(), uiService.Projects, operationType, OperationSource.UI, startTime, status, packageCount, duration.TotalSeconds); TelemetryActivity.EmitTelemetryEvent(actionTelemetryEvent); } }, token); }
private async Task PerformActionImplAsync( IServiceBroker serviceBroker, INuGetProjectManagerService projectManagerService, INuGetUI uiService, ResolveActionsAsync resolveActionsAsync, NuGetOperationType operationType, UserAction userAction, CancellationToken cancellationToken) { var status = NuGetOperationStatus.Succeeded; var startTime = DateTimeOffset.Now; var packageCount = 0; var continueAfterPreview = true; var acceptedLicense = true; List <string> removedPackages = null; var existingPackages = new HashSet <Tuple <string, string> >(); List <Tuple <string, string> > addedPackages = null; List <Tuple <string, string> > updatedPackagesOld = null; List <Tuple <string, string> > updatedPackagesNew = null; // Enable granular level telemetry events for nuget ui operation uiService.ProjectContext.OperationId = Guid.NewGuid(); Stopwatch packageEnumerationTime = new Stopwatch(); packageEnumerationTime.Start(); try { // collect the install state of the existing packages foreach (IProjectContextInfo project in uiService.Projects) { IEnumerable <IPackageReferenceContextInfo> installedPackages = await project.GetInstalledPackagesAsync( uiService.UIContext.ServiceBroker, cancellationToken); foreach (IPackageReferenceContextInfo package in installedPackages) { Tuple <string, string> packageInfo = new Tuple <string, string>( package.Identity.Id, (package.Identity.Version == null ? "" : package.Identity.Version.ToNormalizedString())); if (!existingPackages.Contains(packageInfo)) { existingPackages.Add(packageInfo); } } } } catch (Exception) { // don't teardown the process if we have a telemetry failure } packageEnumerationTime.Stop(); await _lockService.ExecuteNuGetOperationAsync(async() => { try { uiService.BeginOperation(); using (INuGetProjectUpgraderService projectUpgrader = await serviceBroker.GetProxyAsync <INuGetProjectUpgraderService>( NuGetServices.ProjectUpgraderService, cancellationToken)) { bool isAcceptedFormat = await CheckPackageManagementFormatAsync(projectUpgrader, uiService, cancellationToken); if (!isAcceptedFormat) { return; } } TelemetryServiceUtility.StartOrResumeTimer(); IReadOnlyList <ProjectAction> actions = await resolveActionsAsync(projectManagerService); IReadOnlyList <PreviewResult> results = await GetPreviewResultsAsync(projectManagerService, actions, cancellationToken); if (operationType == NuGetOperationType.Uninstall) { // removed packages don't have version info removedPackages = results.SelectMany(result => result.Deleted) .Select(package => package.Id) .Distinct() .ToList(); packageCount = removedPackages.Count; } else { // log rich info about added packages addedPackages = results.SelectMany(result => result.Added) .Select(package => new Tuple <string, string>(package.Id, (package.Version == null ? "" : package.Version.ToNormalizedString()))) .Distinct() .ToList(); var addCount = addedPackages.Count; //updated packages can have an old and a new id. updatedPackagesOld = results.SelectMany(result => result.Updated) .Select(package => new Tuple <string, string>(package.Old.Id, (package.Old.Version == null ? "" : package.Old.Version.ToNormalizedString()))) .Distinct() .ToList(); updatedPackagesNew = results.SelectMany(result => result.Updated) .Select(package => new Tuple <string, string>(package.New.Id, (package.New.Version == null ? "" : package.New.Version.ToNormalizedString()))) .Distinct() .ToList(); var updateCount = updatedPackagesNew.Count; // update packages count packageCount = addCount + updateCount; if (updateCount > 0) { // set operation type to update when there are packages being updated operationType = NuGetOperationType.Update; } } TelemetryServiceUtility.StopTimer(); // Show the preview window. if (uiService.DisplayPreviewWindow) { bool shouldContinue = uiService.PromptForPreviewAcceptance(results); if (!shouldContinue) { continueAfterPreview = false; return; } } TelemetryServiceUtility.StartOrResumeTimer(); // Show the license acceptance window. bool accepted = await CheckLicenseAcceptanceAsync(uiService, results, cancellationToken); TelemetryServiceUtility.StartOrResumeTimer(); if (!accepted) { acceptedLicense = false; return; } // Warn about the fact that the "dotnet" TFM is deprecated. if (uiService.DisplayDeprecatedFrameworkWindow) { bool shouldContinue = await ShouldContinueDueToDotnetDeprecationAsync(projectManagerService, uiService, cancellationToken); TelemetryServiceUtility.StartOrResumeTimer(); if (!shouldContinue) { return; } } if (!cancellationToken.IsCancellationRequested) { await projectManagerService.ExecuteActionsAsync( actions, cancellationToken); string[] projectIds = actions .Select(action => action.ProjectId) .Distinct() .ToArray(); uiService.UIContext.RaiseProjectActionsExecuted(projectIds); } else { status = NuGetOperationStatus.Cancelled; } } catch (System.Net.Http.HttpRequestException ex) { status = NuGetOperationStatus.Failed; if (ex.InnerException != null) { uiService.ShowError(ex.InnerException); } else { uiService.ShowError(ex); } } catch (Exception ex) { status = NuGetOperationStatus.Failed; uiService.ShowError(ex); } finally { TelemetryServiceUtility.StopTimer(); var duration = TelemetryServiceUtility.GetTimerElapsedTime(); uiService.ProjectContext.Log(MessageLevel.Info, string.Format(CultureInfo.CurrentCulture, Resources.Operation_TotalTime, duration)); uiService.EndOperation(); // don't show "Succeeded" if we actually cancelled... if ((!continueAfterPreview) || (!acceptedLicense)) { if (status == NuGetOperationStatus.Succeeded) { status = NuGetOperationStatus.Cancelled; } } var plc = new PackageLoadContext(isSolution: false, uiService.UIContext); IReadOnlyCollection <string> frameworks = await plc.GetSupportedFrameworksAsync(); string[] projectIds = (await ProjectUtility.GetSortedProjectIdsAsync( uiService.UIContext.ServiceBroker, uiService.Projects, cancellationToken)).ToArray(); var packageSourceMapping = PackageSourceMapping.GetPackageSourceMapping(uiService.Settings); bool isPackageSourceMappingEnabled = packageSourceMapping?.IsEnabled ?? false; var actionTelemetryEvent = new VSActionsTelemetryEvent( uiService.ProjectContext.OperationId.ToString(), projectIds, operationType, OperationSource.UI, startTime, status, packageCount, DateTimeOffset.Now, duration.TotalSeconds, isPackageSourceMappingEnabled: isPackageSourceMappingEnabled); var nuGetUI = uiService as NuGetUI; AddUiActionEngineTelemetryProperties( actionTelemetryEvent, continueAfterPreview, acceptedLicense, userAction, nuGetUI?.SelectedIndex, nuGetUI?.RecommendedCount, nuGetUI?.RecommendPackages, nuGetUI?.RecommenderVersion, nuGetUI?.TopLevelVulnerablePackagesCount ?? 0, nuGetUI?.TopLevelVulnerablePackagesMaxSeverities?.ToList() ?? new List <int>(), existingPackages, addedPackages, removedPackages, updatedPackagesOld, updatedPackagesNew, frameworks); actionTelemetryEvent["InstalledPackageEnumerationTimeInMilliseconds"] = packageEnumerationTime.ElapsedMilliseconds; TelemetryActivity.EmitTelemetryEvent(actionTelemetryEvent); } }, cancellationToken); }
/// <summary> /// The internal implementation to perform user action. /// </summary> /// <param name="resolveActionsAsync">A function that returns a task that resolves the user /// action into project actions.</param> /// <param name="executeActionsAsync">A function that returns a task that executes /// the project actions.</param> private async Task PerformActionImplAsync( INuGetUI uiService, Func <SourceCacheContext, Task <IReadOnlyList <ResolvedAction> > > resolveActionsAsync, Func <IReadOnlyList <ResolvedAction>, SourceCacheContext, Task> executeActionsAsync, NuGetOperationType operationType, UserAction userAction, CancellationToken token) { var status = NuGetOperationStatus.Succeeded; var startTime = DateTimeOffset.Now; var packageCount = 0; bool continueAfterPreview = true; bool acceptedLicense = true; List <string> removedPackages = null; HashSet <Tuple <string, string> > existingPackages = new HashSet <Tuple <string, string> >(); List <Tuple <string, string> > addedPackages = null; List <Tuple <string, string> > updatedPackagesOld = null; List <Tuple <string, string> > updatedPackagesNew = null; // Enable granular level telemetry events for nuget ui operation uiService.ProjectContext.OperationId = Guid.NewGuid(); Stopwatch packageEnumerationTime = new Stopwatch(); packageEnumerationTime.Start(); try { // collect the install state of the existing packages foreach (var project in uiService.Projects) { var result = await project.GetInstalledPackagesAsync(token); foreach (var package in result) { Tuple <string, string> packageInfo = new Tuple <string, string>(package.PackageIdentity.Id, (package.PackageIdentity.Version == null ? "" : package.PackageIdentity.Version.ToNormalizedString())); if (!existingPackages.Contains(packageInfo)) { existingPackages.Add(packageInfo); } } } } catch (Exception) { // don't teardown the process if we have a telemetry failure } packageEnumerationTime.Stop(); await _lockService.ExecuteNuGetOperationAsync(async() => { try { uiService.BeginOperation(); var acceptedFormat = await CheckPackageManagementFormat(uiService, token); if (!acceptedFormat) { return; } TelemetryServiceUtility.StartOrResumeTimer(); using (var sourceCacheContext = new SourceCacheContext()) { var actions = await resolveActionsAsync(sourceCacheContext); var results = GetPreviewResults(actions); if (operationType == NuGetOperationType.Uninstall) { // removed packages don't have version info removedPackages = results.SelectMany(result => result.Deleted) .Select(package => package.Id) .Distinct() .ToList(); packageCount = removedPackages.Count; } else { // log rich info about added packages addedPackages = results.SelectMany(result => result.Added) .Select(package => new Tuple <string, string>(package.Id, (package.Version == null ? "" : package.Version.ToNormalizedString()))) .Distinct() .ToList(); var addCount = addedPackages.Count; //updated packages can have an old and a new id. updatedPackagesOld = results.SelectMany(result => result.Updated) .Select(package => new Tuple <string, string>(package.Old.Id, (package.Old.Version == null ? "" : package.Old.Version.ToNormalizedString()))) .Distinct() .ToList(); updatedPackagesNew = results.SelectMany(result => result.Updated) .Select(package => new Tuple <string, string>(package.New.Id, (package.New.Version == null ? "" : package.New.Version.ToNormalizedString()))) .Distinct() .ToList(); var updateCount = updatedPackagesNew.Count; // update packages count packageCount = addCount + updateCount; if (updateCount > 0) { // set operation type to update when there are packages being updated operationType = NuGetOperationType.Update; } } TelemetryServiceUtility.StopTimer(); // Show the preview window. if (uiService.DisplayPreviewWindow) { var shouldContinue = uiService.PromptForPreviewAcceptance(results); if (!shouldContinue) { continueAfterPreview = false; return; } } TelemetryServiceUtility.StartOrResumeTimer(); // Show the license acceptance window. var accepted = await CheckLicenseAcceptanceAsync(uiService, results, token); TelemetryServiceUtility.StartOrResumeTimer(); if (!accepted) { acceptedLicense = false; return; } // Warn about the fact that the "dotnet" TFM is deprecated. if (uiService.DisplayDeprecatedFrameworkWindow) { var shouldContinue = ShouldContinueDueToDotnetDeprecation(uiService, actions, token); TelemetryServiceUtility.StartOrResumeTimer(); if (!shouldContinue) { return; } } if (!token.IsCancellationRequested) { // execute the actions await executeActionsAsync(actions, sourceCacheContext); // fires ActionsExecuted event to update the UI uiService.OnActionsExecuted(actions); } else { status = NuGetOperationStatus.Cancelled; } } } catch (System.Net.Http.HttpRequestException ex) { status = NuGetOperationStatus.Failed; if (ex.InnerException != null) { uiService.ShowError(ex.InnerException); } else { uiService.ShowError(ex); } } catch (Exception ex) { status = NuGetOperationStatus.Failed; uiService.ShowError(ex); } finally { TelemetryServiceUtility.StopTimer(); var duration = TelemetryServiceUtility.GetTimerElapsedTime(); uiService.ProjectContext.Log(MessageLevel.Info, string.Format(CultureInfo.CurrentCulture, Resources.Operation_TotalTime, duration)); uiService.EndOperation(); // don't show "Succeeded" if we actually cancelled... if ((!continueAfterPreview) || (!acceptedLicense)) { if (status == NuGetOperationStatus.Succeeded) { status = NuGetOperationStatus.Cancelled; } } var actionTelemetryEvent = VSTelemetryServiceUtility.GetActionTelemetryEvent( uiService.ProjectContext.OperationId.ToString(), uiService.Projects, operationType, OperationSource.UI, startTime, status, packageCount, duration.TotalSeconds); AddUiActionEngineTelemetryProperties(actionTelemetryEvent, continueAfterPreview, acceptedLicense, userAction, existingPackages, addedPackages, removedPackages, updatedPackagesOld, updatedPackagesNew); actionTelemetryEvent["InstalledPackageEnumerationTimeInMilliseconds"] = packageEnumerationTime.ElapsedMilliseconds; TelemetryActivity.EmitTelemetryEvent(actionTelemetryEvent); } }, token); }
private async Task RestoreAsync(bool forceRestore, RestoreOperationSource restoreSource, CancellationToken token) { var startTime = DateTimeOffset.Now; _status = NuGetOperationStatus.NoOp; // start timer for telemetry event TelemetryServiceUtility.StartOrResumeTimer(); var telemetryService = new NuGetVSActionTelemetryService(); var projects = Enumerable.Empty <NuGetProject>(); _packageRestoreManager.PackageRestoredEvent += PackageRestoreManager_PackageRestored; _packageRestoreManager.PackageRestoreFailedEvent += PackageRestoreManager_PackageRestoreFailedEvent; try { var solutionDirectory = _solutionManager.SolutionDirectory; var isSolutionAvailable = await _solutionManager.IsSolutionAvailableAsync(); if (solutionDirectory == null) { await _logger.DoAsync((l, _) => { _status = NuGetOperationStatus.Failed; l.ShowError(Resources.SolutionIsNotSaved); l.WriteLine(VerbosityLevel.Minimal, Resources.SolutionIsNotSaved); }); return; } // Get the projects from the SolutionManager // Note that projects that are not supported by NuGet, will not show up in this list projects = await _solutionManager.GetNuGetProjectsAsync(); // Check if there are any projects that are not INuGetIntegratedProject, that is, // projects with packages.config. OR // any of the deferred project is type of packages.config, If so, perform package restore on them if (projects.Any(project => !(project is INuGetIntegratedProject))) { await RestorePackagesOrCheckForMissingPackagesAsync( solutionDirectory, isSolutionAvailable, restoreSource, token); } var dependencyGraphProjects = projects .OfType <IDependencyGraphProject>() .ToList(); await RestorePackageSpecProjectsAsync( dependencyGraphProjects, forceRestore, isSolutionAvailable, restoreSource, token); #if !VS14 // TODO: To limit risk, we only publish the event when there is a cross-platform PackageReference // project in the solution. Extending this behavior to all solutions is tracked here: // NuGet/Home#4478 if (projects.OfType <NetCorePackageReferenceProject>().Any()) { _restoreEventsPublisher.OnSolutionRestoreCompleted( new SolutionRestoredEventArgs(_status, solutionDirectory)); } #endif } finally { _packageRestoreManager.PackageRestoredEvent -= PackageRestoreManager_PackageRestored; _packageRestoreManager.PackageRestoreFailedEvent -= PackageRestoreManager_PackageRestoreFailedEvent; TelemetryServiceUtility.StopTimer(); var duration = TelemetryServiceUtility.GetTimerElapsedTime(); // Do not log any restore message if user disabled restore. if (_packageRestoreConsent.IsGranted) { await _logger.WriteSummaryAsync(_status, duration); } else { _logger.LogDebug(Resources.PackageRefNotRestoredBecauseOfNoConsent); } // Emit telemetry event for restore operation EmitRestoreTelemetryEvent( projects, new NuGetVSActionTelemetryService(), restoreSource, startTime, duration.TotalSeconds); } }