Exemplo n.º 1
0
        internal static void SetProperty(IParser parser, StepsTemplateReference reference, Scalar scalar)
        {
            switch (scalar.Value ?? String.Empty)
            {
            case YamlConstants.Parameters:
                reference.Parameters = ReadMapping(parser);
                break;

            case YamlConstants.Steps:
                reference.StepOverrides = ReadStepOverrides(parser);
                break;

            default:
                throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected property: '{scalar.Value}'");
            }
        }
Exemplo n.º 2
0
        internal static IStep ReadStep(IParser parser, Boolean simpleOnly = false)
        {
            IStep result;

            parser.Expect <MappingStart>();
            var scalar = parser.Expect <Scalar>();

            if (String.Equals(scalar.Value, YamlConstants.Task, StringComparison.Ordinal))
            {
                var task = new TaskStep {
                    Enabled = true
                };
                scalar = parser.Expect <Scalar>();
                String[] refComponents = (scalar.Value ?? String.Empty).Split('@');
                Int32    version;
                if (refComponents.Length != 2 ||
                    String.IsNullOrEmpty(refComponents[0]) ||
                    String.IsNullOrEmpty(refComponents[1]) ||
                    !Int32.TryParse(refComponents[1], NumberStyles.None, CultureInfo.InvariantCulture, out version))
                {
                    throw new SyntaxErrorException(scalar.Start, scalar.End, $"Task reference must be in the format <NAME>@<VERSION>. For example MyTask@2. The following task reference format is invalid: '{scalar.Value}'");
                }

                task.Reference = new TaskReference
                {
                    Name    = refComponents[0],
                    Version = refComponents[1],
                };
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.Inputs:
                        task.Inputs = ReadMappingOfStringString(parser, StringComparer.OrdinalIgnoreCase);
                        break;

                    default:
                        SetTaskControlProperty(parser, task, scalar);
                        break;
                    }
                }

                result = task;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Script, StringComparison.Ordinal))
            {
                var task = new TaskStep
                {
                    Enabled   = true,
                    Reference = new TaskReference
                    {
                        Name    = "CmdLine",
                        Version = "2",
                    },
                    Inputs = new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase),
                };

                task.Inputs["script"] = parser.Expect <Scalar>().Value ?? String.Empty;
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.FailOnStderr:
                        task.Inputs["failOnStderr"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.WorkingDirectory:
                        task.Inputs["workingDirectory"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    default:
                        SetTaskControlProperty(parser, task, scalar);
                        break;
                    }
                }

                result = task;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Bash, StringComparison.Ordinal))
            {
                var task = new TaskStep
                {
                    Enabled   = true,
                    Reference = new TaskReference
                    {
                        Name    = "Bash",
                        Version = "3",
                    },
                    Inputs = new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase),
                };

                task.Inputs["targetType"] = "inline";
                task.Inputs["script"]     = parser.Expect <Scalar>().Value ?? String.Empty;
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.FailOnStderr:
                        task.Inputs["failOnStderr"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.WorkingDirectory:
                        task.Inputs["workingDirectory"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    default:
                        SetTaskControlProperty(parser, task, scalar);
                        break;
                    }
                }

                result = task;
            }
            else if (String.Equals(scalar.Value, YamlConstants.PowerShell, StringComparison.Ordinal))
            {
                var task = new TaskStep
                {
                    Enabled   = true,
                    Reference = new TaskReference
                    {
                        Name    = "PowerShell",
                        Version = "2",
                    },
                    Inputs = new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase),
                };

                task.Inputs["targetType"] = "inline";
                task.Inputs["script"]     = parser.Expect <Scalar>().Value ?? String.Empty;
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.ErrorActionPreference:
                        task.Inputs["errorActionPreference"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.FailOnStderr:
                        task.Inputs["failOnStderr"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.IgnoreLASTEXITCODE:
                        task.Inputs["ignoreLASTEXITCODE"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    case YamlConstants.WorkingDirectory:
                        task.Inputs["workingDirectory"] = parser.Expect <Scalar>().Value ?? String.Empty;
                        break;

                    default:
                        SetTaskControlProperty(parser, task, scalar);
                        break;
                    }
                }

                result = task;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Checkout, StringComparison.Ordinal))
            {
                var checkoutStep = new CheckoutStep();
                scalar            = parser.Expect <Scalar>();
                checkoutStep.Name = scalar.Value ?? String.Empty;
                if (String.Equals(checkoutStep.Name, YamlConstants.Self, StringComparison.Ordinal))
                {
                    while (parser.Allow <MappingEnd>() == null)
                    {
                        scalar = parser.Expect <Scalar>();
                        switch (scalar.Value ?? String.Empty)
                        {
                        case YamlConstants.Clean:
                            checkoutStep.Clean = ReadNonEmptyString(parser);
                            break;

                        case YamlConstants.FetchDepth:
                            checkoutStep.FetchDepth = ReadNonEmptyString(parser);
                            break;

                        case YamlConstants.Lfs:
                            checkoutStep.Lfs = ReadNonEmptyString(parser);
                            break;
                        }
                    }
                }
                else if (String.Equals(checkoutStep.Name, YamlConstants.None, StringComparison.Ordinal))
                {
                    parser.Expect <MappingEnd>();
                }
                else
                {
                    throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected resource name '{scalar.Value}'. The '{YamlConstants.Checkout}' step currently can only be used with the resource name '{YamlConstants.Self}' or '{YamlConstants.None}'.");
                }

                result = checkoutStep;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Group, StringComparison.Ordinal))
            {
                if (simpleOnly)
                {
                    throw new SyntaxErrorException(scalar.Start, scalar.End, $"A step '{YamlConstants.Group}' cannot be nested within a step group or steps template.");
                }

                var stepGroup = new StepGroup()
                {
                    Name = ReadNonEmptyString(parser)
                };
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    if (String.Equals(scalar.Value, YamlConstants.Steps, StringComparison.Ordinal))
                    {
                        stepGroup.Steps = ReadSteps(parser, simpleOnly: true).Cast <ISimpleStep>().ToList();
                    }
                    else
                    {
                        throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected property: '{scalar.Value}'");
                    }
                }

                result = stepGroup;
            }
            else if (String.Equals(scalar.Value, YamlConstants.Template, StringComparison.Ordinal))
            {
                if (simpleOnly)
                {
                    throw new SyntaxErrorException(scalar.Start, scalar.End, $"Steps '{YamlConstants.Template}' cannot be nested within a step group or steps template.");
                }

                var templateReference = new StepsTemplateReference {
                    Name = ReadNonEmptyString(parser)
                };
                while (parser.Allow <MappingEnd>() == null)
                {
                    scalar = parser.Expect <Scalar>();
                    switch (scalar.Value ?? String.Empty)
                    {
                    case YamlConstants.Parameters:
                        templateReference.Parameters = ReadMapping(parser);
                        break;

                    case YamlConstants.Steps:
                        templateReference.StepOverrides = ReadStepOverrides(parser);
                        break;

                    default:
                        throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected property: '{scalar.Value}'");
                    }
                }

                result = templateReference;
            }
            else
            {
                throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unknown step type: '{scalar.Value}'");
            }

            return(result);
        }