BlueGit

timfa bluegit

Files

bluegit / internal / ci / parse.go

parse.go

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