BlueGit

timfa bluegit

Files

bluegit / internal / ci / eval.go

eval.go

fix: gebruik de committer-tijd als AUR-pkgver
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
2388e414 History
eval.go 14.6 KiB Download Raw
1package ci
2
3import (
4 "fmt"
5 "path"
6 "regexp"
7 "strconv"
8 "strings"
9
10 "gitlab.com/Timfa/bluegit/internal/i18n"
11)
12
13// Variables zet de voorgedefinieerde CI_-variabelen. Job-specifieke namen
14// vult de runner zelf aan.
15func Variables(r Ref) map[string]string {
16 name := r.Name
17 kind := r.Kind
18 if kind == "" {
19 name, kind = SplitRef(r.FullRef)
20 }
21 short := r.SHA
22 if len(short) > 8 {
23 short = short[:8]
24 }
25 project := r.ProjectPath
26 ns, base := splitProject(project)
27 env := map[string]string{
28 "CI": "true",
29 "CI_CONFIG_PATH": "blue-ci-cd.yml",
30 "CI_SERVER_NAME": "BlueGit",
31 "CI_COMMIT_SHA": r.SHA,
32 "CI_COMMIT_SHORT_SHA": short,
33 "CI_COMMIT_REF": r.FullRef,
34 "CI_COMMIT_REF_NAME": name,
35 "CI_COMMIT_REF_SLUG": slug(name),
36 "CI_COMMIT_TITLE": r.Title,
37 "CI_COMMIT_BRANCH": "",
38 "CI_COMMIT_TAG": "",
39 "CI_DEFAULT_BRANCH": r.DefaultBranch,
40 "CI_PIPELINE_ID": fmt.Sprint(r.PipelineID),
41 "CI_PIPELINE_SOURCE": r.Source,
42 "CI_PIPELINE_URL": strings.TrimRight(r.ProjectURL, "/") + "/-/pipelines/" + fmt.Sprint(r.PipelineID),
43 "CI_PROJECT_PATH": project,
44 "CI_PROJECT_NAME": base,
45 "CI_PROJECT_NAMESPACE": ns,
46 "CI_PROJECT_URL": r.ProjectURL,
47 "CI_API_URL": r.APIURL,
48 }
49 if r.Timestamp != "" {
50 env["CI_COMMIT_TIMESTAMP"] = r.Timestamp
51 }
52 if kind == "tag" {
53 env["CI_COMMIT_TAG"] = name
54 } else {
55 env["CI_COMMIT_BRANCH"] = name
56 }
57 if env["CI_PIPELINE_SOURCE"] == "" {
58 env["CI_PIPELINE_SOURCE"] = "push"
59 }
60 if r.MR != nil {
61 m := r.MR
62 env["CI_MERGE_REQUEST_ID"] = fmt.Sprint(m.ID)
63 env["CI_MERGE_REQUEST_IID"] = fmt.Sprint(m.IID)
64 env["CI_MERGE_REQUEST_TITLE"] = m.Title
65 env["CI_MERGE_REQUEST_SOURCE_BRANCH_NAME"] = m.SourceBranch
66 env["CI_MERGE_REQUEST_SOURCE_BRANCH_SHA"] = r.SHA
67 env["CI_MERGE_REQUEST_TARGET_BRANCH_NAME"] = m.TargetBranch
68 env["CI_MERGE_REQUEST_TARGET_BRANCH_SHA"] = m.TargetSHA
69 env["CI_MERGE_REQUEST_PROJECT_PATH"] = m.ProjectPath
70 env["CI_MERGE_REQUEST_PROJECT_URL"] = m.ProjectURL
71 }
72 return env
73}
74
75// SplitRef haalt de korte naam en het soort uit refs/heads of refs/tags.
76func SplitRef(ref string) (name, kind string) {
77 switch {
78 case strings.HasPrefix(ref, "refs/tags/"):
79 return strings.TrimPrefix(ref, "refs/tags/"), "tag"
80 case strings.HasPrefix(ref, "refs/heads/"):
81 return strings.TrimPrefix(ref, "refs/heads/"), "branch"
82 default:
83 return ref, "branch"
84 }
85}
86
87func splitProject(path string) (ns, name string) {
88 i := strings.LastIndex(path, "/")
89 if i < 0 {
90 return "", path
91 }
92 return path[:i], path[i+1:]
93}
94
95func slug(s string) string {
96 var b strings.Builder
97 prev := false
98 for _, r := range strings.ToLower(s) {
99 if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
100 b.WriteRune(r)
101 prev = false
102 continue
103 }
104 if !prev && b.Len() > 0 {
105 b.WriteByte('-')
106 prev = true
107 }
108 }
109 return strings.Trim(b.String(), "-")
110}
111
112// Select houdt de jobs waarvan de rules, only en except kloppen.
113// De When van de job wordt de when van de winnende rule.
114func (p Pipeline) Select(ev Eval) ([]Job, error) {
115 if ev.Env == nil {
116 ev.Env = map[string]string{}
117 }
118 var out []Job
119 active := map[string]bool{}
120 var pending []Job
121 for _, j := range p.Jobs {
122 ok, when, err := j.matches(ev)
123 if err != nil {
124 return nil, fmt.Errorf("job %s: %w", j.Name, err)
125 }
126 if !ok {
127 continue
128 }
129 if when == "" {
130 when = "on_success"
131 }
132 j.When = when
133 pending = append(pending, j)
134 active[j.Name] = true
135 }
136 for i := range pending {
137 var needs []string
138 for _, n := range pending[i].Needs {
139 if active[n] {
140 needs = append(needs, n)
141 continue
142 }
143 if contains(pending[i].Optional, n) {
144 continue
145 }
146 needs = append(needs, n)
147 }
148 if needs == nil {
149 needs = []string{}
150 }
151 pending[i].Needs = needs
152 out = append(out, pending[i])
153 }
154 return expandJobs(out)
155}
156
157// Allow zegt of workflow:rules deze pipeline toelaat.
158// Zonder workflow wordt de pipeline gemaakt. Een passende rule met when:never
159// of geen enkele passende rule slaat de pipeline over.
160func (p Pipeline) Allow(ev Eval) (bool, error) {
161 if len(p.Workflow) == 0 {
162 return true, nil
163 }
164 if ev.Env == nil {
165 ev.Env = map[string]string{}
166 }
167 ok, _, err := (Job{Rules: p.Workflow, When: "always"}).matches(ev)
168 return ok, err
169}
170
171// ActiveJobs is Select met alleen variabelen. changes en exists gelden dan als waar.
172func (p Pipeline) ActiveJobs(env map[string]string) ([]Job, error) {
173 return p.Select(Eval{Env: env})
174}
175
176func (j Job) matches(ev Eval) (bool, string, error) {
177 when := j.When
178 if when == "" {
179 when = "on_success"
180 }
181 if len(j.Rules) == 0 {
182 ok, err := onlyExcept(j, ev)
183 return ok, when, err
184 }
185 for _, r := range j.Rules {
186 ok, err := ruleMatch(r, ev)
187 if err != nil {
188 return false, "", err
189 }
190 if !ok {
191 continue
192 }
193 w := r.When
194 if w == "" {
195 w = when
196 }
197 if w == "never" {
198 return false, w, nil
199 }
200 return true, w, nil
201 }
202 return false, "", nil
203}
204
205func ruleMatch(r Rule, ev Eval) (bool, error) {
206 if r.If != "" {
207 ok, err := evalRule(r.If, ev.Env)
208 if err != nil || !ok {
209 return ok, err
210 }
211 }
212 if len(r.Changes) > 0 && ev.Changed != nil {
213 if !anyGlob(r.Changes, ev.Changed) {
214 return false, nil
215 }
216 }
217 if len(r.Exists) > 0 && ev.Files != nil {
218 if !allExist(r.Exists, ev.Files) {
219 return false, nil
220 }
221 }
222 if r.If == "" && len(r.Changes) == 0 && len(r.Exists) == 0 && r.When == "" {
223 return false, nil
224 }
225 return true, nil
226}
227
228func onlyExcept(j Job, ev Eval) (bool, error) {
229 mr := ev.Env["CI_PIPELINE_SOURCE"] == "merge_request_event"
230 if len(j.Only) == 0 && len(j.Except) == 0 {
231 // Zonder rules of only draait een job op een branch of tag,
232 // niet in een merge-request-pipeline.
233 if mr {
234 return false, nil
235 }
236 return true, nil
237 }
238 name := ev.Env["CI_COMMIT_REF_NAME"]
239 if name == "" {
240 name = ev.Env["CI_COMMIT_BRANCH"]
241 }
242 tag := ev.Env["CI_COMMIT_TAG"] != ""
243 if len(j.Only) > 0 {
244 ok, err := refListed(j.Only, name, tag, mr)
245 if err != nil || !ok {
246 return false, err
247 }
248 }
249 if len(j.Except) > 0 {
250 ok, err := refListed(j.Except, name, tag, mr)
251 if err != nil {
252 return false, err
253 }
254 if ok {
255 return false, nil
256 }
257 }
258 return true, nil
259}
260
261func refListed(list []string, name string, tag, mr bool) (bool, error) {
262 for _, item := range list {
263 switch item {
264 case "merge_requests":
265 if mr {
266 return true, nil
267 }
268 case "branches":
269 if !tag && !mr {
270 return true, nil
271 }
272 case "tags":
273 if tag && !mr {
274 return true, nil
275 }
276 default:
277 if mr {
278 continue
279 }
280 if strings.HasPrefix(item, "/") && strings.HasSuffix(item, "/") && len(item) > 2 {
281 re, err := regexp.Compile(item[1 : len(item)-1])
282 if err != nil {
283 return false, i18n.E("ci.err.regex", item, err.Error())
284 }
285 if re.MatchString(name) {
286 return true, nil
287 }
288 continue
289 }
290 if item == name {
291 return true, nil
292 }
293 }
294 }
295 return false, nil
296}
297
298func anyGlob(patterns, names []string) bool {
299 for _, name := range names {
300 for _, pattern := range patterns {
301 if Glob(pattern, name) {
302 return true
303 }
304 }
305 }
306 return false
307}
308
309func allExist(patterns, files []string) bool {
310 for _, pattern := range patterns {
311 found := false
312 for _, file := range files {
313 if file == pattern || Glob(pattern, file) {
314 found = true
315 break
316 }
317 }
318 if !found {
319 return false
320 }
321 }
322 return true
323}
324
325// Glob volgt GitLab-padpatronen: * blijft in één segment, ** loopt door mappen.
326func Glob(pattern, name string) bool {
327 pattern = strings.TrimPrefix(pattern, "/")
328 name = strings.TrimPrefix(name, "/")
329 if pattern == name {
330 return true
331 }
332 re := globRegexp(pattern)
333 if re.MatchString(name) {
334 return true
335 }
336 if !strings.Contains(pattern, "/") && re.MatchString(path.Base(name)) {
337 return true
338 }
339 return false
340}
341
342func globRegexp(pattern string) *regexp.Regexp {
343 var b strings.Builder
344 b.WriteString("^")
345 for i := 0; i < len(pattern); i++ {
346 if pattern[i] == '*' && i+1 < len(pattern) && pattern[i+1] == '*' {
347 b.WriteString(".*")
348 i++
349 if i+1 < len(pattern) && pattern[i+1] == '/' {
350 i++
351 }
352 continue
353 }
354 switch pattern[i] {
355 case '*':
356 b.WriteString("[^/]*")
357 case '?':
358 b.WriteString("[^/]")
359 default:
360 b.WriteString(regexp.QuoteMeta(pattern[i : i+1]))
361 }
362 }
363 b.WriteString("$")
364 return regexp.MustCompile(b.String())
365}
366
367// Gate beslist of een job mag starten.
368// "ready" betekent dat alle voorgangers klaar zijn.
369// "wait" betekent dat er nog een voorganger loopt of in de wachtrij staat.
370// "skip" betekent dat een voorganger mislukte zonder allow_failure,
371// dat een job in needs is overgeslagen, of dat when: on_failure geen
372// mislukking zag.
373// "fail" betekent dat een verplichte need niet in deze pipeline zit.
374//
375// NeedsSet volgt de genoemde jobs, ook als de lijst leeg is. Een
376// gefaalde of overgeslagen need slaat deze job over, behalve bij
377// allow_failure, when: on_failure en when: always. needs: [] heeft
378// geen voorgangers en start meteen.
379// Zonder needs wacht de job op alle jobs in eerdere stages. Een
380// overgeslagen eerdere stage telt dan als klaar; een harde mislukking
381// houdt latere stages tegen.
382func Gate(jobs []Job, status map[string]string, job Job) string {
383 byName := map[string]Job{}
384 for _, j := range jobs {
385 byName[j.Name] = j
386 }
387 optional := map[string]bool{}
388 for _, n := range job.Optional {
389 optional[n] = true
390 }
391 var deps []Job
392 if job.NeedsSet {
393 for _, n := range job.Needs {
394 d, ok := byName[n]
395 if !ok {
396 if optional[n] {
397 continue
398 }
399 return "fail"
400 }
401 deps = append(deps, d)
402 }
403 } else {
404 stagePos := map[string]int{}
405 order := 0
406 for _, j := range jobs {
407 if _, ok := stagePos[j.Stage]; !ok {
408 stagePos[j.Stage] = order
409 order++
410 }
411 }
412 my := stagePos[job.Stage]
413 for _, j := range jobs {
414 if stagePos[j.Stage] < my {
415 deps = append(deps, j)
416 }
417 }
418 }
419 failedAny := false
420 failedHard := false
421 skippedNeed := false
422 for _, d := range deps {
423 switch status[d.Name] {
424 case "success":
425 continue
426 case "skipped":
427 // Alleen een genoemde need. Zonder needs telt een
428 // overgeslagen eerdere stage als afgerond.
429 if job.NeedsSet {
430 skippedNeed = true
431 }
432 case "failed", "canceled":
433 failedAny = true
434 if !d.AllowFailure {
435 failedHard = true
436 }
437 case "manual":
438 if d.AllowFailure {
439 continue
440 }
441 return "wait"
442 default:
443 return "wait"
444 }
445 }
446 when := job.When
447 if when == "" {
448 when = "on_success"
449 }
450 switch when {
451 case "always":
452 return "ready"
453 case "on_failure":
454 if failedAny {
455 return "ready"
456 }
457 return "skip"
458 default:
459 if failedHard || skippedNeed {
460 return "skip"
461 }
462 return "ready"
463 }
464}
465
466func evalRule(expr string, env map[string]string) (bool, error) {
467 p := &ruleParser{s: expr, env: env}
468 ok, err := p.parseOr()
469 if err != nil {
470 return false, err
471 }
472 p.skip()
473 if p.i < len(p.s) {
474 return false, i18n.E("ci.err.ruleExpr", strings.TrimSpace(expr))
475 }
476 return ok, nil
477}
478
479const maxParallel = 50
480
481func expandJobs(jobs []Job) ([]Job, error) {
482 expanded := map[string][]string{}
483 var out []Job
484 seen := map[string]bool{}
485 for _, j := range jobs {
486 instances, err := expandOne(j)
487 if err != nil {
488 return nil, fmt.Errorf("job %s: %w", j.Name, err)
489 }
490 names := make([]string, len(instances))
491 for i, inst := range instances {
492 if seen[inst.Name] {
493 return nil, i18n.E("ci.err.jobDup", inst.Name)
494 }
495 seen[inst.Name] = true
496 names[i] = inst.Name
497 out = append(out, inst)
498 }
499 expanded[j.Name] = names
500 }
501 for i := range out {
502 out[i].Needs = rewriteNeeds(out[i].Needs, expanded)
503 out[i].Optional = rewriteNeeds(out[i].Optional, expanded)
504 }
505 return out, nil
506}
507
508func expandOne(j Job) ([]Job, error) {
509 if len(j.Matrix) > 0 {
510 var combos []matrixCombo
511 for _, spec := range j.Matrix {
512 combos = append(combos, cartesian(spec)...)
513 }
514 if len(combos) > maxParallel {
515 return nil, i18n.E("ci.err.parallel", len(combos), maxParallel)
516 }
517 if len(combos) == 0 {
518 return nil, i18n.E("ci.err.parallel", 0, maxParallel)
519 }
520 var out []Job
521 for i, combo := range combos {
522 cp := copyJob(j)
523 cp.Name = j.Name + ": [" + strings.Join(combo.values, ", ") + "]"
524 cp.Parallel = 0
525 cp.Matrix = nil
526 for k, v := range combo.vars {
527 cp.Variables[k] = v
528 }
529 cp.Variables["CI_NODE_INDEX"] = strconv.Itoa(i + 1)
530 cp.Variables["CI_NODE_TOTAL"] = strconv.Itoa(len(combos))
531 out = append(out, cp)
532 }
533 return out, nil
534 }
535 if j.Parallel <= 1 {
536 return []Job{j}, nil
537 }
538 if j.Parallel > maxParallel {
539 return nil, i18n.E("ci.err.parallel", j.Parallel, maxParallel)
540 }
541 var out []Job
542 for i := 1; i <= j.Parallel; i++ {
543 cp := copyJob(j)
544 cp.Name = fmt.Sprintf("%s %d/%d", j.Name, i, j.Parallel)
545 cp.Parallel = 0
546 cp.Variables["CI_NODE_INDEX"] = strconv.Itoa(i)
547 cp.Variables["CI_NODE_TOTAL"] = strconv.Itoa(j.Parallel)
548 out = append(out, cp)
549 }
550 return out, nil
551}
552
553type matrixCombo struct {
554 values []string
555 vars map[string]string
556}
557
558func cartesian(spec MatrixSpec) []matrixCombo {
559 if len(spec.Keys) == 0 {
560 return nil
561 }
562 var out []matrixCombo
563 var walk func(i int, vals []string, vars map[string]string)
564 walk = func(i int, vals []string, vars map[string]string) {
565 if i == len(spec.Keys) {
566 cp := map[string]string{}
567 for k, v := range vars {
568 cp[k] = v
569 }
570 out = append(out, matrixCombo{values: append([]string{}, vals...), vars: cp})
571 return
572 }
573 for _, v := range spec.Vals[i] {
574 vars[spec.Keys[i]] = v
575 walk(i+1, append(vals, v), vars)
576 }
577 }
578 walk(0, nil, map[string]string{})
579 return out
580}
581
582func copyJob(j Job) Job {
583 cp := j
584 cp.Variables = map[string]string{}
585 for k, v := range j.Variables {
586 cp.Variables[k] = v
587 }
588 cp.Needs = append([]string{}, j.Needs...)
589 cp.Optional = append([]string{}, j.Optional...)
590 cp.Services = append([]Service{}, j.Services...)
591 return cp
592}
593
594func rewriteNeeds(list []string, expanded map[string][]string) []string {
595 if list == nil {
596 return nil
597 }
598 var out []string
599 for _, n := range list {
600 names := expanded[n]
601 if len(names) == 0 || (len(names) == 1 && names[0] == n) {
602 out = append(out, n)
603 continue
604 }
605 out = append(out, names...)
606 }
607 if out == nil {
608 return []string{}
609 }
610 return out
611}
612
613// Expand vervangt $NAAM en ${NAAM} in een tekst, bijvoorbeeld environment:url.
614func Expand(s string, env map[string]string) string {
615 var b strings.Builder
616 for i := 0; i < len(s); i++ {
617 if s[i] != '$' || i+1 >= len(s) {
618 b.WriteByte(s[i])
619 continue
620 }
621 if s[i+1] == '{' {
622 end := strings.IndexByte(s[i+2:], '}')
623 if end < 0 {
624 b.WriteByte('$')
625 continue
626 }
627 name := s[i+2 : i+2+end]
628 b.WriteString(env[name])
629 i += 2 + end
630 continue
631 }
632 j := i + 1
633 for j < len(s) && isIdent(s[j]) {
634 j++
635 }
636 if j == i+1 {
637 b.WriteByte('$')
638 continue
639 }
640 b.WriteString(env[s[i+1:j]])
641 i = j - 1
642 }
643 return b.String()
644}
645
646func contains(list []string, s string) bool {
647 for _, item := range list {
648 if item == s {
649 return true
650 }
651 }
652 return false
653}