BlueGit

timfa bluegit

Files

bluegit / internal / ci / parse.go

parse.go

parse.go 32.6 KiB Download Raw
1// Package ci leest blue-ci-cd.yml en bepaalt welke jobs draaien.
2// De vorm volgt GitLab CI waar dat in BlueGit past. Een oud bestand met
3// een jobs:-map blijft geldig. Jobs mogen ook los op het hoogste niveau staan.
4package ci
5
6import (
7 "errors"
8 "fmt"
9 "strconv"
10 "strings"
11 "time"
12
13 "gitlab.com/Timfa/bluegit/internal/i18n"
14 "gopkg.in/yaml.v3"
15)
16
17// Parse leest YAML. Jobvolgorde blijft de volgorde uit het bestand.
18func Parse(data []byte) (Pipeline, error) {
19 return ParseIn(data, nil)
20}
21
22// ParseIn leest YAML en haalt include: local via read op.
23func ParseIn(data []byte, read func(string) ([]byte, error)) (Pipeline, error) {
24 p, issues, err := parseBytes(data, read, nil)
25 if err != nil {
26 return Pipeline{}, err
27 }
28 for _, is := range issues {
29 if !is.Warning {
30 return Pipeline{}, is
31 }
32 }
33 p.Warnings = warningsOnly(issues)
34 return p, nil
35}
36
37// Lint geeft elke fout en waarschuwing, met regelnummer, zonder te stoppen bij de eerste.
38func Lint(data []byte, read func(string) ([]byte, error)) (Pipeline, []Issue) {
39 p, issues, err := parseBytes(data, read, nil)
40 if err != nil {
41 // parseBytes verpakt een YAML-fout al als ci.err.yaml. Nog eens
42 // verpakken geeft "invalid YAML: invalid YAML: ...".
43 line := Issue{Line: 1, Key: "ci.err.yaml", Args: []any{err.Error()}}
44 var ie i18n.Error
45 if errors.As(err, &ie) {
46 line.Key, line.Args = ie.Key, ie.Args
47 }
48 issues = append([]Issue{line}, issues...)
49 }
50 return p, issues
51}
52
53func (i Issue) Error() string { return i18n.T(i18n.EN, i.Key, i.Args...) }
54
55func warningsOnly(in []Issue) []Issue {
56 var out []Issue
57 for _, is := range in {
58 if is.Warning {
59 out = append(out, is)
60 }
61 }
62 return out
63}
64
65var reserved = map[string]bool{
66 "stages": true, "variables": true, "image": true, "default": true,
67 "include": true, "before_script": true, "after_script": true, "cache": true,
68 "workflow": true, "services": true, "spec": true, "pages": true, "jobs": true,
69}
70
71type draft struct {
72 job Job
73 present map[string]bool
74 extends []string
75 line int
76}
77
78func parseBytes(data []byte, read func(string) ([]byte, error), stack []string) (Pipeline, []Issue, error) {
79 var root yaml.Node
80 if err := yaml.Unmarshal(data, &root); err != nil {
81 return Pipeline{}, nil, i18n.E("ci.err.yaml", err.Error())
82 }
83 // Een leeg document of alleen commentaar is een pipeline zonder jobs.
84 // Een echte mapping, ook een lege zoals {}, blijft door validate gaan.
85 if root.Kind == 0 || len(root.Content) == 0 {
86 return Pipeline{Variables: map[string]string{}}, nil, nil
87 }
88 if root.Kind != yaml.DocumentNode || len(root.Content) != 1 || root.Content[0].Kind != yaml.MappingNode {
89 return Pipeline{}, []Issue{{Line: 1, Key: "ci.err.mapping"}}, nil
90 }
91 body := root.Content[0]
92 var included Pipeline
93 var issues []Issue
94 for i := 0; i < len(body.Content); i += 2 {
95 if body.Content[i].Value != "include" {
96 continue
97 }
98 part, more, err := parseInclude(body.Content[i+1], read, stack)
99 if err != nil {
100 return Pipeline{}, nil, err
101 }
102 issues = append(issues, more...)
103 included = mergePipeline(included, part)
104 }
105 p := included
106 if p.Variables == nil {
107 p.Variables = map[string]string{}
108 }
109 var def draft
110 def.present = map[string]bool{}
111 var jobs []draft
112 seenLegacy := false
113 seenTop := false
114 for i := 0; i < len(body.Content); i += 2 {
115 keyNode := body.Content[i]
116 key := keyNode.Value
117 val := body.Content[i+1]
118 switch key {
119 case "include":
120 continue
121 case "stages":
122 stages, iss := scalarList(val, "ci.err.list")
123 issues = append(issues, iss...)
124 if len(stages) > 0 {
125 p.Stages = stages
126 }
127 case "variables":
128 vars, iss := scalarMap(val)
129 issues = append(issues, iss...)
130 for k, v := range vars {
131 p.Variables[k] = v
132 }
133 case "image":
134 img, iss := imageOf(val)
135 issues = append(issues, iss...)
136 if img != "" {
137 p.Image = img
138 }
139 case "before_script":
140 lines, iss := scriptList(val)
141 issues = append(issues, iss...)
142 p.Before = lines
143 def.present["before_script"] = true
144 def.job.Before = lines
145 case "after_script":
146 lines, iss := scriptList(val)
147 issues = append(issues, iss...)
148 p.After = lines
149 def.present["after_script"] = true
150 def.job.After = lines
151 case "cache":
152 c, iss := parseCache(val)
153 issues = append(issues, iss...)
154 p.Cache = c
155 def.present["cache"] = true
156 def.job.Cache = c
157 case "default":
158 d, iss := parseDefault(val)
159 issues = append(issues, iss...)
160 def = overlayDefault(def, d)
161 case "workflow":
162 rules, iss := parseWorkflow(val)
163 issues = append(issues, iss...)
164 p.Workflow = rules
165 case "services", "spec", "pages":
166 issues = append(issues, Issue{Line: keyNode.Line, Key: "ci.warn.ignored", Args: []any{key}, Warning: true})
167 case "jobs":
168 seenLegacy = true
169 parsed, iss := parseJobMap(val)
170 issues = append(issues, iss...)
171 jobs = append(jobs, parsed...)
172 default:
173 if val.Kind != yaml.MappingNode {
174 issues = append(issues, Issue{Line: keyNode.Line, Key: "ci.err.unknown", Args: []any{key}})
175 continue
176 }
177 seenTop = true
178 job, iss := parseJob(key, val)
179 issues = append(issues, iss...)
180 jobs = append(jobs, job)
181 }
182 }
183 if seenLegacy && seenTop {
184 issues = append(issues, Issue{Line: 1, Key: "ci.err.both"})
185 }
186 if p.Image != "" && !def.present["image"] {
187 def.present["image"] = true
188 def.job.Image = p.Image
189 }
190 resolved, iss := applyExtends(jobs, def)
191 issues = append(issues, iss...)
192 byName := map[string]int{}
193 var merged []Job
194 for _, j := range p.Jobs {
195 byName[j.Name] = len(merged)
196 merged = append(merged, j)
197 }
198 for _, d := range resolved {
199 if strings.HasPrefix(d.job.Name, ".") {
200 continue
201 }
202 if i, ok := byName[d.job.Name]; ok {
203 merged[i] = overlayJob(merged[i], d)
204 continue
205 }
206 byName[d.job.Name] = len(merged)
207 merged = append(merged, d.job)
208 }
209 p.Jobs = merged
210 issues = append(issues, validate(&p)...)
211 if hasError(issues) {
212 return p, issues, nil
213 }
214 return p, issues, nil
215}
216
217func parseInclude(node *yaml.Node, read func(string) ([]byte, error), stack []string) (Pipeline, []Issue, error) {
218 var items []*yaml.Node
219 switch node.Kind {
220 case yaml.SequenceNode:
221 items = node.Content
222 default:
223 items = []*yaml.Node{node}
224 }
225 var out Pipeline
226 var issues []Issue
227 for _, item := range items {
228 local, iss := includeLocal(item)
229 issues = append(issues, iss...)
230 if local == "" {
231 continue
232 }
233 if read == nil {
234 issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeRead", Args: []any{local}})
235 continue
236 }
237 for _, prev := range stack {
238 if prev == local {
239 issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeCycle", Args: []any{local}})
240 local = ""
241 break
242 }
243 }
244 if local == "" {
245 continue
246 }
247 raw, err := read(local)
248 if err != nil {
249 issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeRead", Args: []any{local}})
250 continue
251 }
252 part, more, err := parseBytes(raw, read, append(append([]string{}, stack...), local))
253 if err != nil {
254 return Pipeline{}, nil, err
255 }
256 issues = append(issues, more...)
257 out = mergePipeline(out, part)
258 }
259 return out, issues, nil
260}
261
262func includeLocal(node *yaml.Node) (string, []Issue) {
263 switch node.Kind {
264 case yaml.ScalarNode:
265 return cleanLocal(node.Value, node)
266 case yaml.MappingNode:
267 for i := 0; i < len(node.Content); i += 2 {
268 key := node.Content[i].Value
269 if key == "local" {
270 if node.Content[i+1].Kind != yaml.ScalarNode {
271 return "", []Issue{{Line: node.Line, Key: "ci.err.includeLocal"}}
272 }
273 return cleanLocal(node.Content[i+1].Value, node.Content[i+1])
274 }
275 }
276 return "", []Issue{{Line: node.Line, Key: "ci.err.includeRemote"}}
277 default:
278 return "", []Issue{{Line: node.Line, Key: "ci.err.includeLocal"}}
279 }
280}
281
282func cleanLocal(p string, node *yaml.Node) (string, []Issue) {
283 p = strings.TrimPrefix(strings.TrimSpace(p), "/")
284 if p == "" || strings.Contains(p, "\\") || strings.Contains(p, "..") {
285 return "", []Issue{{Line: node.Line, Key: "ci.err.rel", Args: []any{p}}}
286 }
287 return p, nil
288}
289
290func mergePipeline(base, extra Pipeline) Pipeline {
291 if len(extra.Stages) > 0 {
292 base.Stages = extra.Stages
293 }
294 if base.Variables == nil {
295 base.Variables = map[string]string{}
296 }
297 for k, v := range extra.Variables {
298 base.Variables[k] = v
299 }
300 if extra.Image != "" {
301 base.Image = extra.Image
302 }
303 if extra.Before != nil {
304 base.Before = extra.Before
305 }
306 if extra.After != nil {
307 base.After = extra.After
308 }
309 byName := map[string]int{}
310 for i, j := range base.Jobs {
311 byName[j.Name] = i
312 }
313 for _, j := range extra.Jobs {
314 if i, ok := byName[j.Name]; ok {
315 base.Jobs[i] = j
316 continue
317 }
318 byName[j.Name] = len(base.Jobs)
319 base.Jobs = append(base.Jobs, j)
320 }
321 return base
322}
323
324func parseDefault(node *yaml.Node) (draft, []Issue) {
325 d := draft{present: map[string]bool{}}
326 if node.Kind != yaml.MappingNode {
327 return d, []Issue{{Line: node.Line, Key: "ci.err.map"}}
328 }
329 var issues []Issue
330 for i := 0; i < len(node.Content); i += 2 {
331 key := node.Content[i].Value
332 val := node.Content[i+1]
333 switch key {
334 case "image":
335 img, iss := imageOf(val)
336 issues = append(issues, iss...)
337 d.job.Image = img
338 d.present["image"] = true
339 case "before_script":
340 lines, iss := scriptList(val)
341 issues = append(issues, iss...)
342 d.job.Before = lines
343 d.present["before_script"] = true
344 case "after_script":
345 lines, iss := scriptList(val)
346 issues = append(issues, iss...)
347 d.job.After = lines
348 d.present["after_script"] = true
349 case "tags":
350 tags, iss := scalarList(val, "ci.err.list")
351 issues = append(issues, iss...)
352 d.job.Tags = tags
353 d.present["tags"] = true
354 case "timeout":
355 dur, iss := durationOf(val)
356 issues = append(issues, iss...)
357 d.job.Timeout = dur
358 d.present["timeout"] = true
359 case "retry":
360 retry, iss := parseRetry(val)
361 issues = append(issues, iss...)
362 d.job.Retry = retry
363 d.present["retry"] = true
364 case "interruptible":
365 b, iss := parseBool(val)
366 issues = append(issues, iss...)
367 d.job.Interruptible = b
368 d.present["interruptible"] = true
369 case "doNotInterrupt":
370 b, iss := parseBool(val)
371 issues = append(issues, iss...)
372 d.job.DoNotInterrupt = b
373 d.present["doNotInterrupt"] = true
374 case "cache":
375 c, iss := parseCache(val)
376 issues = append(issues, iss...)
377 d.job.Cache = c
378 d.present["cache"] = true
379 default:
380 issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"default." + key}, Warning: true})
381 }
382 }
383 return d, issues
384}
385
386func overlayJob(base Job, d draft) Job {
387 set := func(key string, apply func()) {
388 if d.present[key] {
389 apply()
390 }
391 }
392 set("stage", func() { base.Stage = d.job.Stage })
393 set("image", func() { base.Image = d.job.Image })
394 set("before_script", func() { base.Before = d.job.Before })
395 set("script", func() { base.Script = d.job.Script })
396 set("after_script", func() { base.After = d.job.After })
397 set("needs", func() {
398 base.Needs = d.job.Needs
399 base.Optional = d.job.Optional
400 base.NeedsSet = d.job.NeedsSet
401 })
402 set("artifacts", func() { base.Artifacts = d.job.Artifacts })
403 set("rules", func() { base.Rules = d.job.Rules })
404 set("allow_failure", func() { base.AllowFailure = d.job.AllowFailure })
405 set("when", func() { base.When = d.job.When })
406 set("timeout", func() { base.Timeout = d.job.Timeout })
407 set("tags", func() { base.Tags = d.job.Tags })
408 set("cache", func() { base.Cache = d.job.Cache })
409 set("resource_group", func() { base.ResourceGroup = d.job.ResourceGroup })
410 set("only", func() { base.Only = d.job.Only })
411 set("except", func() { base.Except = d.job.Except })
412 set("retry", func() { base.Retry = d.job.Retry })
413 set("parallel", func() {
414 base.Parallel = d.job.Parallel
415 base.Matrix = d.job.Matrix
416 })
417 set("services", func() { base.Services = d.job.Services })
418 set("environment", func() { base.Environment = d.job.Environment })
419 set("interruptible", func() { base.Interruptible = d.job.Interruptible })
420 set("doNotInterrupt", func() { base.DoNotInterrupt = d.job.DoNotInterrupt })
421 if d.present["variables"] {
422 mergedVars := map[string]string{}
423 for k, v := range base.Variables {
424 mergedVars[k] = v
425 }
426 for k, v := range d.job.Variables {
427 mergedVars[k] = v
428 }
429 base.Variables = mergedVars
430 }
431 return base
432}
433
434func overlayDefault(base, extra draft) draft {
435 if base.present == nil {
436 base.present = map[string]bool{}
437 }
438 for k, on := range extra.present {
439 if !on {
440 continue
441 }
442 base.present[k] = true
443 switch k {
444 case "image":
445 base.job.Image = extra.job.Image
446 case "before_script":
447 base.job.Before = extra.job.Before
448 case "after_script":
449 base.job.After = extra.job.After
450 case "tags":
451 base.job.Tags = extra.job.Tags
452 case "timeout":
453 base.job.Timeout = extra.job.Timeout
454 case "cache":
455 base.job.Cache = extra.job.Cache
456 case "retry":
457 base.job.Retry = extra.job.Retry
458 case "interruptible":
459 base.job.Interruptible = extra.job.Interruptible
460 case "doNotInterrupt":
461 base.job.DoNotInterrupt = extra.job.DoNotInterrupt
462 }
463 }
464 return base
465}
466
467func parseJobMap(node *yaml.Node) ([]draft, []Issue) {
468 if node.Kind != yaml.MappingNode {
469 return nil, []Issue{{Line: node.Line, Key: "ci.err.jobsMap"}}
470 }
471 var jobs []draft
472 var issues []Issue
473 for i := 0; i < len(node.Content); i += 2 {
474 job, iss := parseJob(node.Content[i].Value, node.Content[i+1])
475 issues = append(issues, iss...)
476 if job.job.Name != "" {
477 jobs = append(jobs, job)
478 }
479 }
480 return jobs, issues
481}
482
483func parseJob(name string, node *yaml.Node) (draft, []Issue) {
484 d := draft{present: map[string]bool{}, line: node.Line, job: Job{Name: name, Variables: map[string]string{}}}
485 if node.Kind != yaml.MappingNode {
486 return d, []Issue{{Line: node.Line, Key: "ci.err.jobMap", Args: []any{name}}}
487 }
488 var issues []Issue
489 for i := 0; i < len(node.Content); i += 2 {
490 key := node.Content[i].Value
491 val := node.Content[i+1]
492 d.present[key] = true
493 switch key {
494 case "stage":
495 if val.Kind != yaml.ScalarNode {
496 issues = append(issues, Issue{Line: val.Line, Key: "ci.err.stageText"})
497 continue
498 }
499 d.job.Stage = val.Value
500 case "image":
501 img, iss := imageOf(val)
502 issues = append(issues, iss...)
503 d.job.Image = img
504 case "before_script":
505 lines, iss := scriptList(val)
506 issues = append(issues, iss...)
507 d.job.Before = lines
508 case "script":
509 lines, iss := scriptList(val)
510 issues = append(issues, iss...)
511 d.job.Script = lines
512 case "after_script":
513 lines, iss := scriptList(val)
514 issues = append(issues, iss...)
515 d.job.After = lines
516 case "needs":
517 needs, optional, set, iss := parseNeeds(val)
518 issues = append(issues, iss...)
519 d.job.Needs = needs
520 d.job.Optional = optional
521 d.job.NeedsSet = set
522 case "variables":
523 vars, iss := scalarMap(val)
524 issues = append(issues, iss...)
525 d.job.Variables = vars
526 case "artifacts":
527 art, iss := parseArtifacts(val)
528 issues = append(issues, iss...)
529 d.job.Artifacts = art
530 case "rules":
531 rules, iss := parseRules(val)
532 issues = append(issues, iss...)
533 d.job.Rules = rules
534 case "allow_failure":
535 b, iss := parseBool(val)
536 issues = append(issues, iss...)
537 d.job.AllowFailure = b
538 case "when":
539 w, iss := whenOf(val, false)
540 issues = append(issues, iss...)
541 d.job.When = w
542 case "timeout":
543 dur, iss := durationOf(val)
544 issues = append(issues, iss...)
545 d.job.Timeout = dur
546 case "tags":
547 tags, iss := scalarList(val, "ci.err.list")
548 issues = append(issues, iss...)
549 d.job.Tags = tags
550 case "cache":
551 c, iss := parseCache(val)
552 issues = append(issues, iss...)
553 d.job.Cache = c
554 case "resource_group":
555 if val.Kind != yaml.ScalarNode || strings.TrimSpace(val.Value) == "" {
556 issues = append(issues, Issue{Line: val.Line, Key: "ci.err.resource"})
557 continue
558 }
559 d.job.ResourceGroup = strings.TrimSpace(val.Value)
560 case "only":
561 list, iss := scalarList(val, "ci.err.list")
562 issues = append(issues, iss...)
563 d.job.Only = list
564 case "except":
565 list, iss := scalarList(val, "ci.err.list")
566 issues = append(issues, iss...)
567 d.job.Except = list
568 case "extends":
569 list, iss := extendsOf(val)
570 issues = append(issues, iss...)
571 d.extends = list
572 case "retry":
573 retry, iss := parseRetry(val)
574 issues = append(issues, iss...)
575 d.job.Retry = retry
576 case "parallel":
577 n, matrix, iss := parseParallel(val)
578 issues = append(issues, iss...)
579 d.job.Parallel = n
580 d.job.Matrix = matrix
581 case "services":
582 svcs, iss := parseServices(val)
583 issues = append(issues, iss...)
584 d.job.Services = svcs
585 case "environment":
586 env, iss := parseEnvironment(val)
587 issues = append(issues, iss...)
588 d.job.Environment = env
589 case "interruptible":
590 b, iss := parseBool(val)
591 issues = append(issues, iss...)
592 d.job.Interruptible = b
593 case "doNotInterrupt":
594 b, iss := parseBool(val)
595 issues = append(issues, iss...)
596 d.job.DoNotInterrupt = b
597 default:
598 if _, ok := reserved[key]; ok {
599 issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{key}, Warning: true})
600 continue
601 }
602 issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{name + "." + key}, Warning: true})
603 }
604 }
605 return d, issues
606}
607
608func applyExtends(jobs []draft, def draft) ([]draft, []Issue) {
609 by := map[string]*draft{}
610 var order []string
611 var issues []Issue
612 for i := range jobs {
613 name := jobs[i].job.Name
614 if by[name] != nil {
615 issues = append(issues, Issue{Line: jobs[i].line, Key: "ci.err.jobDup", Args: []any{name}})
616 continue
617 }
618 by[name] = &jobs[i]
619 order = append(order, name)
620 }
621 visiting := map[string]bool{}
622 var walk func(string)
623 walk = func(name string) {
624 d := by[name]
625 if d == nil || d.present["__resolved"] {
626 return
627 }
628 if visiting[name] {
629 issues = append(issues, Issue{Line: d.line, Key: "ci.err.extendsCycle", Args: []any{name}})
630 return
631 }
632 visiting[name] = true
633 for _, parent := range d.extends {
634 base := by[parent]
635 if base == nil {
636 issues = append(issues, Issue{Line: d.line, Key: "ci.err.extends", Args: []any{name, parent}})
637 continue
638 }
639 walk(parent)
640 inherit(d, base)
641 }
642 delete(visiting, name)
643 d.present["__resolved"] = true
644 inherit(d, &def)
645 }
646 for _, name := range order {
647 walk(name)
648 }
649 return jobs, issues
650}
651
652func inherit(child, parent *draft) {
653 if parent == nil {
654 return
655 }
656 copyField := func(key string, apply func()) {
657 if child.present[key] || !parent.present[key] {
658 return
659 }
660 apply()
661 child.present[key] = true
662 }
663 copyField("stage", func() { child.job.Stage = parent.job.Stage })
664 copyField("image", func() { child.job.Image = parent.job.Image })
665 copyField("before_script", func() { child.job.Before = parent.job.Before })
666 copyField("script", func() { child.job.Script = parent.job.Script })
667 copyField("after_script", func() { child.job.After = parent.job.After })
668 copyField("needs", func() {
669 child.job.Needs = parent.job.Needs
670 child.job.Optional = parent.job.Optional
671 child.job.NeedsSet = parent.job.NeedsSet
672 })
673 copyField("artifacts", func() { child.job.Artifacts = parent.job.Artifacts })
674 copyField("rules", func() { child.job.Rules = parent.job.Rules })
675 copyField("allow_failure", func() { child.job.AllowFailure = parent.job.AllowFailure })
676 copyField("when", func() { child.job.When = parent.job.When })
677 copyField("timeout", func() { child.job.Timeout = parent.job.Timeout })
678 copyField("tags", func() { child.job.Tags = parent.job.Tags })
679 copyField("cache", func() { child.job.Cache = parent.job.Cache })
680 copyField("resource_group", func() { child.job.ResourceGroup = parent.job.ResourceGroup })
681 copyField("only", func() { child.job.Only = parent.job.Only })
682 copyField("except", func() { child.job.Except = parent.job.Except })
683 copyField("retry", func() { child.job.Retry = parent.job.Retry })
684 copyField("parallel", func() {
685 child.job.Parallel = parent.job.Parallel
686 child.job.Matrix = parent.job.Matrix
687 })
688 copyField("services", func() { child.job.Services = parent.job.Services })
689 copyField("environment", func() { child.job.Environment = parent.job.Environment })
690 copyField("interruptible", func() { child.job.Interruptible = parent.job.Interruptible })
691 copyField("doNotInterrupt", func() { child.job.DoNotInterrupt = parent.job.DoNotInterrupt })
692 if len(parent.job.Variables) > 0 {
693 merged := map[string]string{}
694 for k, v := range parent.job.Variables {
695 merged[k] = v
696 }
697 for k, v := range child.job.Variables {
698 merged[k] = v
699 }
700 child.job.Variables = merged
701 }
702}
703
704func validate(p *Pipeline) []Issue {
705 var issues []Issue
706 if len(p.Jobs) == 0 {
707 return []Issue{{Line: 1, Key: "ci.err.noJobs"}}
708 }
709 seenStage := map[string]bool{}
710 for _, s := range p.Stages {
711 if s == "" {
712 issues = append(issues, Issue{Line: 1, Key: "ci.err.stageEmpty"})
713 continue
714 }
715 if seenStage[s] {
716 issues = append(issues, Issue{Line: 1, Key: "ci.err.stageDup", Args: []any{s}})
717 }
718 seenStage[s] = true
719 }
720 if len(p.Stages) == 0 {
721 var order []string
722 for i := range p.Jobs {
723 if p.Jobs[i].Stage == "" {
724 p.Jobs[i].Stage = "test"
725 }
726 if !seenStage[p.Jobs[i].Stage] {
727 seenStage[p.Jobs[i].Stage] = true
728 order = append(order, p.Jobs[i].Stage)
729 }
730 }
731 p.Stages = order
732 }
733 names := map[string]bool{}
734 for i := range p.Jobs {
735 j := &p.Jobs[i]
736 if j.Name == "" || strings.ContainsAny(j.Name, " \t\n/\\") {
737 issues = append(issues, Issue{Line: 1, Key: "ci.err.jobName", Args: []any{j.Name}})
738 continue
739 }
740 names[j.Name] = true
741 if j.Stage == "" {
742 issues = append(issues, Issue{Line: 1, Key: "ci.err.jobStage", Args: []any{j.Name}})
743 } else if !seenStage[j.Stage] {
744 issues = append(issues, Issue{Line: 1, Key: "ci.err.stageUnknown", Args: []any{j.Name, j.Stage}})
745 }
746 if j.Image == "" {
747 j.Image = p.Image
748 }
749 if strings.TrimSpace(j.Image) == "" || strings.ContainsAny(j.Image, " \t\n") {
750 issues = append(issues, Issue{Line: 1, Key: "ci.err.noImage", Args: []any{j.Name}})
751 }
752 if len(j.Script) == 0 {
753 issues = append(issues, Issue{Line: 1, Key: "ci.err.noScript", Args: []any{j.Name}})
754 }
755 for _, line := range j.Script {
756 if strings.TrimSpace(line) == "" {
757 issues = append(issues, Issue{Line: 1, Key: "ci.err.emptyLine", Args: []any{j.Name}})
758 }
759 }
760 for _, path := range j.Artifacts.Paths {
761 if iss := safeRel(path); iss.Key != "" {
762 issues = append(issues, iss)
763 }
764 }
765 for _, path := range j.Cache.Paths {
766 if iss := safeRel(path); iss.Key != "" {
767 issues = append(issues, iss)
768 }
769 }
770 if j.When == "" {
771 j.When = "on_success"
772 }
773 }
774 for _, j := range p.Jobs {
775 for _, need := range j.Needs {
776 if !names[need] && !contains(j.Optional, need) {
777 issues = append(issues, Issue{Line: 1, Key: "ci.err.needUnknown", Args: []any{j.Name, need}})
778 }
779 if need == j.Name {
780 issues = append(issues, Issue{Line: 1, Key: "ci.err.needSelf", Args: []any{j.Name}})
781 }
782 }
783 }
784 if iss := detectCycles(p.Jobs); iss.Key != "" {
785 issues = append(issues, iss)
786 }
787 return issues
788}
789
790func detectCycles(jobs []Job) Issue {
791 idx := map[string]int{}
792 for i, j := range jobs {
793 idx[j.Name] = i
794 }
795 const (
796 white = 0
797 gray = 1
798 black = 2
799 )
800 color := make([]int, len(jobs))
801 var visit func(int) Issue
802 visit = func(i int) Issue {
803 if color[i] == gray {
804 return Issue{Line: 1, Key: "ci.err.cycle", Args: []any{jobs[i].Name}}
805 }
806 if color[i] == black {
807 return Issue{}
808 }
809 color[i] = gray
810 for _, n := range jobs[i].Needs {
811 target, ok := idx[n]
812 if !ok {
813 continue
814 }
815 if iss := visit(target); iss.Key != "" {
816 return iss
817 }
818 }
819 color[i] = black
820 return Issue{}
821 }
822 for i := range jobs {
823 if iss := visit(i); iss.Key != "" {
824 return iss
825 }
826 }
827 return Issue{}
828}
829
830func parseArtifacts(node *yaml.Node) (Artifacts, []Issue) {
831 if node.Kind != yaml.MappingNode {
832 return Artifacts{}, []Issue{{Line: node.Line, Key: "ci.err.artifacts"}}
833 }
834 var a Artifacts
835 var issues []Issue
836 for i := 0; i < len(node.Content); i += 2 {
837 key := node.Content[i].Value
838 val := node.Content[i+1]
839 switch key {
840 case "paths":
841 paths, iss := scalarList(val, "ci.err.list")
842 issues = append(issues, iss...)
843 a.Paths = paths
844 case "expire_in":
845 if val.Kind != yaml.ScalarNode {
846 issues = append(issues, Issue{Line: val.Line, Key: "ci.err.expire"})
847 continue
848 }
849 d, err := parseExpire(val.Value)
850 if err != nil {
851 issues = append(issues, Issue{Line: val.Line, Key: "ci.err.expireBad", Args: []any{val.Value}})
852 continue
853 }
854 a.ExpireIn = d
855 default:
856 issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"artifacts." + key}, Warning: true})
857 }
858 }
859 return a, issues
860}
861
862func parseCache(node *yaml.Node) (Cache, []Issue) {
863 if node.Kind != yaml.MappingNode {
864 return Cache{}, []Issue{{Line: node.Line, Key: "ci.err.cache"}}
865 }
866 var c Cache
867 var issues []Issue
868 for i := 0; i < len(node.Content); i += 2 {
869 key := node.Content[i].Value
870 val := node.Content[i+1]
871 switch key {
872 case "paths":
873 paths, iss := scalarList(val, "ci.err.list")
874 issues = append(issues, iss...)
875 c.Paths = paths
876 case "key":
877 if val.Kind != yaml.ScalarNode {
878 issues = append(issues, Issue{Line: val.Line, Key: "ci.err.cacheKey"})
879 continue
880 }
881 c.Key = val.Value
882 default:
883 issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"cache." + key}, Warning: true})
884 }
885 }
886 return c, issues
887}
888
889func parseRules(node *yaml.Node) ([]Rule, []Issue) {
890 if node.Kind != yaml.SequenceNode {
891 return nil, []Issue{{Line: node.Line, Key: "ci.err.rulesList"}}
892 }
893 var rules []Rule
894 var issues []Issue
895 for _, item := range node.Content {
896 if item.Kind != yaml.MappingNode {
897 issues = append(issues, Issue{Line: item.Line, Key: "ci.err.ruleMap"})
898 continue
899 }
900 var r Rule
901 for i := 0; i < len(item.Content); i += 2 {
902 key := item.Content[i].Value
903 val := item.Content[i+1]
904 switch key {
905 case "if":
906 if val.Kind != yaml.ScalarNode || strings.TrimSpace(val.Value) == "" {
907 issues = append(issues, Issue{Line: val.Line, Key: "ci.err.ruleIf"})
908 continue
909 }
910 r.If = strings.TrimSpace(val.Value)
911 if err := checkRule(r.If); err != nil {
912 if ie, ok := err.(i18n.Error); ok {
913 issues = append(issues, Issue{Line: val.Line, Key: ie.Key, Args: ie.Args})
914 } else {
915 issues = append(issues, Issue{Line: val.Line, Key: "ci.err.ruleExpr", Args: []any{r.If}})
916 }
917 }
918 case "changes":
919 list, iss := scalarList(val, "ci.err.list")
920 issues = append(issues, iss...)
921 r.Changes = list
922 case "exists":
923 list, iss := scalarList(val, "ci.err.list")
924 issues = append(issues, iss...)
925 r.Exists = list
926 case "when":
927 w, iss := whenOf(val, true)
928 issues = append(issues, iss...)
929 r.When = w
930 default:
931 issues = append(issues, Issue{Line: item.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"rules." + key}, Warning: true})
932 }
933 }
934 if r.If == "" && len(r.Changes) == 0 && len(r.Exists) == 0 && r.When == "" {
935 issues = append(issues, Issue{Line: item.Line, Key: "ci.err.ruleEmpty"})
936 continue
937 }
938 rules = append(rules, r)
939 }
940 return rules, issues
941}
942
943func parseNeeds(node *yaml.Node) (needs, optional []string, set bool, issues []Issue) {
944 set = true
945 if node.Kind != yaml.SequenceNode {
946 return nil, nil, true, []Issue{{Line: node.Line, Key: "ci.err.needs"}}
947 }
948 for _, item := range node.Content {
949 switch item.Kind {
950 case yaml.ScalarNode:
951 needs = append(needs, item.Value)
952 case yaml.MappingNode:
953 var name string
954 var opt bool
955 for i := 0; i < len(item.Content); i += 2 {
956 switch item.Content[i].Value {
957 case "job":
958 if item.Content[i+1].Kind == yaml.ScalarNode {
959 name = item.Content[i+1].Value
960 }
961 case "optional":
962 b, iss := parseBool(item.Content[i+1])
963 issues = append(issues, iss...)
964 opt = b
965 default:
966 issues = append(issues, Issue{Line: item.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"needs." + item.Content[i].Value}, Warning: true})
967 }
968 }
969 if name == "" {
970 issues = append(issues, Issue{Line: item.Line, Key: "ci.err.needs"})
971 continue
972 }
973 needs = append(needs, name)
974 if opt {
975 optional = append(optional, name)
976 }
977 default:
978 issues = append(issues, Issue{Line: item.Line, Key: "ci.err.needs"})
979 }
980 }
981 if needs == nil {
982 needs = []string{}
983 }
984 return needs, optional, set, issues
985}
986
987func imageOf(node *yaml.Node) (string, []Issue) {
988 switch node.Kind {
989 case yaml.ScalarNode:
990 return node.Value, nil
991 case yaml.MappingNode:
992 for i := 0; i < len(node.Content); i += 2 {
993 if node.Content[i].Value == "name" && node.Content[i+1].Kind == yaml.ScalarNode {
994 return node.Content[i+1].Value, nil
995 }
996 }
997 return "", []Issue{{Line: node.Line, Key: "ci.err.image"}}
998 default:
999 return "", []Issue{{Line: node.Line, Key: "ci.err.image"}}
1000 }
1001}
1002
1003func whenOf(node *yaml.Node, allowNever bool) (string, []Issue) {
1004 if node.Kind != yaml.ScalarNode {
1005 return "", []Issue{{Line: node.Line, Key: "ci.err.when", Args: []any{""}}}
1006 }
1007 switch node.Value {
1008 case "on_success", "on_failure", "always", "manual":
1009 return node.Value, nil
1010 case "never":
1011 if allowNever {
1012 return node.Value, nil
1013 }
1014 }
1015 return "", []Issue{{Line: node.Line, Key: "ci.err.when", Args: []any{node.Value}}}
1016}
1017
1018func durationOf(node *yaml.Node) (time.Duration, []Issue) {
1019 if node.Kind != yaml.ScalarNode {
1020 return 0, []Issue{{Line: node.Line, Key: "ci.err.timeout", Args: []any{""}}}
1021 }
1022 d, err := parseExpire(node.Value)
1023 if err != nil {
1024 if strings.HasSuffix(node.Value, "s") {
1025 n, nerr := strconv.Atoi(strings.TrimSuffix(node.Value, "s"))
1026 if nerr == nil && n >= 0 {
1027 return time.Duration(n) * time.Second, nil
1028 }
1029 }
1030 return 0, []Issue{{Line: node.Line, Key: "ci.err.timeout", Args: []any{node.Value}}}
1031 }
1032 return d, nil
1033}
1034
1035func extendsOf(node *yaml.Node) ([]string, []Issue) {
1036 if node.Kind == yaml.ScalarNode && strings.TrimSpace(node.Value) != "" {
1037 return []string{node.Value}, nil
1038 }
1039 return scalarList(node, "ci.err.extendsList")
1040}
1041
1042func scriptList(node *yaml.Node) ([]string, []Issue) {
1043 if node.Kind == yaml.ScalarNode {
1044 if strings.TrimSpace(node.Value) == "" {
1045 return nil, []Issue{{Line: node.Line, Key: "ci.err.script"}}
1046 }
1047 return splitLines(node.Value), nil
1048 }
1049 return scalarList(node, "ci.err.script")
1050}
1051
1052func splitLines(s string) []string {
1053 parts := strings.Split(s, "\n")
1054 var out []string
1055 for _, p := range parts {
1056 if strings.TrimSpace(p) == "" {
1057 continue
1058 }
1059 out = append(out, p)
1060 }
1061 return out
1062}
1063
1064func scalarList(node *yaml.Node, key string) ([]string, []Issue) {
1065 if node.Kind != yaml.SequenceNode {
1066 return nil, []Issue{{Line: node.Line, Key: key}}
1067 }
1068 var out []string
1069 var issues []Issue
1070 for _, item := range node.Content {
1071 if item.Kind != yaml.ScalarNode {
1072 issues = append(issues, Issue{Line: item.Line, Key: "ci.err.listText"})
1073 continue
1074 }
1075 out = append(out, item.Value)
1076 }
1077 return out, issues
1078}
1079
1080func scalarMap(node *yaml.Node) (map[string]string, []Issue) {
1081 if node.Kind != yaml.MappingNode {
1082 return nil, []Issue{{Line: node.Line, Key: "ci.err.map"}}
1083 }
1084 out := map[string]string{}
1085 var issues []Issue
1086 for i := 0; i < len(node.Content); i += 2 {
1087 k := node.Content[i]
1088 v := node.Content[i+1]
1089 if k.Kind != yaml.ScalarNode {
1090 issues = append(issues, Issue{Line: k.Line, Key: "ci.err.varText"})
1091 continue
1092 }
1093 switch v.Kind {
1094 case yaml.ScalarNode:
1095 out[k.Value] = v.Value
1096 case yaml.MappingNode:
1097 val, iss := mappingValue(v)
1098 issues = append(issues, iss...)
1099 if val != "" || len(iss) == 0 {
1100 out[k.Value] = val
1101 }
1102 default:
1103 issues = append(issues, Issue{Line: v.Line, Key: "ci.err.varText"})
1104 }
1105 }
1106 return out, issues
1107}
1108
1109func mappingValue(node *yaml.Node) (string, []Issue) {
1110 for i := 0; i < len(node.Content); i += 2 {
1111 if node.Content[i].Value == "value" && node.Content[i+1].Kind == yaml.ScalarNode {
1112 return node.Content[i+1].Value, nil
1113 }
1114 }
1115 return "", []Issue{{Line: node.Line, Key: "ci.err.varText"}}
1116}
1117
1118func parseBool(node *yaml.Node) (bool, []Issue) {
1119 if node.Kind != yaml.ScalarNode {
1120 return false, []Issue{{Line: node.Line, Key: "ci.err.bool"}}
1121 }
1122 switch strings.ToLower(node.Value) {
1123 case "true", "yes":
1124 return true, nil
1125 case "false", "no":
1126 return false, nil
1127 default:
1128 return false, []Issue{{Line: node.Line, Key: "ci.err.bool"}}
1129 }
1130}
1131
1132func parseExpire(s string) (time.Duration, error) {
1133 s = strings.TrimSpace(s)
1134 if s == "" || s == "never" {
1135 return 0, nil
1136 }
1137 if len(s) < 2 {
1138 return 0, fmt.Errorf("expire")
1139 }
1140 n, err := strconv.Atoi(s[:len(s)-1])
1141 if err != nil || n < 0 {
1142 return 0, fmt.Errorf("expire")
1143 }
1144 switch s[len(s)-1] {
1145 case 's':
1146 return time.Duration(n) * time.Second, nil
1147 case 'm':
1148 return time.Duration(n) * time.Minute, nil
1149 case 'h':
1150 return time.Duration(n) * time.Hour, nil
1151 case 'd':
1152 return time.Duration(n) * 24 * time.Hour, nil
1153 case 'w':
1154 return time.Duration(n) * 7 * 24 * time.Hour, nil
1155 default:
1156 return 0, fmt.Errorf("expire")
1157 }
1158}
1159
1160func safeRel(p string) Issue {
1161 if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, "\\") {
1162 return Issue{Line: 1, Key: "ci.err.rel", Args: []any{p}}
1163 }
1164 for _, part := range strings.Split(p, "/") {
1165 if part == ".." {
1166 return Issue{Line: 1, Key: "ci.err.dotdot", Args: []any{p}}
1167 }
1168 }
1169 return Issue{}
1170}
1171
1172func hasError(issues []Issue) bool {
1173 for _, is := range issues {
1174 if !is.Warning {
1175 return true
1176 }
1177 }
1178 return false
1179}