package ci import ( "fmt" "path" "regexp" "strings" "gitlab.com/Timfa/bluegit/internal/i18n" ) // Variables zet de voorgedefinieerde CI_-variabelen. Job-specifieke namen // vult de runner zelf aan. func Variables(r Ref) map[string]string { name := r.Name kind := r.Kind if kind == "" { name, kind = SplitRef(r.FullRef) } short := r.SHA if len(short) > 8 { short = short[:8] } project := r.ProjectPath ns, base := splitProject(project) env := map[string]string{ "CI": "true", "CI_CONFIG_PATH": "blue-ci-cd.yml", "CI_SERVER_NAME": "BlueGit", "CI_COMMIT_SHA": r.SHA, "CI_COMMIT_SHORT_SHA": short, "CI_COMMIT_REF": r.FullRef, "CI_COMMIT_REF_NAME": name, "CI_COMMIT_REF_SLUG": slug(name), "CI_COMMIT_TITLE": r.Title, "CI_COMMIT_BRANCH": "", "CI_COMMIT_TAG": "", "CI_DEFAULT_BRANCH": r.DefaultBranch, "CI_PIPELINE_ID": fmt.Sprint(r.PipelineID), "CI_PIPELINE_SOURCE": r.Source, "CI_PIPELINE_URL": strings.TrimRight(r.ProjectURL, "/") + "/-/pipelines/" + fmt.Sprint(r.PipelineID), "CI_PROJECT_PATH": project, "CI_PROJECT_NAME": base, "CI_PROJECT_NAMESPACE": ns, "CI_PROJECT_URL": r.ProjectURL, "CI_API_URL": r.APIURL, } if kind == "tag" { env["CI_COMMIT_TAG"] = name } else { env["CI_COMMIT_BRANCH"] = name } if env["CI_PIPELINE_SOURCE"] == "" { env["CI_PIPELINE_SOURCE"] = "push" } if r.MR != nil { m := r.MR env["CI_MERGE_REQUEST_ID"] = fmt.Sprint(m.ID) env["CI_MERGE_REQUEST_IID"] = fmt.Sprint(m.IID) env["CI_MERGE_REQUEST_TITLE"] = m.Title env["CI_MERGE_REQUEST_SOURCE_BRANCH_NAME"] = m.SourceBranch env["CI_MERGE_REQUEST_SOURCE_BRANCH_SHA"] = r.SHA env["CI_MERGE_REQUEST_TARGET_BRANCH_NAME"] = m.TargetBranch env["CI_MERGE_REQUEST_TARGET_BRANCH_SHA"] = m.TargetSHA env["CI_MERGE_REQUEST_PROJECT_PATH"] = m.ProjectPath env["CI_MERGE_REQUEST_PROJECT_URL"] = m.ProjectURL } return env } // SplitRef haalt de korte naam en het soort uit refs/heads of refs/tags. func SplitRef(ref string) (name, kind string) { switch { case strings.HasPrefix(ref, "refs/tags/"): return strings.TrimPrefix(ref, "refs/tags/"), "tag" case strings.HasPrefix(ref, "refs/heads/"): return strings.TrimPrefix(ref, "refs/heads/"), "branch" default: return ref, "branch" } } func splitProject(path string) (ns, name string) { i := strings.LastIndex(path, "/") if i < 0 { return "", path } return path[:i], path[i+1:] } func slug(s string) string { var b strings.Builder prev := false for _, r := range strings.ToLower(s) { if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') { b.WriteRune(r) prev = false continue } if !prev && b.Len() > 0 { b.WriteByte('-') prev = true } } return strings.Trim(b.String(), "-") } // Select houdt de jobs waarvan de rules, only en except kloppen. // De When van de job wordt de when van de winnende rule. func (p Pipeline) Select(ev Eval) ([]Job, error) { if ev.Env == nil { ev.Env = map[string]string{} } var out []Job active := map[string]bool{} var pending []Job for _, j := range p.Jobs { ok, when, err := j.matches(ev) if err != nil { return nil, fmt.Errorf("job %s: %w", j.Name, err) } if !ok { continue } if when == "" { when = "on_success" } j.When = when pending = append(pending, j) active[j.Name] = true } for i := range pending { var needs []string for _, n := range pending[i].Needs { if active[n] { needs = append(needs, n) continue } if contains(pending[i].Optional, n) { continue } needs = append(needs, n) } if needs == nil { needs = []string{} } pending[i].Needs = needs out = append(out, pending[i]) } return out, nil } // ActiveJobs is Select met alleen variabelen. changes en exists gelden dan als waar. func (p Pipeline) ActiveJobs(env map[string]string) ([]Job, error) { return p.Select(Eval{Env: env}) } func (j Job) matches(ev Eval) (bool, string, error) { when := j.When if when == "" { when = "on_success" } if len(j.Rules) == 0 { ok, err := onlyExcept(j, ev) return ok, when, err } for _, r := range j.Rules { ok, err := ruleMatch(r, ev) if err != nil { return false, "", err } if !ok { continue } w := r.When if w == "" { w = when } if w == "never" { return false, w, nil } return true, w, nil } return false, "", nil } func ruleMatch(r Rule, ev Eval) (bool, error) { if r.If != "" { ok, err := evalRule(r.If, ev.Env) if err != nil || !ok { return ok, err } } if len(r.Changes) > 0 && ev.Changed != nil { if !anyGlob(r.Changes, ev.Changed) { return false, nil } } if len(r.Exists) > 0 && ev.Files != nil { if !allExist(r.Exists, ev.Files) { return false, nil } } if r.If == "" && len(r.Changes) == 0 && len(r.Exists) == 0 && r.When == "" { return false, nil } return true, nil } func onlyExcept(j Job, ev Eval) (bool, error) { mr := ev.Env["CI_PIPELINE_SOURCE"] == "merge_request_event" if len(j.Only) == 0 && len(j.Except) == 0 { // Zonder rules of only draait een job op een branch of tag, // niet in een merge-request-pipeline. if mr { return false, nil } return true, nil } name := ev.Env["CI_COMMIT_REF_NAME"] if name == "" { name = ev.Env["CI_COMMIT_BRANCH"] } tag := ev.Env["CI_COMMIT_TAG"] != "" if len(j.Only) > 0 { ok, err := refListed(j.Only, name, tag, mr) if err != nil || !ok { return false, err } } if len(j.Except) > 0 { ok, err := refListed(j.Except, name, tag, mr) if err != nil { return false, err } if ok { return false, nil } } return true, nil } func refListed(list []string, name string, tag, mr bool) (bool, error) { for _, item := range list { switch item { case "merge_requests": if mr { return true, nil } case "branches": if !tag && !mr { return true, nil } case "tags": if tag && !mr { return true, nil } default: if mr { continue } if strings.HasPrefix(item, "/") && strings.HasSuffix(item, "/") && len(item) > 2 { re, err := regexp.Compile(item[1 : len(item)-1]) if err != nil { return false, i18n.E("ci.err.regex", item, err.Error()) } if re.MatchString(name) { return true, nil } continue } if item == name { return true, nil } } } return false, nil } func anyGlob(patterns, names []string) bool { for _, name := range names { for _, pattern := range patterns { if Glob(pattern, name) { return true } } } return false } func allExist(patterns, files []string) bool { for _, pattern := range patterns { found := false for _, file := range files { if file == pattern || Glob(pattern, file) { found = true break } } if !found { return false } } return true } // Glob volgt GitLab-padpatronen: * blijft in één segment, ** loopt door mappen. func Glob(pattern, name string) bool { pattern = strings.TrimPrefix(pattern, "/") name = strings.TrimPrefix(name, "/") if pattern == name { return true } re := globRegexp(pattern) if re.MatchString(name) { return true } if !strings.Contains(pattern, "/") && re.MatchString(path.Base(name)) { return true } return false } func globRegexp(pattern string) *regexp.Regexp { var b strings.Builder b.WriteString("^") for i := 0; i < len(pattern); i++ { if pattern[i] == '*' && i+1 < len(pattern) && pattern[i+1] == '*' { b.WriteString(".*") i++ if i+1 < len(pattern) && pattern[i+1] == '/' { i++ } continue } switch pattern[i] { case '*': b.WriteString("[^/]*") case '?': b.WriteString("[^/]") default: b.WriteString(regexp.QuoteMeta(pattern[i : i+1])) } } b.WriteString("$") return regexp.MustCompile(b.String()) } // 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, // of dat when: on_failure geen mislukking zag. // "fail" betekent dat een verplichte need niet in deze pipeline zit. // // 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 } optional := map[string]bool{} for _, n := range job.Optional { optional[n] = true } var deps []Job if job.NeedsSet { for _, n := range job.Needs { d, ok := byName[n] if !ok { if optional[n] { continue } return "fail" } deps = append(deps, d) } } 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) } } } failedAny := false failedHard := false for _, d := range deps { switch status[d.Name] { case "success", "skipped": continue case "failed": failedAny = true if !d.AllowFailure { failedHard = true } case "manual": if d.AllowFailure { continue } return "wait" default: return "wait" } } when := job.When if when == "" { when = "on_success" } switch when { case "always": return "ready" case "on_failure": if failedAny { return "ready" } return "skip" default: if failedHard { return "skip" } return "ready" } } var ( reEq = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*==\s*(?:"([^"]*)"|\$([A-Za-z_][A-Za-z0-9_]*)|null)$`) reNe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*!=\s*(?:"([^"]*)"|\$([A-Za-z_][A-Za-z0-9_]*)|null)$`) reRe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*=~\s*/(.*)/$`) reNRe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*!~\s*/(.*)/$`) ) type compiledRule struct { kind string name string arg string other string null bool re *regexp.Regexp } func compileRule(expr string) (compiledRule, error) { expr = strings.TrimSpace(expr) if strings.Contains(expr, "&&") || strings.Contains(expr, "||") { return compiledRule{}, i18n.E("ci.err.ruleCombine", expr) } if m := reEq.FindStringSubmatch(expr); m != nil { return compiledRule{kind: "eq", name: m[1], arg: m[2], other: m[3], null: m[2] == "" && m[3] == "" && strings.HasSuffix(strings.TrimSpace(expr), "null")}, nil } if m := reNe.FindStringSubmatch(expr); m != nil { return compiledRule{kind: "ne", name: m[1], arg: m[2], other: m[3], null: m[2] == "" && m[3] == "" && strings.HasSuffix(strings.TrimSpace(expr), "null")}, nil } if m := reRe.FindStringSubmatch(expr); m != nil { re, err := regexp.Compile(m[2]) if err != nil { return compiledRule{}, i18n.E("ci.err.regex", expr, err.Error()) } return compiledRule{kind: "re", name: m[1], re: re}, nil } if m := reNRe.FindStringSubmatch(expr); m != nil { re, err := regexp.Compile(m[2]) if err != nil { return compiledRule{}, i18n.E("ci.err.regex", expr, err.Error()) } return compiledRule{kind: "nre", name: m[1], re: re}, nil } return compiledRule{}, i18n.E("ci.err.ruleExpr", 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] right := c.arg if c.other != "" { right = env[c.other] } if c.null { right = "" } switch c.kind { case "eq": return val == right, nil case "ne": return val != right, nil case "re": return c.re.MatchString(val), nil case "nre": return !c.re.MatchString(val), nil default: return false, i18n.E("ci.err.ruleExpr", expr) } } func contains(list []string, s string) bool { for _, item := range list { if item == s { return true } } return false }