public RestoreTelemetryEvent(
string operationId,
string[] projectIds,
bool forceRestore,
RestoreOperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
int noOpProjectsCount,
int upToDateProjectsCount,
DateTimeOffset endTime,
double duration,
bool isSolutionLoadRestore,
IntervalTracker intervalTimingTracker) : base(RestoreActionEventName, operationId, projectIds, startTime, status, packageCount, endTime, duration)
{
base[nameof(OperationSource)] = source;
base[nameof(NoOpProjectsCount)] = noOpProjectsCount;
base[nameof(UpToDateProjectCount)] = upToDateProjectsCount;
base[nameof(ForceRestore)] = forceRestore;
base[nameof(IsSolutionLoadRestore)] = isSolutionLoadRestore;
foreach (var(intervalName, intervalDuration) in intervalTimingTracker.GetIntervals())
{
base[intervalName] = intervalDuration;
}
}
public ActionEventBase(
string eventName,
string operationId,
string[] projectIds,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
DateTimeOffset endTime,
double duration) :
base(eventName, new Dictionary <string, object>
{
{ nameof(OperationId), operationId },
{ nameof(PackagesCount), packageCount },
{ nameof(Status), status },
{ nameof(StartTime), startTime.UtcDateTime.ToString("O") },
{ nameof(EndTime), endTime.UtcDateTime.ToString("O") },
{ nameof(Duration), duration },
{ nameof(ProjectsCount), projectIds.Length }
})
{
ProjectIds = projectIds;
// log each project id separately so that it can be joined with ProjectInformation telemetry event
for (var i = 0; i < projectIds.Length; i++)
{
this[$"ProjectId{i + 1}"] = projectIds[i];
}
}
/// <summary>
/// Create ActionTelemetryEvent instance.
/// </summary>
/// <param name="projects"></param>
/// <param name="operationType"></param>
/// <param name="source"></param>
/// <param name="startTime"></param>
/// <param name="status"></param>
/// <param name="statusMessage"></param>
/// <param name="packageCount"></param>
/// <param name="endTime"></param>
/// <param name="duration"></param>
/// <returns></returns>
public static VSActionsTelemetryEvent GetActionTelemetryEvent(
string operationId,
IEnumerable <NuGetProject> projects,
NuGetOperationType operationType,
OperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
double duration)
{
var sortedProjects = projects.OrderBy(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName));
var projectIds = sortedProjects.Select(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId)).ToArray();
return(new VSActionsTelemetryEvent(
operationId,
projectIds,
operationType,
source,
startTime,
status,
packageCount,
DateTimeOffset.Now,
duration));
}
public PackageSigningTelemetryEvent(PackageSignType packageSignType, NuGetOperationStatus status) :
base(EventName, new Dictionary <string, object>
{
{ nameof(Status), status },
{ nameof(PackageSignType), packageSignType }
})
{
}
public SolutionRestoredEventArgs(
NuGetOperationStatus restoreStatus,
string solutionDirectory)
{
Assumes.NotNullOrEmpty(solutionDirectory);
RestoreStatus = restoreStatus;
SolutionDirectory = solutionDirectory;
}
public RestoreTelemetryEvent(
string operationId,
string[] projectIds,
bool forceRestore,
RestoreOperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
int noOpProjectsCount,
int upToDateProjectsCount,
int unknownProjectsCount,
int projectJsonProjectsCount,
int packageReferenceProjectsCount,
int legacyPackageReferenceProjectsCount,
int cpsPackageReferenceProjectsCount,
int dotnetCliToolProjectsCount,
int packagesConfigProjectsCount,
DateTimeOffset endTime,
double duration,
IDictionary <string, object> additionalTrackingData,
IntervalTracker intervalTimingTracker,
bool isPackageSourceMappingEnabled,
int httpFeedsCount,
int localFeedsCount,
bool hasNuGetOrg,
bool hasVSOfflineFeed
) : base(RestoreActionEventName, operationId, projectIds, startTime, status, packageCount, endTime, duration)
{
base[nameof(OperationSource)] = source;
base[nameof(NoOpProjectsCount)] = noOpProjectsCount;
base[nameof(UpToDateProjectCount)] = upToDateProjectsCount;
base[nameof(UnknownProjectsCount)] = unknownProjectsCount;
base[nameof(ProjectJsonProjectsCount)] = projectJsonProjectsCount;
base[nameof(PackageReferenceProjectsCount)] = packageReferenceProjectsCount;
base[nameof(LegacyPackageReferenceProjectsCount)] = legacyPackageReferenceProjectsCount;
base[nameof(CpsPackageReferenceProjectsCount)] = cpsPackageReferenceProjectsCount;
base[nameof(DotnetCliToolProjectsCount)] = dotnetCliToolProjectsCount;
base[nameof(PackagesConfigProjectsCount)] = packagesConfigProjectsCount;
base[nameof(ForceRestore)] = forceRestore;
base[PackageSourceMappingIsMappingEnabled] = isPackageSourceMappingEnabled;
base[NumHTTPFeeds] = httpFeedsCount;
base[NumLocalFeeds] = localFeedsCount;
base[NuGetOrg] = hasNuGetOrg;
base[VsOfflinePackages] = hasVSOfflineFeed;
foreach (KeyValuePair <string, object> data in additionalTrackingData)
{
base[data.Key] = data.Value;
}
foreach (var(intervalName, intervalDuration) in intervalTimingTracker.GetIntervals())
{
base[intervalName] = intervalDuration;
}
}
public async Task WriteSummaryAsync(NuGetOperationStatus operationStatus, TimeSpan duration)
{
var forceStatusWrite = _operationSource == RestoreOperationSource.Explicit;
var quietOrMinimal = forceStatusWrite ? MSBuildVerbosityLevel.Quiet : MSBuildVerbosityLevel.Minimal;
var quietOrNormal = forceStatusWrite ? MSBuildVerbosityLevel.Quiet : MSBuildVerbosityLevel.Normal;
var quietOrDetailed = forceStatusWrite ? MSBuildVerbosityLevel.Quiet : MSBuildVerbosityLevel.Detailed;
switch (operationStatus)
{
case NuGetOperationStatus.Cancelled:
await WriteLineAsync(
quietOrMinimal,
Resources.PackageRestoreCanceled);
break;
case NuGetOperationStatus.NoOp:
if (forceStatusWrite)
{
await WriteLineAsync(
quietOrDetailed,
Resources.NothingToRestore);
}
break;
case NuGetOperationStatus.Failed:
await WriteLineAsync(
quietOrMinimal,
Resources.PackageRestoreFinishedWithError);
break;
case NuGetOperationStatus.Succeeded:
await WriteLineAsync(
quietOrNormal,
Resources.PackageRestoreFinished);
break;
}
if (_operationSource != RestoreOperationSource.OnBuild && (_hasHeaderBeenShown || forceStatusWrite))
{
// Submit all messages at once. Avoid needless thread switching
var fullMessage =
string.Format(CultureInfo.CurrentCulture, Resources.Operation_TotalTime, duration) +
Environment.NewLine +
Resources.Operation_Finished +
Environment.NewLine +
string.Empty +
Environment.NewLine;
await WriteLineAsync(quietOrMinimal, fullMessage);
}
}
public ActionsTelemetryEvent(
string[] projectIds,
NuGetOperationType operationType,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
DateTimeOffset endTime,
double duration) : base(NugetActionEventName, projectIds, startTime, status, packageCount, endTime, duration)
{
base[nameof(OperationType)] = operationType;
}
internal void SetResult(IEnumerable <NuGetProject> projects, NuGetOperationStatus status, int packageCount)
{
var sortedProjects = projects.OrderBy(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName));
var projectIds = sortedProjects.Select(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId));
base["ProjectIds"] = string.Join(",", projectIds);
base["Status"] = status;
base["PackageCount"] = packageCount;
}
public RestoreTelemetryEvent(
string operationId,
string[] projectIds,
RestoreOperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
DateTimeOffset endTime,
double duration) : base(operationId, projectIds, startTime, status, packageCount, endTime, duration)
{
Source = source;
}
private void PackageRestoreManager_PackageRestoreFailedEvent(
object sender,
PackageRestoreFailedEventArgs args)
{
if (_status == NuGetOperationStatus.Cancelled)
{
// If an operation is canceled, a single message gets shown in the summary
// that package restore has been canceled
// Do not report it as separate errors
return;
}
if (args.Exception is SignatureException ex)
{
_status = NuGetOperationStatus.Failed;
if (!string.IsNullOrEmpty(ex.Message))
{
_logger.Log(ex.AsLogMessage());
}
if (ex.Results != null)
{
ex.Results.SelectMany(p => p.Issues).ToList().ForEach(p => _logger.Log(p));
}
return;
}
if (args.ProjectNames.Any())
{
_status = NuGetOperationStatus.Failed;
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
foreach (var projectName in args.ProjectNames)
{
var exceptionMessage =
_logger.OutputVerbosity >= (int)VerbosityLevel.Detailed
? args.Exception.ToString()
: args.Exception.Message;
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.PackageRestoreFailedForProject,
projectName,
exceptionMessage);
await _logger.WriteLineAsync(VerbosityLevel.Quiet, message);
await _logger.ShowErrorAsync(message);
await _logger.WriteLineAsync(VerbosityLevel.Normal, Resources.PackageRestoreFinishedForProject, projectName);
}
});
}
}
public VSActionsTelemetryEvent(
string[] projectIds,
NuGetOperationType operationType,
OperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
DateTimeOffset endTime,
double duration) :
base(projectIds, operationType, startTime, status, packageCount, endTime, duration)
{
base[nameof(Source)] = source;
}
public RestoreTelemetryEvent(
string[] projectIds,
RestoreOperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
int noOpProjectsCount,
DateTimeOffset endTime,
double duration) : base(RestoreActionEventName, projectIds, startTime, status, packageCount, endTime, duration)
{
base[nameof(OperationSource)] = source;
base[(nameof(NoOpProjectsCount))] = noOpProjectsCount;
}
/// <summary>
/// Restore job entry point. Not re-entrant.
/// </summary>
public async Task <bool> ExecuteAsync(
SolutionRestoreRequest request,
SolutionRestoreJobContext jobContext,
RestoreOperationLogger logger,
CancellationToken token)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (jobContext == null)
{
throw new ArgumentNullException(nameof(jobContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
// update instance attributes with the shared context values
_dependencyGraphProjectCacheHash = jobContext.DependencyGraphProjectCacheHash;
_nuGetProjectContext = jobContext.NuGetProjectContext;
using (var ctr1 = token.Register(() => _status = NuGetOperationStatus.Cancelled))
{
try
{
await RestoreAsync(request.ForceRestore, request.RestoreSource, token);
}
catch (OperationCanceledException) when(token.IsCancellationRequested)
{
}
catch (Exception e)
{
// Log the exception to the console and activity log
await _logger.LogExceptionAsync(e);
}
finally
{
// update shared context values with instance attributes
jobContext.DependencyGraphProjectCacheHash = _dependencyGraphProjectCacheHash;
}
}
return(_status == NuGetOperationStatus.NoOp || _status == NuGetOperationStatus.Succeeded);
}
public PackageExtractionTelemetryEvent(
PackageSaveMode packageSaveMode,
NuGetOperationStatus status,
ExtractionSource extractionSource,
PackageIdentity packageId) :
base(EventName, new Dictionary <string, object>
{
{ nameof(Status), status },
{ nameof(ExtractionSource), extractionSource },
{ nameof(PackageSaveMode), packageSaveMode }
})
{
AddPiiData(nameof(PackageId), packageId.ToString());
}
public Task WriteSummaryAsync(NuGetOperationStatus operationStatus, TimeSpan duration)
{
var forceStatusWrite = _operationSource == RestoreOperationSource.Explicit;
var quietOrMinimal = forceStatusWrite ? VerbosityLevel.Quiet : VerbosityLevel.Minimal;
var quietOrNormal = forceStatusWrite ? VerbosityLevel.Quiet : VerbosityLevel.Normal;
var quietOrDetailed = forceStatusWrite ? VerbosityLevel.Quiet : VerbosityLevel.Detailed;
return(DoAsync((_, __) =>
{
switch (operationStatus)
{
case NuGetOperationStatus.Cancelled:
WriteLine(
quietOrMinimal,
Resources.PackageRestoreCanceled);
break;
case NuGetOperationStatus.NoOp:
if (forceStatusWrite)
{
WriteLine(
quietOrDetailed,
Resources.NothingToRestore);
}
break;
case NuGetOperationStatus.Failed:
WriteLine(
quietOrMinimal,
Resources.PackageRestoreFinishedWithError);
break;
case NuGetOperationStatus.Succeeded:
WriteLine(
quietOrNormal,
Resources.PackageRestoreFinished);
break;
}
if (_operationSource != RestoreOperationSource.OnBuild && (_hasHeaderBeenShown || forceStatusWrite))
{
WriteLine(
quietOrMinimal,
Resources.Operation_TotalTime,
duration);
WriteLine(quietOrMinimal, Resources.Operation_Finished);
WriteLine(quietOrMinimal, string.Empty);
}
}));
}
public ActionsTelemetryEvent(
string operationId,
string[] projectIds,
NuGetOperationType operationType,
OperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
DateTimeOffset endTime,
double duration) : base(operationId, projectIds, startTime, status, packageCount, endTime, duration)
{
OperationType = operationType;
Source = source;
}
public VSActionsTelemetryEvent(
string operationId,
string[] projectIds,
NuGetOperationType operationType,
OperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
DateTimeOffset endTime,
double duration,
bool isPackageSourceMappingEnabled) :
base(operationId, projectIds, operationType, startTime, status, packageCount, endTime, duration)
{
base[nameof(Source)] = source;
base[PackageSourceMappingIsMappingEnabled] = isPackageSourceMappingEnabled;
}
private void PackageRestoreManager_PackageRestoreFailedEvent(
object sender,
PackageRestoreFailedEventArgs args)
{
if (_status == NuGetOperationStatus.Cancelled)
{
// If an operation is canceled, a single message gets shown in the summary
// that package restore has been canceled
// Do not report it as separate errors
return;
}
if (args.Exception is SignatureException)
{
_status = NuGetOperationStatus.Failed;
var ex = args.Exception as SignatureException;
ex.Results.SelectMany(p => p.Issues).ToList().ForEach(p => _logger.Log(p.ToLogMessage()));
return;
}
if (args.ProjectNames.Any())
{
_status = NuGetOperationStatus.Failed;
_logger.Do((l, _) =>
{
foreach (var projectName in args.ProjectNames)
{
var exceptionMessage =
l.OutputVerbosity >= (int)VerbosityLevel.Detailed
? args.Exception.ToString()
: args.Exception.Message;
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.PackageRestoreFailedForProject,
projectName,
exceptionMessage);
l.WriteLine(VerbosityLevel.Quiet, message);
l.ShowError(message);
l.WriteLine(VerbosityLevel.Normal, Resources.PackageRestoreFinishedForProject, projectName);
}
});
}
}
public ActionEventBase(
string operationId,
string[] projectIds,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
DateTimeOffset endTime,
double duration)
{
OperationId = operationId;
ProjectIds = projectIds;
PackagesCount = packageCount;
Status = status;
StartTime = startTime;
EndTime = endTime;
Duration = duration;
}
public PackageExtractionTelemetryEvent(
PackageSaveMode packageSaveMode,
NuGetOperationStatus status,
ExtractionSource extractionSource,
PackageIdentity packageId = null) :
base(EventName, new Dictionary <string, object>
{
{ nameof(Status), status },
{ nameof(ExtractionSource), extractionSource },
{ nameof(PackageSaveMode), packageSaveMode }
})
{
if (packageId != null)
{
LogPackageIdentity(packageId);
}
}
public ActionEventBase(
string eventName,
string[] projectIds,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
DateTimeOffset endTime,
double duration) :
base(eventName, new Dictionary <string, object>
{
{ nameof(ProjectIds), string.Join(",", projectIds) },
{ nameof(PackagesCount), packageCount },
{ nameof(Status), status },
{ nameof(StartTime), startTime.ToString() },
{ nameof(EndTime), endTime.ToString() },
{ nameof(Duration), duration },
{ nameof(ProjectsCount), projectIds.Length }
})
{
}
public static TelemetryEvent GetUpgradeTelemetryEvent(
IEnumerable <NuGetProject> projects,
NuGetOperationStatus status,
int packageCount)
{
var eventName = "UpgradeInformation";
var sortedProjects = projects.OrderBy(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName));
var projectIds = sortedProjects.Select(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId)).ToArray();
var telemetryEvent = new TelemetryEvent(eventName);
telemetryEvent["ProjectIds"] = string.Join(",", projectIds);
telemetryEvent["Status"] = status;
telemetryEvent["PackageCount"] = packageCount;
return(telemetryEvent);
}
public RestoreTelemetryEvent(
string operationId,
string[] projectIds,
bool forceRestore,
RestoreOperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
int noOpProjectsCount,
int upToDateProjectsCount,
int unknownProjectsCount,
int projectJsonProjectsCount,
int packageReferenceProjectsCount,
int legacyPackageReferenceProjectsCount,
int cpsPackageReferenceProjectsCount,
int dotnetCliToolProjectsCount,
int packagesConfigProjectsCount,
DateTimeOffset endTime,
double duration,
bool isSolutionLoadRestore,
IntervalTracker intervalTimingTracker) : base(RestoreActionEventName, operationId, projectIds, startTime, status, packageCount, endTime, duration)
{
base[nameof(OperationSource)] = source;
base[nameof(NoOpProjectsCount)] = noOpProjectsCount;
base[nameof(UpToDateProjectCount)] = upToDateProjectsCount;
base[nameof(UnknownProjectsCount)] = unknownProjectsCount;
base[nameof(ProjectJsonProjectsCount)] = projectJsonProjectsCount;
base[nameof(PackageReferenceProjectsCount)] = packageReferenceProjectsCount;
base[nameof(LegacyPackageReferenceProjectsCount)] = legacyPackageReferenceProjectsCount;
base[nameof(CpsPackageReferenceProjectsCount)] = cpsPackageReferenceProjectsCount;
base[nameof(DotnetCliToolProjectsCount)] = dotnetCliToolProjectsCount;
base[nameof(PackagesConfigProjectsCount)] = packagesConfigProjectsCount;
base[nameof(ForceRestore)] = forceRestore;
base[nameof(IsSolutionLoadRestore)] = isSolutionLoadRestore;
foreach (var(intervalName, intervalDuration) in intervalTimingTracker.GetIntervals())
{
base[intervalName] = intervalDuration;
}
}
private static void EmitRestoreTelemetryEvent(IEnumerable <NuGetProject> projects,
RestoreOperationSource source,
DateTimeOffset startTime,
NuGetOperationStatus status,
int packageCount,
double duration)
{
var sortedProjects = projects.OrderBy(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName));
var projectIds = sortedProjects.Select(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId)).ToArray();
var restoreTelemetryEvent = new RestoreTelemetryEvent(
Guid.NewGuid().ToString(),
projectIds,
source,
startTime,
status,
packageCount,
DateTimeOffset.Now,
duration);
RestoreTelemetryService.Instance.EmitRestoreEvent(restoreTelemetryEvent);
}
private async Task RestorePackagesOrCheckForMissingPackagesAsync(
string solutionDirectory,
bool isSolutionAvailable,
RestoreOperationSource restoreSource,
CancellationToken token)
{
if (string.IsNullOrEmpty(solutionDirectory))
{
// If the solution is closed, SolutionDirectory will be unavailable. Just return. Do nothing
return;
}
var packages = (await _packageRestoreManager.GetPackagesInSolutionAsync(
solutionDirectory, token)).ToList();
if (_packageRestoreConsent.IsGranted)
{
_currentCount = 0;
if (packages.Count == 0)
{
if (!isSolutionAvailable &&
await CheckPackagesConfigAsync())
{
await _logger.DoAsync((l, _) =>
{
l.ShowError(Resources.SolutionIsNotSaved);
l.WriteLine(VerbosityLevel.Quiet, Resources.SolutionIsNotSaved);
});
}
// Restore is not applicable, since, there is no project with installed packages
return;
}
_packageCount += packages.Count;
var missingPackagesList = packages.Where(p => p.IsMissing).ToList();
_missingPackagesCount = missingPackagesList.Count;
if (_missingPackagesCount > 0)
{
// Only show the wait dialog, when there are some packages to restore
await _logger.RunWithProgressAsync(
async (l, _, t) =>
{
// Display the restore opt out message if it has not been shown yet
await l.WriteHeaderAsync();
await RestoreMissingPackagesInSolutionAsync(solutionDirectory, packages, t);
},
token);
// Mark that work is being done during this restore
_status = NuGetOperationStatus.Succeeded;
}
}
else if (restoreSource == RestoreOperationSource.Explicit)
{
// When the user consent is not granted, missing packages may not be restored.
// So, we just check for them, and report them as warning(s) on the error list window
await _logger.RunWithProgressAsync(
(_, __, ___) => CheckForMissingPackagesAsync(packages),
token);
}
await _packageRestoreManager.RaisePackagesMissingEventForSolutionAsync(
solutionDirectory,
token);
}
private async Task RestorePackageSpecProjectsAsync(
List <IDependencyGraphProject> projects,
bool forceRestore,
bool isSolutionAvailable,
RestoreOperationSource restoreSource,
CancellationToken token)
{
// Only continue if there are some build integrated type projects.
if (!(projects.Any(project => project is BuildIntegratedNuGetProject)))
{
return;
}
if (_packageRestoreConsent.IsGranted)
{
if (!isSolutionAvailable)
{
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings);
if (!Path.IsPathRooted(globalPackagesFolder))
{
await _logger.DoAsync((l, _) =>
{
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.RelativeGlobalPackagesFolder,
globalPackagesFolder);
l.WriteLine(VerbosityLevel.Quiet, message);
});
// Cannot restore packages since globalPackagesFolder is a relative path
// and the solution is not available
return;
}
}
// Cache p2ps discovered from DTE
var cacheContext = new DependencyGraphCacheContext(_logger, _settings);
var pathContext = NuGetPathContext.Create(_settings);
// Get full dg spec
// TODO: pass this down instead of creating it twice.
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(_solutionManager, cacheContext);
// Avoid restoring solutions with zero potential PackageReference projects.
if (DependencyGraphRestoreUtility.IsRestoreRequired(dgSpec))
{
// NOTE: During restore for build integrated projects,
// We might show the dialog even if there are no packages to restore
// When both currentStep and totalSteps are 0, we get a marquee on the dialog
await _logger.RunWithProgressAsync(
async (l, _, t) =>
{
// Display the restore opt out message if it has not been shown yet
await l.WriteHeaderAsync();
var sources = _sourceRepositoryProvider
.GetRepositories()
.ToList();
var providerCache = new RestoreCommandProvidersCache();
Action <SourceCacheContext> cacheModifier = (cache) => { };
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
_solutionManager,
cacheContext,
providerCache,
cacheModifier,
sources,
forceRestore,
dgSpec,
l,
t);
_packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum();
var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false);
_noOpProjectsCount = restoreSummaries.Where(summary => summary.NoOpRestore == true).Count();
if (isRestoreFailed)
{
_status = NuGetOperationStatus.Failed;
}
else if (_noOpProjectsCount < restoreSummaries.Count)
{
_status = NuGetOperationStatus.Succeeded;
}
},
token);
}
}
else if (restoreSource == RestoreOperationSource.Explicit)
{
// Log an error when restore is disabled and user explicitly restore.
await _logger.DoAsync((l, _) =>
{
l.ShowError(Resources.PackageRefNotRestoredBecauseOfNoConsent);
});
}
}
private async Task RestoreAsync(bool forceRestore, RestoreOperationSource restoreSource, CancellationToken token)
{
var startTime = DateTimeOffset.Now;
_status = NuGetOperationStatus.NoOp;
// start timer for telemetry event
TelemetryUtility.StartorResumeTimer();
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;
TelemetryUtility.StopTimer();
var duration = TelemetryUtility.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,
restoreSource,
startTime,
duration.TotalSeconds);
}
}
private async Task RestoreAsync(bool forceRestore, RestoreOperationSource restoreSource, CancellationToken token)
{
var startTime = DateTimeOffset.Now;
_status = NuGetOperationStatus.NoOp;
// start timer for telemetry event
var stopWatch = Stopwatch.StartNew();
var intervalTracker = new IntervalTracker(RestoreTelemetryEvent.RestoreActionEventName);
var projects = Enumerable.Empty <NuGetProject>();
_packageRestoreManager.PackageRestoredEvent += PackageRestoreManager_PackageRestored;
_packageRestoreManager.PackageRestoreFailedEvent += PackageRestoreManager_PackageRestoreFailedEvent;
var sources = _sourceRepositoryProvider.GetRepositories();
using (var packageSourceTelemetry = new PackageSourceTelemetry(sources, _nuGetProjectContext.OperationId, PackageSourceTelemetry.TelemetryAction.Restore))
{
try
{
token.ThrowIfCancellationRequested();
string solutionDirectory;
bool isSolutionAvailable;
using (intervalTracker.Start(RestoreTelemetryEvent.RestoreOperationChecks))
{
solutionDirectory = _solutionManager.SolutionDirectory;
isSolutionAvailable = await _solutionManager.IsSolutionAvailableAsync();
// 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()).ToList();
if (projects.Any() && solutionDirectory == null)
{
_status = NuGetOperationStatus.Failed;
await _logger.ShowErrorAsync(Resources.SolutionIsNotSaved);
await _logger.WriteLineAsync(VerbosityLevel.Minimal, Resources.SolutionIsNotSaved);
return;
}
}
using (intervalTracker.Start(RestoreTelemetryEvent.PackagesConfigRestore))
{
// 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(
projects,
solutionDirectory,
isSolutionAvailable,
restoreSource,
token);
}
}
var dependencyGraphProjects = projects
.OfType <IDependencyGraphProject>()
.ToList();
await RestorePackageSpecProjectsAsync(
dependencyGraphProjects,
forceRestore,
isSolutionAvailable,
restoreSource,
intervalTracker,
token);
// 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 <CpsPackageReferenceProject>().Any())
{
_restoreEventsPublisher.OnSolutionRestoreCompleted(
new SolutionRestoredEventArgs(_status, solutionDirectory));
}
}
catch (OperationCanceledException)
{
_status = NuGetOperationStatus.Cancelled;
throw;
}
catch
{
_status = NuGetOperationStatus.Failed;
throw;
}
finally
{
_packageRestoreManager.PackageRestoredEvent -= PackageRestoreManager_PackageRestored;
_packageRestoreManager.PackageRestoreFailedEvent -= PackageRestoreManager_PackageRestoreFailedEvent;
await packageSourceTelemetry.SendTelemetryAsync();
stopWatch.Stop();
var duration = stopWatch.Elapsed;
// Do not log any restore message if user disabled restore.
if (_packageRestoreConsent.IsGranted)
{
await _logger.WriteSummaryAsync(_status, duration);
}
else
{
_logger.LogDebug(Resources.PackageRefNotRestoredBecauseOfNoConsent);
}
var protocolDiagnosticsTotals = packageSourceTelemetry.GetTotals();
// Emit telemetry event for restore operation
EmitRestoreTelemetryEvent(
projects,
forceRestore,
restoreSource,
startTime,
duration.TotalSeconds,
protocolDiagnosticsTotals,
intervalTracker);
}
}
}
private async Task RestorePackageSpecProjectsAsync(
List <IDependencyGraphProject> projects,
bool forceRestore,
bool isSolutionAvailable,
RestoreOperationSource restoreSource,
IntervalTracker intervalTracker,
CancellationToken token)
{
// Only continue if there are some build integrated type projects.
if (!(projects.Any(project => project is BuildIntegratedNuGetProject)))
{
return;
}
if (_packageRestoreConsent.IsGranted)
{
if (!isSolutionAvailable)
{
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings);
if (!Path.IsPathRooted(globalPackagesFolder))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.RelativeGlobalPackagesFolder,
globalPackagesFolder);
await _logger.WriteLineAsync(VerbosityLevel.Quiet, message);
// Cannot restore packages since globalPackagesFolder is a relative path
// and the solution is not available
return;
}
}
DependencyGraphCacheContext cacheContext;
DependencyGraphSpec originalDgSpec;
DependencyGraphSpec dgSpec;
IReadOnlyList <IAssetsLogMessage> additionalMessages;
using (intervalTracker.Start(RestoreTelemetryEvent.SolutionDependencyGraphSpecCreation))
{
// Cache p2ps discovered from DTE
cacheContext = new DependencyGraphCacheContext(_logger, _settings);
var pathContext = NuGetPathContext.Create(_settings);
// Get full dg spec
(originalDgSpec, additionalMessages) = await DependencyGraphRestoreUtility.GetSolutionRestoreSpecAndAdditionalMessages(_solutionManager, cacheContext);
}
using (intervalTracker.Start(RestoreTelemetryEvent.SolutionUpToDateCheck))
{
// Run solution based up to date check.
var projectsNeedingRestore = _solutionUpToDateChecker.PerformUpToDateCheck(originalDgSpec, _logger).AsList();
var specialReferencesCount = originalDgSpec.Projects
.Where(x => x.RestoreMetadata.ProjectStyle != ProjectStyle.PackageReference && x.RestoreMetadata.ProjectStyle != ProjectStyle.PackagesConfig && x.RestoreMetadata.ProjectStyle != ProjectStyle.ProjectJson)
.Count();
dgSpec = originalDgSpec;
// Only use the optimization results if the restore is not `force`.
// Still run the optimization check anyways to prep the cache.
if (!forceRestore)
{
// Update the dg spec.
dgSpec = originalDgSpec.WithoutRestores();
foreach (var uniqueProjectId in projectsNeedingRestore)
{
dgSpec.AddRestore(uniqueProjectId); // Fill DGSpec copy only with restore-needed projects
}
// Calculate the number of up to date projects
_upToDateProjectCount = originalDgSpec.Restore.Count - specialReferencesCount - projectsNeedingRestore.Count;
_noOpProjectsCount = _upToDateProjectCount;
}
}
using (intervalTracker.Start(RestoreTelemetryEvent.PackageReferenceRestoreDuration))
{
// Avoid restoring if all the projects are up to date, or the solution does not have build integrated projects.
if (DependencyGraphRestoreUtility.IsRestoreRequired(dgSpec))
{
// NOTE: During restore for build integrated projects,
// We might show the dialog even if there are no packages to restore
// When both currentStep and totalSteps are 0, we get a marquee on the dialog
await _logger.RunWithProgressAsync(
async (l, _, t) =>
{
// Display the restore opt out message if it has not been shown yet
await l.WriteHeaderAsync();
var sources = _sourceRepositoryProvider
.GetRepositories()
.ToList();
var providerCache = new RestoreCommandProvidersCache();
Action <SourceCacheContext> cacheModifier = (cache) => { };
var isRestoreOriginalAction = true;
var isRestoreSucceeded = true;
IReadOnlyList <RestoreSummary> restoreSummaries = null;
try
{
restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
_solutionManager,
dgSpec,
cacheContext,
providerCache,
cacheModifier,
sources,
_nuGetProjectContext.OperationId,
forceRestore,
isRestoreOriginalAction,
additionalMessages,
l,
t);
_packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum();
isRestoreSucceeded = restoreSummaries.All(summary => summary.Success == true);
_noOpProjectsCount += restoreSummaries.Where(summary => summary.NoOpRestore == true).Count();
_solutionUpToDateChecker.SaveRestoreStatus(restoreSummaries);
}
catch
{
isRestoreSucceeded = false;
throw;
}
finally
{
if (isRestoreSucceeded)
{
if (_noOpProjectsCount < restoreSummaries.Count)
{
_status = NuGetOperationStatus.Succeeded;
}
else
{
_status = NuGetOperationStatus.NoOp;
}
}
else
{
_status = NuGetOperationStatus.Failed;
}
}
},
token);
}
}
}
else if (restoreSource == RestoreOperationSource.Explicit)
{
await _logger.ShowErrorAsync(Resources.PackageRefNotRestoredBecauseOfNoConsent);
}
}
