// Package ci leest blue-ci-cd.yml en bepaalt welke jobs draaien. // De vorm volgt GitLab CI waar dat in BlueGit past. Een oud bestand met // een jobs:-map blijft geldig. Jobs mogen ook los op het hoogste niveau staan. package ci import ( "errors" "fmt" "strconv" "strings" "time" "gitlab.com/Timfa/bluegit/internal/i18n" "gopkg.in/yaml.v3" ) // Parse leest YAML. Jobvolgorde blijft de volgorde uit het bestand. func Parse(data []byte) (Pipeline, error) { return ParseIn(data, nil) } // ParseIn leest YAML en haalt include: local via read op. func ParseIn(data []byte, read func(string) ([]byte, error)) (Pipeline, error) { p, issues, err := parseBytes(data, read, nil) if err != nil { return Pipeline{}, err } for _, is := range issues { if !is.Warning { return Pipeline{}, is } } p.Warnings = warningsOnly(issues) return p, nil } // Lint geeft elke fout en waarschuwing, met regelnummer, zonder te stoppen bij de eerste. func Lint(data []byte, read func(string) ([]byte, error)) (Pipeline, []Issue) { p, issues, err := parseBytes(data, read, nil) if err != nil { // parseBytes verpakt een YAML-fout al als ci.err.yaml. Nog eens // verpakken geeft "invalid YAML: invalid YAML: ...". line := Issue{Line: 1, Key: "ci.err.yaml", Args: []any{err.Error()}} var ie i18n.Error if errors.As(err, &ie) { line.Key, line.Args = ie.Key, ie.Args } issues = append([]Issue{line}, issues...) } return p, issues } func (i Issue) Error() string { return i18n.T(i18n.EN, i.Key, i.Args...) } func warningsOnly(in []Issue) []Issue { var out []Issue for _, is := range in { if is.Warning { out = append(out, is) } } return out } var reserved = map[string]bool{ "stages": true, "variables": true, "image": true, "default": true, "include": true, "before_script": true, "after_script": true, "cache": true, "workflow": true, "services": true, "spec": true, "pages": true, "jobs": true, } type draft struct { job Job present map[string]bool extends []string line int } func parseBytes(data []byte, read func(string) ([]byte, error), stack []string) (Pipeline, []Issue, error) { var root yaml.Node if err := yaml.Unmarshal(data, &root); err != nil { return Pipeline{}, nil, i18n.E("ci.err.yaml", err.Error()) } // Een leeg document of alleen commentaar is een pipeline zonder jobs. // Een echte mapping, ook een lege zoals {}, blijft door validate gaan. if root.Kind == 0 || len(root.Content) == 0 { return Pipeline{Variables: map[string]string{}}, nil, nil } if root.Kind != yaml.DocumentNode || len(root.Content) != 1 || root.Content[0].Kind != yaml.MappingNode { return Pipeline{}, []Issue{{Line: 1, Key: "ci.err.mapping"}}, nil } body := root.Content[0] var included Pipeline var issues []Issue for i := 0; i < len(body.Content); i += 2 { if body.Content[i].Value != "include" { continue } part, more, err := parseInclude(body.Content[i+1], read, stack) if err != nil { return Pipeline{}, nil, err } issues = append(issues, more...) included = mergePipeline(included, part) } p := included if p.Variables == nil { p.Variables = map[string]string{} } var def draft def.present = map[string]bool{} var jobs []draft seenLegacy := false seenTop := false for i := 0; i < len(body.Content); i += 2 { keyNode := body.Content[i] key := keyNode.Value val := body.Content[i+1] switch key { case "include": continue case "stages": stages, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) if len(stages) > 0 { p.Stages = stages } case "variables": vars, iss := scalarMap(val) issues = append(issues, iss...) for k, v := range vars { p.Variables[k] = v } case "image": img, iss := imageOf(val) issues = append(issues, iss...) if img != "" { p.Image = img } case "before_script": lines, iss := scriptList(val) issues = append(issues, iss...) p.Before = lines def.present["before_script"] = true def.job.Before = lines case "after_script": lines, iss := scriptList(val) issues = append(issues, iss...) p.After = lines def.present["after_script"] = true def.job.After = lines case "cache": c, iss := parseCache(val) issues = append(issues, iss...) p.Cache = c def.present["cache"] = true def.job.Cache = c case "default": d, iss := parseDefault(val) issues = append(issues, iss...) def = overlayDefault(def, d) case "workflow": rules, iss := parseWorkflow(val) issues = append(issues, iss...) p.Workflow = rules case "services", "spec", "pages": issues = append(issues, Issue{Line: keyNode.Line, Key: "ci.warn.ignored", Args: []any{key}, Warning: true}) case "jobs": seenLegacy = true parsed, iss := parseJobMap(val) issues = append(issues, iss...) jobs = append(jobs, parsed...) default: if val.Kind != yaml.MappingNode { issues = append(issues, Issue{Line: keyNode.Line, Key: "ci.err.unknown", Args: []any{key}}) continue } seenTop = true job, iss := parseJob(key, val) issues = append(issues, iss...) jobs = append(jobs, job) } } if seenLegacy && seenTop { issues = append(issues, Issue{Line: 1, Key: "ci.err.both"}) } if p.Image != "" && !def.present["image"] { def.present["image"] = true def.job.Image = p.Image } resolved, iss := applyExtends(jobs, def) issues = append(issues, iss...) byName := map[string]int{} var merged []Job for _, j := range p.Jobs { byName[j.Name] = len(merged) merged = append(merged, j) } for _, d := range resolved { if strings.HasPrefix(d.job.Name, ".") { continue } if i, ok := byName[d.job.Name]; ok { merged[i] = overlayJob(merged[i], d) continue } byName[d.job.Name] = len(merged) merged = append(merged, d.job) } p.Jobs = merged issues = append(issues, validate(&p)...) if hasError(issues) { return p, issues, nil } return p, issues, nil } func parseInclude(node *yaml.Node, read func(string) ([]byte, error), stack []string) (Pipeline, []Issue, error) { var items []*yaml.Node switch node.Kind { case yaml.SequenceNode: items = node.Content default: items = []*yaml.Node{node} } var out Pipeline var issues []Issue for _, item := range items { local, iss := includeLocal(item) issues = append(issues, iss...) if local == "" { continue } if read == nil { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeRead", Args: []any{local}}) continue } for _, prev := range stack { if prev == local { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeCycle", Args: []any{local}}) local = "" break } } if local == "" { continue } raw, err := read(local) if err != nil { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeRead", Args: []any{local}}) continue } part, more, err := parseBytes(raw, read, append(append([]string{}, stack...), local)) if err != nil { return Pipeline{}, nil, err } issues = append(issues, more...) out = mergePipeline(out, part) } return out, issues, nil } func includeLocal(node *yaml.Node) (string, []Issue) { switch node.Kind { case yaml.ScalarNode: return cleanLocal(node.Value, node) case yaml.MappingNode: for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value if key == "local" { if node.Content[i+1].Kind != yaml.ScalarNode { return "", []Issue{{Line: node.Line, Key: "ci.err.includeLocal"}} } return cleanLocal(node.Content[i+1].Value, node.Content[i+1]) } } return "", []Issue{{Line: node.Line, Key: "ci.err.includeRemote"}} default: return "", []Issue{{Line: node.Line, Key: "ci.err.includeLocal"}} } } func cleanLocal(p string, node *yaml.Node) (string, []Issue) { p = strings.TrimPrefix(strings.TrimSpace(p), "/") if p == "" || strings.Contains(p, "\\") || strings.Contains(p, "..") { return "", []Issue{{Line: node.Line, Key: "ci.err.rel", Args: []any{p}}} } return p, nil } func mergePipeline(base, extra Pipeline) Pipeline { if len(extra.Stages) > 0 { base.Stages = extra.Stages } if base.Variables == nil { base.Variables = map[string]string{} } for k, v := range extra.Variables { base.Variables[k] = v } if extra.Image != "" { base.Image = extra.Image } if extra.Before != nil { base.Before = extra.Before } if extra.After != nil { base.After = extra.After } byName := map[string]int{} for i, j := range base.Jobs { byName[j.Name] = i } for _, j := range extra.Jobs { if i, ok := byName[j.Name]; ok { base.Jobs[i] = j continue } byName[j.Name] = len(base.Jobs) base.Jobs = append(base.Jobs, j) } return base } func parseDefault(node *yaml.Node) (draft, []Issue) { d := draft{present: map[string]bool{}} if node.Kind != yaml.MappingNode { return d, []Issue{{Line: node.Line, Key: "ci.err.map"}} } var issues []Issue for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] switch key { case "image": img, iss := imageOf(val) issues = append(issues, iss...) d.job.Image = img d.present["image"] = true case "before_script": lines, iss := scriptList(val) issues = append(issues, iss...) d.job.Before = lines d.present["before_script"] = true case "after_script": lines, iss := scriptList(val) issues = append(issues, iss...) d.job.After = lines d.present["after_script"] = true case "tags": tags, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) d.job.Tags = tags d.present["tags"] = true case "timeout": dur, iss := durationOf(val) issues = append(issues, iss...) d.job.Timeout = dur d.present["timeout"] = true case "retry": retry, iss := parseRetry(val) issues = append(issues, iss...) d.job.Retry = retry d.present["retry"] = true case "interruptible": b, iss := parseBool(val) issues = append(issues, iss...) d.job.Interruptible = b d.present["interruptible"] = true case "cache": c, iss := parseCache(val) issues = append(issues, iss...) d.job.Cache = c d.present["cache"] = true default: issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"default." + key}, Warning: true}) } } return d, issues } func overlayJob(base Job, d draft) Job { set := func(key string, apply func()) { if d.present[key] { apply() } } set("stage", func() { base.Stage = d.job.Stage }) set("image", func() { base.Image = d.job.Image }) set("before_script", func() { base.Before = d.job.Before }) set("script", func() { base.Script = d.job.Script }) set("after_script", func() { base.After = d.job.After }) set("needs", func() { base.Needs = d.job.Needs base.Optional = d.job.Optional base.NeedsSet = d.job.NeedsSet }) set("artifacts", func() { base.Artifacts = d.job.Artifacts }) set("rules", func() { base.Rules = d.job.Rules }) set("allow_failure", func() { base.AllowFailure = d.job.AllowFailure }) set("when", func() { base.When = d.job.When }) set("timeout", func() { base.Timeout = d.job.Timeout }) set("tags", func() { base.Tags = d.job.Tags }) set("cache", func() { base.Cache = d.job.Cache }) set("resource_group", func() { base.ResourceGroup = d.job.ResourceGroup }) set("only", func() { base.Only = d.job.Only }) set("except", func() { base.Except = d.job.Except }) set("retry", func() { base.Retry = d.job.Retry }) set("parallel", func() { base.Parallel = d.job.Parallel base.Matrix = d.job.Matrix }) set("services", func() { base.Services = d.job.Services }) set("environment", func() { base.Environment = d.job.Environment }) set("interruptible", func() { base.Interruptible = d.job.Interruptible }) if d.present["variables"] { mergedVars := map[string]string{} for k, v := range base.Variables { mergedVars[k] = v } for k, v := range d.job.Variables { mergedVars[k] = v } base.Variables = mergedVars } return base } func overlayDefault(base, extra draft) draft { if base.present == nil { base.present = map[string]bool{} } for k, on := range extra.present { if !on { continue } base.present[k] = true switch k { case "image": base.job.Image = extra.job.Image case "before_script": base.job.Before = extra.job.Before case "after_script": base.job.After = extra.job.After case "tags": base.job.Tags = extra.job.Tags case "timeout": base.job.Timeout = extra.job.Timeout case "cache": base.job.Cache = extra.job.Cache case "retry": base.job.Retry = extra.job.Retry case "interruptible": base.job.Interruptible = extra.job.Interruptible } } return base } func parseJobMap(node *yaml.Node) ([]draft, []Issue) { if node.Kind != yaml.MappingNode { return nil, []Issue{{Line: node.Line, Key: "ci.err.jobsMap"}} } var jobs []draft var issues []Issue for i := 0; i < len(node.Content); i += 2 { job, iss := parseJob(node.Content[i].Value, node.Content[i+1]) issues = append(issues, iss...) if job.job.Name != "" { jobs = append(jobs, job) } } return jobs, issues } func parseJob(name string, node *yaml.Node) (draft, []Issue) { d := draft{present: map[string]bool{}, line: node.Line, job: Job{Name: name, Variables: map[string]string{}}} if node.Kind != yaml.MappingNode { return d, []Issue{{Line: node.Line, Key: "ci.err.jobMap", Args: []any{name}}} } var issues []Issue for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] d.present[key] = true switch key { case "stage": if val.Kind != yaml.ScalarNode { issues = append(issues, Issue{Line: val.Line, Key: "ci.err.stageText"}) continue } d.job.Stage = val.Value case "image": img, iss := imageOf(val) issues = append(issues, iss...) d.job.Image = img case "before_script": lines, iss := scriptList(val) issues = append(issues, iss...) d.job.Before = lines case "script": lines, iss := scriptList(val) issues = append(issues, iss...) d.job.Script = lines case "after_script": lines, iss := scriptList(val) issues = append(issues, iss...) d.job.After = lines case "needs": needs, optional, set, iss := parseNeeds(val) issues = append(issues, iss...) d.job.Needs = needs d.job.Optional = optional d.job.NeedsSet = set case "variables": vars, iss := scalarMap(val) issues = append(issues, iss...) d.job.Variables = vars case "artifacts": art, iss := parseArtifacts(val) issues = append(issues, iss...) d.job.Artifacts = art case "rules": rules, iss := parseRules(val) issues = append(issues, iss...) d.job.Rules = rules case "allow_failure": b, iss := parseBool(val) issues = append(issues, iss...) d.job.AllowFailure = b case "when": w, iss := whenOf(val, false) issues = append(issues, iss...) d.job.When = w case "timeout": dur, iss := durationOf(val) issues = append(issues, iss...) d.job.Timeout = dur case "tags": tags, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) d.job.Tags = tags case "cache": c, iss := parseCache(val) issues = append(issues, iss...) d.job.Cache = c case "resource_group": if val.Kind != yaml.ScalarNode || strings.TrimSpace(val.Value) == "" { issues = append(issues, Issue{Line: val.Line, Key: "ci.err.resource"}) continue } d.job.ResourceGroup = strings.TrimSpace(val.Value) case "only": list, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) d.job.Only = list case "except": list, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) d.job.Except = list case "extends": list, iss := extendsOf(val) issues = append(issues, iss...) d.extends = list case "retry": retry, iss := parseRetry(val) issues = append(issues, iss...) d.job.Retry = retry case "parallel": n, matrix, iss := parseParallel(val) issues = append(issues, iss...) d.job.Parallel = n d.job.Matrix = matrix case "services": svcs, iss := parseServices(val) issues = append(issues, iss...) d.job.Services = svcs case "environment": env, iss := parseEnvironment(val) issues = append(issues, iss...) d.job.Environment = env case "interruptible": b, iss := parseBool(val) issues = append(issues, iss...) d.job.Interruptible = b default: if _, ok := reserved[key]; ok { issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{key}, Warning: true}) continue } issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{name + "." + key}, Warning: true}) } } return d, issues } func applyExtends(jobs []draft, def draft) ([]draft, []Issue) { by := map[string]*draft{} var order []string var issues []Issue for i := range jobs { name := jobs[i].job.Name if by[name] != nil { issues = append(issues, Issue{Line: jobs[i].line, Key: "ci.err.jobDup", Args: []any{name}}) continue } by[name] = &jobs[i] order = append(order, name) } visiting := map[string]bool{} var walk func(string) walk = func(name string) { d := by[name] if d == nil || d.present["__resolved"] { return } if visiting[name] { issues = append(issues, Issue{Line: d.line, Key: "ci.err.extendsCycle", Args: []any{name}}) return } visiting[name] = true for _, parent := range d.extends { base := by[parent] if base == nil { issues = append(issues, Issue{Line: d.line, Key: "ci.err.extends", Args: []any{name, parent}}) continue } walk(parent) inherit(d, base) } delete(visiting, name) d.present["__resolved"] = true inherit(d, &def) } for _, name := range order { walk(name) } return jobs, issues } func inherit(child, parent *draft) { if parent == nil { return } copyField := func(key string, apply func()) { if child.present[key] || !parent.present[key] { return } apply() child.present[key] = true } copyField("stage", func() { child.job.Stage = parent.job.Stage }) copyField("image", func() { child.job.Image = parent.job.Image }) copyField("before_script", func() { child.job.Before = parent.job.Before }) copyField("script", func() { child.job.Script = parent.job.Script }) copyField("after_script", func() { child.job.After = parent.job.After }) copyField("needs", func() { child.job.Needs = parent.job.Needs child.job.Optional = parent.job.Optional child.job.NeedsSet = parent.job.NeedsSet }) copyField("artifacts", func() { child.job.Artifacts = parent.job.Artifacts }) copyField("rules", func() { child.job.Rules = parent.job.Rules }) copyField("allow_failure", func() { child.job.AllowFailure = parent.job.AllowFailure }) copyField("when", func() { child.job.When = parent.job.When }) copyField("timeout", func() { child.job.Timeout = parent.job.Timeout }) copyField("tags", func() { child.job.Tags = parent.job.Tags }) copyField("cache", func() { child.job.Cache = parent.job.Cache }) copyField("resource_group", func() { child.job.ResourceGroup = parent.job.ResourceGroup }) copyField("only", func() { child.job.Only = parent.job.Only }) copyField("except", func() { child.job.Except = parent.job.Except }) copyField("retry", func() { child.job.Retry = parent.job.Retry }) copyField("parallel", func() { child.job.Parallel = parent.job.Parallel child.job.Matrix = parent.job.Matrix }) copyField("services", func() { child.job.Services = parent.job.Services }) copyField("environment", func() { child.job.Environment = parent.job.Environment }) copyField("interruptible", func() { child.job.Interruptible = parent.job.Interruptible }) if len(parent.job.Variables) > 0 { merged := map[string]string{} for k, v := range parent.job.Variables { merged[k] = v } for k, v := range child.job.Variables { merged[k] = v } child.job.Variables = merged } } func validate(p *Pipeline) []Issue { var issues []Issue if len(p.Jobs) == 0 { return []Issue{{Line: 1, Key: "ci.err.noJobs"}} } seenStage := map[string]bool{} for _, s := range p.Stages { if s == "" { issues = append(issues, Issue{Line: 1, Key: "ci.err.stageEmpty"}) continue } if seenStage[s] { issues = append(issues, Issue{Line: 1, Key: "ci.err.stageDup", Args: []any{s}}) } seenStage[s] = true } if len(p.Stages) == 0 { var order []string for i := range p.Jobs { if p.Jobs[i].Stage == "" { p.Jobs[i].Stage = "test" } if !seenStage[p.Jobs[i].Stage] { seenStage[p.Jobs[i].Stage] = true order = append(order, p.Jobs[i].Stage) } } p.Stages = order } names := map[string]bool{} for i := range p.Jobs { j := &p.Jobs[i] if j.Name == "" || strings.ContainsAny(j.Name, " \t\n/\\") { issues = append(issues, Issue{Line: 1, Key: "ci.err.jobName", Args: []any{j.Name}}) continue } names[j.Name] = true if j.Stage == "" { issues = append(issues, Issue{Line: 1, Key: "ci.err.jobStage", Args: []any{j.Name}}) } else if !seenStage[j.Stage] { issues = append(issues, Issue{Line: 1, Key: "ci.err.stageUnknown", Args: []any{j.Name, j.Stage}}) } if j.Image == "" { j.Image = p.Image } if strings.TrimSpace(j.Image) == "" || strings.ContainsAny(j.Image, " \t\n") { issues = append(issues, Issue{Line: 1, Key: "ci.err.noImage", Args: []any{j.Name}}) } if len(j.Script) == 0 { issues = append(issues, Issue{Line: 1, Key: "ci.err.noScript", Args: []any{j.Name}}) } for _, line := range j.Script { if strings.TrimSpace(line) == "" { issues = append(issues, Issue{Line: 1, Key: "ci.err.emptyLine", Args: []any{j.Name}}) } } for _, path := range j.Artifacts.Paths { if iss := safeRel(path); iss.Key != "" { issues = append(issues, iss) } } for _, path := range j.Cache.Paths { if iss := safeRel(path); iss.Key != "" { issues = append(issues, iss) } } if j.When == "" { j.When = "on_success" } } for _, j := range p.Jobs { for _, need := range j.Needs { if !names[need] && !contains(j.Optional, need) { issues = append(issues, Issue{Line: 1, Key: "ci.err.needUnknown", Args: []any{j.Name, need}}) } if need == j.Name { issues = append(issues, Issue{Line: 1, Key: "ci.err.needSelf", Args: []any{j.Name}}) } } } if iss := detectCycles(p.Jobs); iss.Key != "" { issues = append(issues, iss) } return issues } func detectCycles(jobs []Job) Issue { idx := map[string]int{} for i, j := range jobs { idx[j.Name] = i } const ( white = 0 gray = 1 black = 2 ) color := make([]int, len(jobs)) var visit func(int) Issue visit = func(i int) Issue { if color[i] == gray { return Issue{Line: 1, Key: "ci.err.cycle", Args: []any{jobs[i].Name}} } if color[i] == black { return Issue{} } color[i] = gray for _, n := range jobs[i].Needs { target, ok := idx[n] if !ok { continue } if iss := visit(target); iss.Key != "" { return iss } } color[i] = black return Issue{} } for i := range jobs { if iss := visit(i); iss.Key != "" { return iss } } return Issue{} } func parseArtifacts(node *yaml.Node) (Artifacts, []Issue) { if node.Kind != yaml.MappingNode { return Artifacts{}, []Issue{{Line: node.Line, Key: "ci.err.artifacts"}} } var a Artifacts var issues []Issue for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] switch key { case "paths": paths, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) a.Paths = paths case "expire_in": if val.Kind != yaml.ScalarNode { issues = append(issues, Issue{Line: val.Line, Key: "ci.err.expire"}) continue } d, err := parseExpire(val.Value) if err != nil { issues = append(issues, Issue{Line: val.Line, Key: "ci.err.expireBad", Args: []any{val.Value}}) continue } a.ExpireIn = d default: issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"artifacts." + key}, Warning: true}) } } return a, issues } func parseCache(node *yaml.Node) (Cache, []Issue) { if node.Kind != yaml.MappingNode { return Cache{}, []Issue{{Line: node.Line, Key: "ci.err.cache"}} } var c Cache var issues []Issue for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] switch key { case "paths": paths, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) c.Paths = paths case "key": if val.Kind != yaml.ScalarNode { issues = append(issues, Issue{Line: val.Line, Key: "ci.err.cacheKey"}) continue } c.Key = val.Value default: issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"cache." + key}, Warning: true}) } } return c, issues } func parseRules(node *yaml.Node) ([]Rule, []Issue) { if node.Kind != yaml.SequenceNode { return nil, []Issue{{Line: node.Line, Key: "ci.err.rulesList"}} } var rules []Rule var issues []Issue for _, item := range node.Content { if item.Kind != yaml.MappingNode { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.ruleMap"}) continue } var r Rule for i := 0; i < len(item.Content); i += 2 { key := item.Content[i].Value val := item.Content[i+1] switch key { case "if": if val.Kind != yaml.ScalarNode || strings.TrimSpace(val.Value) == "" { issues = append(issues, Issue{Line: val.Line, Key: "ci.err.ruleIf"}) continue } r.If = strings.TrimSpace(val.Value) if err := checkRule(r.If); err != nil { if ie, ok := err.(i18n.Error); ok { issues = append(issues, Issue{Line: val.Line, Key: ie.Key, Args: ie.Args}) } else { issues = append(issues, Issue{Line: val.Line, Key: "ci.err.ruleExpr", Args: []any{r.If}}) } } case "changes": list, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) r.Changes = list case "exists": list, iss := scalarList(val, "ci.err.list") issues = append(issues, iss...) r.Exists = list case "when": w, iss := whenOf(val, true) issues = append(issues, iss...) r.When = w default: issues = append(issues, Issue{Line: item.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"rules." + key}, Warning: true}) } } if r.If == "" && len(r.Changes) == 0 && len(r.Exists) == 0 && r.When == "" { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.ruleEmpty"}) continue } rules = append(rules, r) } return rules, issues } func parseNeeds(node *yaml.Node) (needs, optional []string, set bool, issues []Issue) { set = true if node.Kind != yaml.SequenceNode { return nil, nil, true, []Issue{{Line: node.Line, Key: "ci.err.needs"}} } for _, item := range node.Content { switch item.Kind { case yaml.ScalarNode: needs = append(needs, item.Value) case yaml.MappingNode: var name string var opt bool for i := 0; i < len(item.Content); i += 2 { switch item.Content[i].Value { case "job": if item.Content[i+1].Kind == yaml.ScalarNode { name = item.Content[i+1].Value } case "optional": b, iss := parseBool(item.Content[i+1]) issues = append(issues, iss...) opt = b default: issues = append(issues, Issue{Line: item.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"needs." + item.Content[i].Value}, Warning: true}) } } if name == "" { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.needs"}) continue } needs = append(needs, name) if opt { optional = append(optional, name) } default: issues = append(issues, Issue{Line: item.Line, Key: "ci.err.needs"}) } } if needs == nil { needs = []string{} } return needs, optional, set, issues } func imageOf(node *yaml.Node) (string, []Issue) { switch node.Kind { case yaml.ScalarNode: return node.Value, nil case yaml.MappingNode: for i := 0; i < len(node.Content); i += 2 { if node.Content[i].Value == "name" && node.Content[i+1].Kind == yaml.ScalarNode { return node.Content[i+1].Value, nil } } return "", []Issue{{Line: node.Line, Key: "ci.err.image"}} default: return "", []Issue{{Line: node.Line, Key: "ci.err.image"}} } } func whenOf(node *yaml.Node, allowNever bool) (string, []Issue) { if node.Kind != yaml.ScalarNode { return "", []Issue{{Line: node.Line, Key: "ci.err.when", Args: []any{""}}} } switch node.Value { case "on_success", "on_failure", "always", "manual": return node.Value, nil case "never": if allowNever { return node.Value, nil } } return "", []Issue{{Line: node.Line, Key: "ci.err.when", Args: []any{node.Value}}} } func durationOf(node *yaml.Node) (time.Duration, []Issue) { if node.Kind != yaml.ScalarNode { return 0, []Issue{{Line: node.Line, Key: "ci.err.timeout", Args: []any{""}}} } d, err := parseExpire(node.Value) if err != nil { if strings.HasSuffix(node.Value, "s") { n, nerr := strconv.Atoi(strings.TrimSuffix(node.Value, "s")) if nerr == nil && n >= 0 { return time.Duration(n) * time.Second, nil } } return 0, []Issue{{Line: node.Line, Key: "ci.err.timeout", Args: []any{node.Value}}} } return d, nil } func extendsOf(node *yaml.Node) ([]string, []Issue) { if node.Kind == yaml.ScalarNode && strings.TrimSpace(node.Value) != "" { return []string{node.Value}, nil } return scalarList(node, "ci.err.extendsList") } func scriptList(node *yaml.Node) ([]string, []Issue) { if node.Kind == yaml.ScalarNode { if strings.TrimSpace(node.Value) == "" { return nil, []Issue{{Line: node.Line, Key: "ci.err.script"}} } return splitLines(node.Value), nil } return scalarList(node, "ci.err.script") } func splitLines(s string) []string { parts := strings.Split(s, "\n") var out []string for _, p := range parts { if strings.TrimSpace(p) == "" { continue } out = append(out, p) } return out } func scalarList(node *yaml.Node, key string) ([]string, []Issue) { if node.Kind != yaml.SequenceNode { return nil, []Issue{{Line: node.Line, Key: key}} } var out []string var issues []Issue for _, item := range node.Content { if item.Kind != yaml.ScalarNode { issues = append(issues, Issue{Line: item.Line, Key: "ci.err.listText"}) continue } out = append(out, item.Value) } return out, issues } func scalarMap(node *yaml.Node) (map[string]string, []Issue) { if node.Kind != yaml.MappingNode { return nil, []Issue{{Line: node.Line, Key: "ci.err.map"}} } out := map[string]string{} var issues []Issue for i := 0; i < len(node.Content); i += 2 { k := node.Content[i] v := node.Content[i+1] if k.Kind != yaml.ScalarNode { issues = append(issues, Issue{Line: k.Line, Key: "ci.err.varText"}) continue } switch v.Kind { case yaml.ScalarNode: out[k.Value] = v.Value case yaml.MappingNode: val, iss := mappingValue(v) issues = append(issues, iss...) if val != "" || len(iss) == 0 { out[k.Value] = val } default: issues = append(issues, Issue{Line: v.Line, Key: "ci.err.varText"}) } } return out, issues } func mappingValue(node *yaml.Node) (string, []Issue) { for i := 0; i < len(node.Content); i += 2 { if node.Content[i].Value == "value" && node.Content[i+1].Kind == yaml.ScalarNode { return node.Content[i+1].Value, nil } } return "", []Issue{{Line: node.Line, Key: "ci.err.varText"}} } func parseBool(node *yaml.Node) (bool, []Issue) { if node.Kind != yaml.ScalarNode { return false, []Issue{{Line: node.Line, Key: "ci.err.bool"}} } switch strings.ToLower(node.Value) { case "true", "yes": return true, nil case "false", "no": return false, nil default: return false, []Issue{{Line: node.Line, Key: "ci.err.bool"}} } } func parseExpire(s string) (time.Duration, error) { s = strings.TrimSpace(s) if s == "" || s == "never" { return 0, nil } if len(s) < 2 { return 0, fmt.Errorf("expire") } n, err := strconv.Atoi(s[:len(s)-1]) if err != nil || n < 0 { return 0, fmt.Errorf("expire") } switch s[len(s)-1] { case 's': return time.Duration(n) * time.Second, nil case 'm': return time.Duration(n) * time.Minute, nil case 'h': return time.Duration(n) * time.Hour, nil case 'd': return time.Duration(n) * 24 * time.Hour, nil case 'w': return time.Duration(n) * 7 * 24 * time.Hour, nil default: return 0, fmt.Errorf("expire") } } func safeRel(p string) Issue { if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, "\\") { return Issue{Line: 1, Key: "ci.err.rel", Args: []any{p}} } for _, part := range strings.Split(p, "/") { if part == ".." { return Issue{Line: 1, Key: "ci.err.dotdot", Args: []any{p}} } } return Issue{} } func hasError(issues []Issue) bool { for _, is := range issues { if !is.Warning { return true } } return false }