private void DisplayConstraintResults(IReadOnlyList <TemplateConstraintResult> constraintResults, TemplateCommandArgs templateArgs)
{
var reporter = templateArgs.IsForceFlagSpecified ? Reporter.Output : Reporter.Error;
if (templateArgs.IsForceFlagSpecified)
{
reporter.WriteLine(string.Format(LocalizableStrings.TemplateCommand_DisplayConstraintResults_Warning, templateArgs.Template.Name));
}
else
{
reporter.WriteLine(string.Format(LocalizableStrings.TemplateCommand_DisplayConstraintResults_Error, templateArgs.Template.Name));
}
foreach (var constraint in constraintResults.Where(cr => cr.EvaluationStatus != TemplateConstraintResult.Status.Allowed))
{
reporter.WriteLine(constraint.ToDisplayString().Indent());
}
reporter.WriteLine();
if (!templateArgs.IsForceFlagSpecified)
{
reporter.WriteLine(string.Format(LocalizableStrings.TemplateCommand_DisplayConstraintResults_Hint, TemplateCommand.ForceOption.Aliases.First()));
reporter.WriteCommand(Example.FromExistingTokens(templateArgs.ParseResult).WithOption(TemplateCommand.ForceOption));
}
else
{
reporter.WriteLine(LocalizableStrings.TemplateCommand_DisplayConstraintResults_Hint_TemplateNotUsable);
}
}
internal async Task <NewCommandStatus> InvokeAsync(ParseResult parseResult, ITelemetryLogger telemetryLogger, CancellationToken cancellationToken)
{
TemplateCommandArgs args = new TemplateCommandArgs(this, _instantiateCommand, parseResult);
TemplateInvoker invoker = new TemplateInvoker(_environmentSettings, telemetryLogger, () => Console.ReadLine() ?? string.Empty, _instantiateCommand.Callbacks);
TemplatePackageCoordinator packageCoordinator = new TemplatePackageCoordinator(telemetryLogger, _environmentSettings, _templatePackageManager);
TemplateConstraintManager constraintManager = new TemplateConstraintManager(_environmentSettings);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(ConstraintEvaluationTimeout);
Task <IReadOnlyList <TemplateConstraintResult> > constraintsEvaluation = ValidateConstraintsAsync(constraintManager, args.Template, args.IsForceFlagSpecified ? cancellationTokenSource.Token : cancellationToken);
if (!args.IsForceFlagSpecified)
{
var constraintResults = await constraintsEvaluation.ConfigureAwait(false);
if (constraintResults.Any())
{
DisplayConstraintResults(constraintResults, args);
return(NewCommandStatus.CreateFailed);
}
}
cancellationToken.ThrowIfCancellationRequested();
Task <NewCommandStatus> instantiateTask = invoker.InvokeTemplateAsync(args, cancellationToken);
Task <(string Id, string Version, string Provider)> builtInPackageCheck = packageCoordinator.ValidateBuiltInPackageAvailabilityAsync(args.Template, cancellationToken);
Task <CheckUpdateResult?> checkForUpdateTask = packageCoordinator.CheckUpdateForTemplate(args, cancellationToken);
Task[] tasksToWait = new Task[] { instantiateTask, builtInPackageCheck, checkForUpdateTask };
await Task.WhenAll(tasksToWait).ConfigureAwait(false);
Reporter.Output.WriteLine();
cancellationToken.ThrowIfCancellationRequested();
if (checkForUpdateTask.Result != null)
{
// print if there is update for the template package containing the template
packageCoordinator.DisplayUpdateCheckResult(checkForUpdateTask.Result, args);
}
if (builtInPackageCheck.Result != default)
{
// print if there is same or newer built-in package
packageCoordinator.DisplayBuiltInPackagesCheckResult(
builtInPackageCheck.Result.Id,
builtInPackageCheck.Result.Version,
builtInPackageCheck.Result.Provider,
args);
}
if (args.IsForceFlagSpecified)
{
// print warning about the constraints that were not met.
try
{
IReadOnlyList <TemplateConstraintResult> constraintResults = await constraintsEvaluation.WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
if (constraintResults.Any())
{
DisplayConstraintResults(constraintResults, args);
}
}
catch (TaskCanceledException)
{
// do nothing
}
}
return(instantiateTask.Result);
}