internal static void WritePhase()

in src/Agent.Listener/DistributedTask.Pipelines/Yaml/TypeConverters/ConverterUtil.phases.cs [378:676]


        internal static void WritePhase(IEmitter emitter, IPhase phase, Boolean noBootstrap = false)
        {
            if (!noBootstrap)
            {
                emitter.Emit(new MappingStart());
            }

            if (phase is PhasesTemplateReference)
            {
                var reference = phase as PhasesTemplateReference;
                if (!noBootstrap)
                {
                    emitter.Emit(new Scalar(YamlConstants.Template));
                    emitter.Emit(new Scalar(reference.Name));
                    if (reference.Parameters != null && reference.Parameters.Count > 0)
                    {
                        emitter.Emit(new Scalar(YamlConstants.Parameters));
                        WriteMapping(emitter, reference.Parameters);
                    }
                }

                if (reference.PhaseSelectors != null && reference.PhaseSelectors.Count > 0)
                {
                    emitter.Emit(new Scalar(YamlConstants.Phases));
                    emitter.Emit(new SequenceStart(null, null, true, SequenceStyle.Block));
                    foreach (PhaseSelector selector in reference.PhaseSelectors)
                    {
                        emitter.Emit(new MappingStart());
                        if (!String.IsNullOrEmpty(selector.Name))
                        {
                            emitter.Emit(new Scalar(YamlConstants.Name));
                            emitter.Emit(new Scalar(selector.Name));
                        }

                        if (selector.StepOverrides != null && selector.StepOverrides.Count > 0)
                        {
                            emitter.Emit(new Scalar(YamlConstants.Steps));
                            WriteStepOverrides(emitter, selector.StepOverrides);
                        }

                        emitter.Emit(new MappingEnd());
                    }

                    emitter.Emit(new SequenceEnd());
                }

                WriteStep(emitter, reference as StepsTemplateReference, noBootstrap: true);
            }
            else
            {
                var p = phase as Phase;
                if (!noBootstrap)
                {
                    emitter.Emit(new Scalar(YamlConstants.Name));
                    emitter.Emit(new Scalar(p.Name ?? String.Empty));
                }

                if (p.DependsOn != null && p.DependsOn.Count > 0)
                {
                    emitter.Emit(new Scalar(YamlConstants.DependsOn));
                    if (p.DependsOn.Count == 1)
                    {
                        emitter.Emit(new Scalar(p.DependsOn[0]));
                    }
                    else
                    {
                        WriteSequence(emitter, p.DependsOn);
                    }
                }

                if (!String.IsNullOrEmpty(p.Condition))
                {
                    emitter.Emit(new Scalar(YamlConstants.Condition));
                    emitter.Emit(new Scalar(p.Condition));
                }

                if (!String.IsNullOrEmpty(p.ContinueOnError))
                {
                    emitter.Emit(new Scalar(YamlConstants.ContinueOnError));
                    emitter.Emit(new Scalar(p.ContinueOnError));
                }

                if (!String.IsNullOrEmpty(p.EnableAccessToken))
                {
                    emitter.Emit(new Scalar(YamlConstants.EnableAccessToken));
                    emitter.Emit(new Scalar(p.EnableAccessToken));
                }

                if (p.Target != null)
                {
                    QueueTarget queueTarget = null;
                    DeploymentTarget deploymentTarget = null;
                    ServerTarget serverTarget = null;
                    if ((queueTarget = p.Target as QueueTarget) != null)
                    {
                        emitter.Emit(new Scalar(YamlConstants.Queue));

                        // Test for the simple case "queue: name".
                        if (!String.IsNullOrEmpty(queueTarget.Name) &&
                            String.IsNullOrEmpty(queueTarget.ContinueOnError) &&
                            String.IsNullOrEmpty(queueTarget.Parallel) &&
                            String.IsNullOrEmpty(queueTarget.TimeoutInMinutes) &&
                            (queueTarget.Demands == null || queueTarget.Demands.Count == 0) &&
                            (queueTarget.Matrix == null || queueTarget.Matrix.Count == 0))
                        {
                            emitter.Emit(new Scalar(queueTarget.Name));
                        }
                        else // Otherwise write the mapping.
                        {
                            emitter.Emit(new MappingStart());
                            if (!String.IsNullOrEmpty(queueTarget.Name))
                            {
                                emitter.Emit(new Scalar(YamlConstants.Name));
                                emitter.Emit(new Scalar(queueTarget.Name));
                            }

                            if (!String.IsNullOrEmpty(queueTarget.ContinueOnError))
                            {
                                emitter.Emit(new Scalar(YamlConstants.ContinueOnError));
                                emitter.Emit(new Scalar(queueTarget.ContinueOnError));
                            }

                            if (!String.IsNullOrEmpty(queueTarget.Parallel))
                            {
                                emitter.Emit(new Scalar(YamlConstants.Parallel));
                                emitter.Emit(new Scalar(queueTarget.Parallel));
                            }

                            if (!String.IsNullOrEmpty(queueTarget.TimeoutInMinutes))
                            {
                                emitter.Emit(new Scalar(YamlConstants.TimeoutInMinutes));
                                emitter.Emit(new Scalar(queueTarget.TimeoutInMinutes));
                            }

                            if (queueTarget.Demands != null && queueTarget.Demands.Count > 0)
                            {
                                emitter.Emit(new Scalar(YamlConstants.Demands));
                                if (queueTarget.Demands.Count == 1)
                                {
                                    emitter.Emit(new Scalar(queueTarget.Demands[0]));
                                }
                                else
                                {
                                    WriteSequence(emitter, queueTarget.Demands);
                                }
                            }

                            if (queueTarget.Matrix != null && queueTarget.Matrix.Count > 0)
                            {
                                emitter.Emit(new Scalar(YamlConstants.Matrix));
                                emitter.Emit(new MappingStart());
                                foreach (KeyValuePair<String, IDictionary<String, String>> pair in queueTarget.Matrix.OrderBy(x => x.Key, StringComparer.OrdinalIgnoreCase))
                                {
                                    emitter.Emit(new Scalar(pair.Key));
                                    WriteMapping(emitter, pair.Value);
                                }

                                emitter.Emit(new MappingEnd());
                            }

                            emitter.Emit(new MappingEnd());
                        }
                    }
                    else if ((deploymentTarget = p.Target as DeploymentTarget) != null)
                    {
                        emitter.Emit(new Scalar(YamlConstants.Deployment));

                        // Test for the simple case "deployment: group".
                        if (!String.IsNullOrEmpty(deploymentTarget.Group) &&
                            String.IsNullOrEmpty(deploymentTarget.ContinueOnError) &&
                            String.IsNullOrEmpty(deploymentTarget.HealthOption) &&
                            String.IsNullOrEmpty(deploymentTarget.Percentage) &&
                            String.IsNullOrEmpty(deploymentTarget.TimeoutInMinutes) &&
                            (deploymentTarget.Tags == null || deploymentTarget.Tags.Count == 0))
                        {
                            emitter.Emit(new Scalar(deploymentTarget.Group));
                        }
                        else // Otherwise write the mapping.
                        {
                            emitter.Emit(new MappingStart());
                            if (!String.IsNullOrEmpty(deploymentTarget.Group))
                            {
                                emitter.Emit(new Scalar(YamlConstants.Group));
                                emitter.Emit(new Scalar(deploymentTarget.Group));
                            }

                            if (!String.IsNullOrEmpty(deploymentTarget.ContinueOnError))
                            {
                                emitter.Emit(new Scalar(YamlConstants.ContinueOnError));
                                emitter.Emit(new Scalar(deploymentTarget.ContinueOnError));
                            }

                            if (!String.IsNullOrEmpty(deploymentTarget.HealthOption))
                            {
                                emitter.Emit(new Scalar(YamlConstants.HealthOption));
                                emitter.Emit(new Scalar(deploymentTarget.HealthOption));
                            }

                            if (!String.IsNullOrEmpty(deploymentTarget.Percentage))
                            {
                                emitter.Emit(new Scalar(YamlConstants.Percentage));
                                emitter.Emit(new Scalar(deploymentTarget.Percentage));
                            }

                            if (!String.IsNullOrEmpty(deploymentTarget.TimeoutInMinutes))
                            {
                                emitter.Emit(new Scalar(YamlConstants.TimeoutInMinutes));
                                emitter.Emit(new Scalar(deploymentTarget.TimeoutInMinutes));
                            }

                            if (deploymentTarget.Tags != null && deploymentTarget.Tags.Count > 0)
                            {
                                emitter.Emit(new Scalar(YamlConstants.Tags));
                                if (deploymentTarget.Tags.Count == 1)
                                {
                                    emitter.Emit(new Scalar(deploymentTarget.Tags[0]));
                                }
                                else
                                {
                                    WriteSequence(emitter, deploymentTarget.Tags);
                                }
                            }

                            emitter.Emit(new MappingEnd());
                        }
                    }
                    else if ((serverTarget = p.Target as ServerTarget) != null)
                    {
                        emitter.Emit(new Scalar(YamlConstants.Server));

                        // Test for the simple case "server: true".
                        if (String.IsNullOrEmpty(serverTarget.ContinueOnError) &&
                            String.IsNullOrEmpty(serverTarget.Parallel) &&
                            String.IsNullOrEmpty(serverTarget.TimeoutInMinutes) &&
                            (serverTarget.Matrix == null || serverTarget.Matrix.Count == 0))
                        {
                            emitter.Emit(new Scalar("true"));
                        }
                        else // Otherwise write the mapping.
                        {
                            emitter.Emit(new MappingStart());
                            if (!String.IsNullOrEmpty(serverTarget.ContinueOnError))
                            {
                                emitter.Emit(new Scalar(YamlConstants.ContinueOnError));
                                emitter.Emit(new Scalar(serverTarget.ContinueOnError));
                            }

                            if (!String.IsNullOrEmpty(serverTarget.Parallel))
                            {
                                emitter.Emit(new Scalar(YamlConstants.Parallel));
                                emitter.Emit(new Scalar(serverTarget.Parallel));
                            }

                            if (!String.IsNullOrEmpty(serverTarget.TimeoutInMinutes))
                            {
                                emitter.Emit(new Scalar(YamlConstants.TimeoutInMinutes));
                                emitter.Emit(new Scalar(serverTarget.TimeoutInMinutes));
                            }

                            if (serverTarget.Matrix != null && serverTarget.Matrix.Count > 0)
                            {
                                emitter.Emit(new Scalar(YamlConstants.Matrix));
                                emitter.Emit(new MappingStart());
                                foreach (KeyValuePair<String, IDictionary<String, String>> pair in serverTarget.Matrix.OrderBy(x => x.Key, StringComparer.OrdinalIgnoreCase))
                                {
                                    emitter.Emit(new Scalar(pair.Key));
                                    WriteMapping(emitter, pair.Value);
                                }

                                emitter.Emit(new MappingEnd());
                            }

                            emitter.Emit(new MappingEnd());
                        }
                    }
                    else
                    {
                        throw new NotSupportedException($"Unexpected target type: '{p.Target.GetType().FullName}'");
                    }
                }

                if (p.Variables != null && p.Variables.Count > 0)
                {
                    emitter.Emit(new Scalar(YamlConstants.Variables));
                    WriteVariables(emitter, p.Variables);
                }

                if (p.Steps != null && p.Steps.Count > 0)
                {
                    emitter.Emit(new Scalar(YamlConstants.Steps));
                    WriteSteps(emitter, p.Steps);
                }
            }

            if (!noBootstrap)
            {
                emitter.Emit(new MappingEnd());
            }
        }