// Package ci leest blue-ci-cd.yml en bepaalt welke jobs draaien. // De vorm ligt dicht bij GitLab CI: stages, jobs, needs, rules, artifacts. package ci import ( "fmt" "regexp" "strconv" "strings" "time" "gopkg.in/yaml.v3" ) // Pipeline is een geparset configuratiebestand. type Pipeline struct { Stages []string Variables map[string]string Image string Jobs []Job } // Job is één containerstap. type Job struct { Name string Stage string Image string Script []string Needs []string NeedsSet bool Variables map[string]string Artifacts Artifacts Rules []Rule AllowFailure bool } // Artifacts zijn paden die na een geslaagde job bewaard blijven. type Artifacts struct { Paths []string ExpireIn time.Duration } // Rule is één voorwaarde. De job draait als minstens één rule klopt. // Zonder rules draait de job altijd. type Rule struct { If string } // Parse leest YAML. Jobvolgorde blijft de volgorde uit het bestand. func Parse(data []byte) (Pipeline, error) { var root yaml.Node if err := yaml.Unmarshal(data, &root); err != nil { return Pipeline{}, fmt.Errorf("yaml: %w", err) } if root.Kind != yaml.DocumentNode || len(root.Content) != 1 || root.Content[0].Kind != yaml.MappingNode { return Pipeline{}, fmt.Errorf("blue-ci-cd.yml moet een mapping zijn") } body := root.Content[0] var p Pipeline p.Variables = map[string]string{} for i := 0; i < len(body.Content); i += 2 { key := body.Content[i].Value val := body.Content[i+1] switch key { case "stages": stages, err := scalarList(val) if err != nil { return Pipeline{}, fmt.Errorf("stages: %w", err) } p.Stages = stages case "variables": vars, err := scalarMap(val) if err != nil { return Pipeline{}, fmt.Errorf("variables: %w", err) } p.Variables = vars case "image": if val.Kind != yaml.ScalarNode { return Pipeline{}, fmt.Errorf("image moet een tekst zijn") } p.Image = val.Value case "jobs": jobs, err := parseJobs(val) if err != nil { return Pipeline{}, err } p.Jobs = jobs default: return Pipeline{}, fmt.Errorf("onbekend veld %q", key) } } if err := p.validate(); err != nil { return Pipeline{}, err } return p, nil } func parseJobs(node *yaml.Node) ([]Job, error) { if node.Kind != yaml.MappingNode { return nil, fmt.Errorf("jobs moet een mapping zijn") } var jobs []Job for i := 0; i < len(node.Content); i += 2 { name := node.Content[i].Value body := node.Content[i+1] job, err := parseJob(name, body) if err != nil { return nil, fmt.Errorf("job %s: %w", name, err) } jobs = append(jobs, job) } return jobs, nil } func parseJob(name string, node *yaml.Node) (Job, error) { if node.Kind != yaml.MappingNode { return Job{}, fmt.Errorf("moet een mapping zijn") } j := Job{Name: name, Variables: map[string]string{}} for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] switch key { case "stage": if val.Kind != yaml.ScalarNode { return Job{}, fmt.Errorf("stage moet tekst zijn") } j.Stage = val.Value case "image": if val.Kind != yaml.ScalarNode { return Job{}, fmt.Errorf("image moet tekst zijn") } j.Image = val.Value case "script": lines, err := scalarList(val) if err != nil { return Job{}, fmt.Errorf("script: %w", err) } j.Script = lines case "needs": needs, err := scalarList(val) if err != nil { return Job{}, fmt.Errorf("needs: %w", err) } j.Needs = needs j.NeedsSet = true case "variables": vars, err := scalarMap(val) if err != nil { return Job{}, fmt.Errorf("variables: %w", err) } j.Variables = vars case "artifacts": art, err := parseArtifacts(val) if err != nil { return Job{}, err } j.Artifacts = art case "rules": rules, err := parseRules(val) if err != nil { return Job{}, err } j.Rules = rules case "allow_failure": b, err := parseBool(val) if err != nil { return Job{}, fmt.Errorf("allow_failure: %w", err) } j.AllowFailure = b default: return Job{}, fmt.Errorf("onbekend veld %q", key) } } return j, nil } func parseArtifacts(node *yaml.Node) (Artifacts, error) { if node.Kind != yaml.MappingNode { return Artifacts{}, fmt.Errorf("artifacts moet een mapping zijn") } var a Artifacts for i := 0; i < len(node.Content); i += 2 { key := node.Content[i].Value val := node.Content[i+1] switch key { case "paths": paths, err := scalarList(val) if err != nil { return Artifacts{}, fmt.Errorf("artifacts.paths: %w", err) } a.Paths = paths case "expire_in": if val.Kind != yaml.ScalarNode { return Artifacts{}, fmt.Errorf("expire_in moet tekst zijn") } d, err := parseExpire(val.Value) if err != nil { return Artifacts{}, err } a.ExpireIn = d default: return Artifacts{}, fmt.Errorf("onbekend artifacts-veld %q", key) } } return a, nil } func parseRules(node *yaml.Node) ([]Rule, error) { if node.Kind != yaml.SequenceNode { return nil, fmt.Errorf("rules moet een lijst zijn") } var rules []Rule for _, item := range node.Content { if item.Kind != yaml.MappingNode { return nil, fmt.Errorf("rule moet een mapping zijn") } var r Rule for i := 0; i < len(item.Content); i += 2 { key := item.Content[i].Value val := item.Content[i+1] if key != "if" { return nil, fmt.Errorf("rule ondersteunt alleen if, kreeg %q", key) } if val.Kind != yaml.ScalarNode || strings.TrimSpace(val.Value) == "" { return nil, fmt.Errorf("rule.if moet tekst zijn") } r.If = strings.TrimSpace(val.Value) } if r.If == "" { return nil, fmt.Errorf("rule mist if") } if _, err := compileRule(r.If); err != nil { return nil, err } rules = append(rules, r) } return rules, nil } func (p *Pipeline) validate() error { if len(p.Jobs) == 0 { return fmt.Errorf("geen jobs") } seenStage := map[string]bool{} for _, s := range p.Stages { if s == "" { return fmt.Errorf("lege stage-naam") } if seenStage[s] { return fmt.Errorf("dubbele stage %q", s) } seenStage[s] = true } if len(p.Stages) == 0 { var order []string have := map[string]bool{} for i := range p.Jobs { if p.Jobs[i].Stage == "" { p.Jobs[i].Stage = "test" } if !have[p.Jobs[i].Stage] { have[p.Jobs[i].Stage] = true order = append(order, p.Jobs[i].Stage) } } p.Stages = order for _, s := range p.Stages { seenStage[s] = true } } names := map[string]bool{} for i := range p.Jobs { j := &p.Jobs[i] if j.Name == "" || strings.ContainsAny(j.Name, " \t\n/\\") { return fmt.Errorf("ongeldige jobnaam %q", j.Name) } if names[j.Name] { return fmt.Errorf("dubbele job %q", j.Name) } names[j.Name] = true if j.Stage == "" { return fmt.Errorf("job %s mist stage", j.Name) } if !seenStage[j.Stage] { return fmt.Errorf("job %s gebruikt onbekende stage %q", j.Name, j.Stage) } if j.Image == "" { j.Image = p.Image } if strings.TrimSpace(j.Image) == "" || strings.ContainsAny(j.Image, " \t\n") { return fmt.Errorf("job %s mist een image", j.Name) } if len(j.Script) == 0 { return fmt.Errorf("job %s mist script", j.Name) } for _, line := range j.Script { if strings.TrimSpace(line) == "" { return fmt.Errorf("job %s heeft een lege scriptregel", j.Name) } } for _, path := range j.Artifacts.Paths { if err := safeRelPath(path); err != nil { return fmt.Errorf("job %s artifact: %w", j.Name, err) } } } for _, j := range p.Jobs { for _, need := range j.Needs { if !names[need] { return fmt.Errorf("job %s needs onbekende job %q", j.Name, need) } if need == j.Name { return fmt.Errorf("job %s kan niet van zichzelf afhangen", j.Name) } } } if err := detectCycles(p.Jobs); err != nil { return err } return nil } func detectCycles(jobs []Job) error { 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) error visit = func(i int) error { if color[i] == gray { return fmt.Errorf("cyclus in needs bij job %s", jobs[i].Name) } if color[i] == black { return nil } color[i] = gray for _, n := range jobs[i].Needs { if err := visit(idx[n]); err != nil { return err } } color[i] = black return nil } for i := range jobs { if err := visit(i); err != nil { return err } } return nil } // ActiveJobs filtert jobs waarvan de rules niet kloppen. func (p Pipeline) ActiveJobs(env map[string]string) ([]Job, error) { var out []Job for _, j := range p.Jobs { ok, err := j.matches(env) if err != nil { return nil, fmt.Errorf("job %s: %w", j.Name, err) } if ok { out = append(out, j) } } return out, nil } func (j Job) matches(env map[string]string) (bool, error) { if len(j.Rules) == 0 { return true, nil } for _, r := range j.Rules { ok, err := evalRule(r.If, env) if err != nil { return false, err } if ok { return true, nil } } return false, nil } // Gate beslist of een job mag starten. // "ready" betekent dat alle voorgangers klaar zijn. // "wait" betekent dat er nog een voorganger loopt of in de wachtrij staat. // "skip" betekent dat een voorganger mislukte zonder allow_failure. // // NeedsSet volgt de genoemde jobs, ook als de lijst leeg is. // Zonder needs wacht de job op alle jobs in eerdere stages. func Gate(jobs []Job, status map[string]string, job Job) string { byName := map[string]Job{} for _, j := range jobs { byName[j.Name] = j } var deps []Job if job.NeedsSet { for _, n := range job.Needs { deps = append(deps, byName[n]) } } else { stagePos := map[string]int{} order := 0 for _, j := range jobs { if _, ok := stagePos[j.Stage]; !ok { stagePos[j.Stage] = order order++ } } my := stagePos[job.Stage] for _, j := range jobs { if stagePos[j.Stage] < my { deps = append(deps, j) } } } for _, d := range deps { switch status[d.Name] { case "success", "skipped": continue case "failed": if d.AllowFailure { continue } return "skip" default: return "wait" } } return "ready" } var ( reEq = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*==\s*"([^"]*)"$`) reNe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*!=\s*"([^"]*)"$`) reRe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*=~\s*/(.+)/$`) ) type compiledRule struct { kind string name string arg string re *regexp.Regexp } func compileRule(expr string) (compiledRule, error) { if m := reEq.FindStringSubmatch(expr); m != nil { return compiledRule{kind: "eq", name: m[1], arg: m[2]}, nil } if m := reNe.FindStringSubmatch(expr); m != nil { return compiledRule{kind: "ne", name: m[1], arg: m[2]}, nil } if m := reRe.FindStringSubmatch(expr); m != nil { re, err := regexp.Compile(m[2]) if err != nil { return compiledRule{}, fmt.Errorf("ongeldige regex in rule %q: %w", expr, err) } return compiledRule{kind: "re", name: m[1], re: re}, nil } return compiledRule{}, fmt.Errorf("rule %q wordt niet begrepen", expr) } func evalRule(expr string, env map[string]string) (bool, error) { c, err := compileRule(expr) if err != nil { return false, err } val := env[c.name] switch c.kind { case "eq": return val == c.arg, nil case "ne": return val != c.arg, nil case "re": return c.re.MatchString(val), nil default: return false, fmt.Errorf("interne rulefout") } } 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_in %q is ongeldig", s) } n, err := strconv.Atoi(s[:len(s)-1]) if err != nil || n < 0 { return 0, fmt.Errorf("expire_in %q is ongeldig", s) } switch s[len(s)-1] { 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_in %q is ongeldig", s) } } func scalarList(node *yaml.Node) ([]string, error) { if node.Kind != yaml.SequenceNode { return nil, fmt.Errorf("verwacht een lijst") } var out []string for _, item := range node.Content { if item.Kind != yaml.ScalarNode { return nil, fmt.Errorf("lijst mag alleen tekst bevatten") } out = append(out, item.Value) } return out, nil } func scalarMap(node *yaml.Node) (map[string]string, error) { if node.Kind != yaml.MappingNode { return nil, fmt.Errorf("verwacht een mapping") } out := map[string]string{} for i := 0; i < len(node.Content); i += 2 { k := node.Content[i] v := node.Content[i+1] if k.Kind != yaml.ScalarNode || v.Kind != yaml.ScalarNode { return nil, fmt.Errorf("variabelen moeten tekst zijn") } out[k.Value] = v.Value } return out, nil } func parseBool(node *yaml.Node) (bool, error) { if node.Kind != yaml.ScalarNode { return false, fmt.Errorf("verwacht ja of nee") } switch strings.ToLower(node.Value) { case "true", "yes", "ja": return true, nil case "false", "no", "nee": return false, nil default: return false, fmt.Errorf("verwacht true of false") } } func safeRelPath(p string) error { if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, "\\") { return fmt.Errorf("pad %q moet relatief zijn", p) } for _, part := range strings.Split(p, "/") { if part == ".." { return fmt.Errorf("pad %q mag niet buiten de workspace", p) } } return nil }