private static void ApplyStepOverrides(PhasesTemplateReference reference, PhasesTemplate template)
{
// Select by phase name.
var byPhaseNames =
(reference.PhaseSelectors ?? new List <PhaseSelector>(0))
.Join(inner: (template.Phases ?? new List <IPhase>(0)).Cast <Phase>(),
outerKeySelector: (PhaseSelector phaseSelector) => phaseSelector.Name,
innerKeySelector: (Phase phase) => phase.Name,
resultSelector: (PhaseSelector phaseSelector, Phase phase) => new { Selector = phaseSelector, Phase = phase })
.ToArray();
// Apply overrides from phase selectors.
foreach (var byPhaseName in byPhaseNames)
{
ApplyStepOverrides(byPhaseName.Selector.StepOverrides, byPhaseName.Phase.Steps);
}
// Apply unqualified overrides.
var allStepLists =
(template.Phases ?? new List <IPhase>(0))
.Cast <Phase>()
.Select((Phase phase) => phase.Steps ?? new List <IStep>(0))
.Concat(new[] { template.Steps ?? new List <IStep>(0) })
.ToArray();
foreach (List <IStep> stepList in allStepLists)
{
ApplyStepOverrides(reference.StepOverrides, stepList);
}
}
public Object ReadYaml(IParser parser, Type type)
{
var result = new PhasesTemplate();
parser.Expect <MappingStart>();
while (parser.Allow <MappingEnd>() == null)
{
Scalar scalar = parser.Expect <Scalar>();
switch (scalar.Value ?? String.Empty)
{
//
// Phases template properties
//
case YamlConstants.Phases:
ConverterUtil.ValidateNull(result.Steps, YamlConstants.Steps, YamlConstants.Phases, scalar);
result.Phases = ConverterUtil.ReadPhases(parser, simpleOnly: true);
break;
//
// Steps template properties
//
case YamlConstants.Steps:
ConverterUtil.ValidateNull(result.Phases, YamlConstants.Phases, YamlConstants.Steps, scalar);
result.Steps = ConverterUtil.ReadSteps(parser, simpleOnly: false);
break;
default:
throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected process property: '{scalar.Value}'");
}
}
return(result);
}
private void ResolveTemplates(IList <IPhase> phases, String defaultRoot, CancellationToken cancellationToken, ref Int32 fileCount)
{
for (int i = 0; i < (phases?.Count ?? 0);)
{
if (phases[i] is PhasesTemplateReference)
{
// Load the template.
var reference = phases[i] as PhasesTemplateReference;
String templateFilePath = m_fileProvider.ResolvePath(defaultRoot: defaultRoot, path: reference.Name);
PipelineFile <PhasesTemplate> templateFile = LoadFile <PhasesTemplate, PhasesTemplateConverter>(templateFilePath, reference.Parameters, cancellationToken, ref fileCount);
PhasesTemplate template = templateFile.Object;
// Resolve template references within the template.
if (template.Steps != null)
{
ResolveTemplates(template.Steps, defaultRoot: templateFile.Directory, cancellationToken: cancellationToken, fileCount: ref fileCount);
}
// Merge the template.
ApplyStepOverrides(reference, template);
phases.RemoveAt(i);
if (template.Phases != null)
{
foreach (IPhase phase in template.Phases)
{
phases.Insert(i, phase);
}
i += template.Phases.Count;
}
else if (template.Steps != null)
{
var newPhase = new Phase {
Steps = template.Steps
};
phases.Insert(i, newPhase);
i++;
}
}
else
{
// Resolve nested template references.
var phase = phases[i] as Phase;
if (phase.Variables != null)
{
ResolveTemplates(phase.Variables, defaultRoot, cancellationToken, ref fileCount);
}
if (phase.Steps != null)
{
ResolveTemplates(phase.Steps, defaultRoot, cancellationToken, ref fileCount);
}
i++;
}
}
}
internal static void WritePhasesTemplate(IEmitter emitter, PhasesTemplate template, Boolean noBootstrapper = false)
{
if (!noBootstrapper)
{
emitter.Emit(new MappingStart());
}
if (template.Phases != null && template.Phases.Count > 0)
{
emitter.Emit(new Scalar(YamlConstants.Phases));
WritePhases(emitter, template.Phases);
}
WriteStepsTemplate(emitter, template, noBootstrapper: true);
if (!noBootstrapper)
{
emitter.Emit(new MappingEnd());
}
}
