BlueGit

timfa bluegit

Files

bluegit / internal / ci / eval.go

eval.go

feat: merge-request-pipelines en merge na een geslaagde run
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed 24b281c4 History
eval.go 11.6 KiB Download Raw
1package ci
2
3import (
4 "fmt"
5 "path"
6 "regexp"
7 "strings"
8
9 "gitlab.com/Timfa/bluegit/internal/i18n"
10)
11
12// Variables zet de voorgedefinieerde CI_-variabelen. Job-specifieke namen
13// vult de runner zelf aan.
14func Variables(r Ref) map[string]string {
15 name := r.Name
16 kind := r.Kind
17 if kind == "" {
18 name, kind = SplitRef(r.FullRef)
19 }
20 short := r.SHA
21 if len(short) > 8 {
22 short = short[:8]
23 }
24 project := r.ProjectPath
25 ns, base := splitProject(project)
26 env := map[string]string{
27 "CI": "true",
28 "CI_CONFIG_PATH": "blue-ci-cd.yml",
29 "CI_SERVER_NAME": "BlueGit",
30 "CI_COMMIT_SHA": r.SHA,
31 "CI_COMMIT_SHORT_SHA": short,
32 "CI_COMMIT_REF": r.FullRef,
33 "CI_COMMIT_REF_NAME": name,
34 "CI_COMMIT_REF_SLUG": slug(name),
35 "CI_COMMIT_TITLE": r.Title,
36 "CI_COMMIT_BRANCH": "",
37 "CI_COMMIT_TAG": "",
38 "CI_DEFAULT_BRANCH": r.DefaultBranch,
39 "CI_PIPELINE_ID": fmt.Sprint(r.PipelineID),
40 "CI_PIPELINE_SOURCE": r.Source,
41 "CI_PIPELINE_URL": strings.TrimRight(r.ProjectURL, "/") + "/-/pipelines/" + fmt.Sprint(r.PipelineID),
42 "CI_PROJECT_PATH": project,
43 "CI_PROJECT_NAME": base,
44 "CI_PROJECT_NAMESPACE": ns,
45 "CI_PROJECT_URL": r.ProjectURL,
46 "CI_API_URL": r.APIURL,
47 }
48 if kind == "tag" {
49 env["CI_COMMIT_TAG"] = name
50 } else {
51 env["CI_COMMIT_BRANCH"] = name
52 }
53 if env["CI_PIPELINE_SOURCE"] == "" {
54 env["CI_PIPELINE_SOURCE"] = "push"
55 }
56 if r.MR != nil {
57 m := r.MR
58 env["CI_MERGE_REQUEST_ID"] = fmt.Sprint(m.ID)
59 env["CI_MERGE_REQUEST_IID"] = fmt.Sprint(m.IID)
60 env["CI_MERGE_REQUEST_TITLE"] = m.Title
61 env["CI_MERGE_REQUEST_SOURCE_BRANCH_NAME"] = m.SourceBranch
62 env["CI_MERGE_REQUEST_SOURCE_BRANCH_SHA"] = r.SHA
63 env["CI_MERGE_REQUEST_TARGET_BRANCH_NAME"] = m.TargetBranch
64 env["CI_MERGE_REQUEST_TARGET_BRANCH_SHA"] = m.TargetSHA
65 env["CI_MERGE_REQUEST_PROJECT_PATH"] = m.ProjectPath
66 env["CI_MERGE_REQUEST_PROJECT_URL"] = m.ProjectURL
67 }
68 return env
69}
70
71// SplitRef haalt de korte naam en het soort uit refs/heads of refs/tags.
72func SplitRef(ref string) (name, kind string) {
73 switch {
74 case strings.HasPrefix(ref, "refs/tags/"):
75 return strings.TrimPrefix(ref, "refs/tags/"), "tag"
76 case strings.HasPrefix(ref, "refs/heads/"):
77 return strings.TrimPrefix(ref, "refs/heads/"), "branch"
78 default:
79 return ref, "branch"
80 }
81}
82
83func splitProject(path string) (ns, name string) {
84 i := strings.LastIndex(path, "/")
85 if i < 0 {
86 return "", path
87 }
88 return path[:i], path[i+1:]
89}
90
91func slug(s string) string {
92 var b strings.Builder
93 prev := false
94 for _, r := range strings.ToLower(s) {
95 if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
96 b.WriteRune(r)
97 prev = false
98 continue
99 }
100 if !prev && b.Len() > 0 {
101 b.WriteByte('-')
102 prev = true
103 }
104 }
105 return strings.Trim(b.String(), "-")
106}
107
108// Select houdt de jobs waarvan de rules, only en except kloppen.
109// De When van de job wordt de when van de winnende rule.
110func (p Pipeline) Select(ev Eval) ([]Job, error) {
111 if ev.Env == nil {
112 ev.Env = map[string]string{}
113 }
114 var out []Job
115 active := map[string]bool{}
116 var pending []Job
117 for _, j := range p.Jobs {
118 ok, when, err := j.matches(ev)
119 if err != nil {
120 return nil, fmt.Errorf("job %s: %w", j.Name, err)
121 }
122 if !ok {
123 continue
124 }
125 if when == "" {
126 when = "on_success"
127 }
128 j.When = when
129 pending = append(pending, j)
130 active[j.Name] = true
131 }
132 for i := range pending {
133 var needs []string
134 for _, n := range pending[i].Needs {
135 if active[n] {
136 needs = append(needs, n)
137 continue
138 }
139 if contains(pending[i].Optional, n) {
140 continue
141 }
142 needs = append(needs, n)
143 }
144 if needs == nil {
145 needs = []string{}
146 }
147 pending[i].Needs = needs
148 out = append(out, pending[i])
149 }
150 return out, nil
151}
152
153// ActiveJobs is Select met alleen variabelen. changes en exists gelden dan als waar.
154func (p Pipeline) ActiveJobs(env map[string]string) ([]Job, error) {
155 return p.Select(Eval{Env: env})
156}
157
158func (j Job) matches(ev Eval) (bool, string, error) {
159 when := j.When
160 if when == "" {
161 when = "on_success"
162 }
163 if len(j.Rules) == 0 {
164 ok, err := onlyExcept(j, ev)
165 return ok, when, err
166 }
167 for _, r := range j.Rules {
168 ok, err := ruleMatch(r, ev)
169 if err != nil {
170 return false, "", err
171 }
172 if !ok {
173 continue
174 }
175 w := r.When
176 if w == "" {
177 w = when
178 }
179 if w == "never" {
180 return false, w, nil
181 }
182 return true, w, nil
183 }
184 return false, "", nil
185}
186
187func ruleMatch(r Rule, ev Eval) (bool, error) {
188 if r.If != "" {
189 ok, err := evalRule(r.If, ev.Env)
190 if err != nil || !ok {
191 return ok, err
192 }
193 }
194 if len(r.Changes) > 0 && ev.Changed != nil {
195 if !anyGlob(r.Changes, ev.Changed) {
196 return false, nil
197 }
198 }
199 if len(r.Exists) > 0 && ev.Files != nil {
200 if !allExist(r.Exists, ev.Files) {
201 return false, nil
202 }
203 }
204 if r.If == "" && len(r.Changes) == 0 && len(r.Exists) == 0 && r.When == "" {
205 return false, nil
206 }
207 return true, nil
208}
209
210func onlyExcept(j Job, ev Eval) (bool, error) {
211 mr := ev.Env["CI_PIPELINE_SOURCE"] == "merge_request_event"
212 if len(j.Only) == 0 && len(j.Except) == 0 {
213 // Zonder rules of only draait een job op een branch of tag,
214 // niet in een merge-request-pipeline.
215 if mr {
216 return false, nil
217 }
218 return true, nil
219 }
220 name := ev.Env["CI_COMMIT_REF_NAME"]
221 if name == "" {
222 name = ev.Env["CI_COMMIT_BRANCH"]
223 }
224 tag := ev.Env["CI_COMMIT_TAG"] != ""
225 if len(j.Only) > 0 {
226 ok, err := refListed(j.Only, name, tag, mr)
227 if err != nil || !ok {
228 return false, err
229 }
230 }
231 if len(j.Except) > 0 {
232 ok, err := refListed(j.Except, name, tag, mr)
233 if err != nil {
234 return false, err
235 }
236 if ok {
237 return false, nil
238 }
239 }
240 return true, nil
241}
242
243func refListed(list []string, name string, tag, mr bool) (bool, error) {
244 for _, item := range list {
245 switch item {
246 case "merge_requests":
247 if mr {
248 return true, nil
249 }
250 case "branches":
251 if !tag && !mr {
252 return true, nil
253 }
254 case "tags":
255 if tag && !mr {
256 return true, nil
257 }
258 default:
259 if mr {
260 continue
261 }
262 if strings.HasPrefix(item, "/") && strings.HasSuffix(item, "/") && len(item) > 2 {
263 re, err := regexp.Compile(item[1 : len(item)-1])
264 if err != nil {
265 return false, i18n.E("ci.err.regex", item, err.Error())
266 }
267 if re.MatchString(name) {
268 return true, nil
269 }
270 continue
271 }
272 if item == name {
273 return true, nil
274 }
275 }
276 }
277 return false, nil
278}
279
280func anyGlob(patterns, names []string) bool {
281 for _, name := range names {
282 for _, pattern := range patterns {
283 if Glob(pattern, name) {
284 return true
285 }
286 }
287 }
288 return false
289}
290
291func allExist(patterns, files []string) bool {
292 for _, pattern := range patterns {
293 found := false
294 for _, file := range files {
295 if file == pattern || Glob(pattern, file) {
296 found = true
297 break
298 }
299 }
300 if !found {
301 return false
302 }
303 }
304 return true
305}
306
307// Glob volgt GitLab-padpatronen: * blijft in één segment, ** loopt door mappen.
308func Glob(pattern, name string) bool {
309 pattern = strings.TrimPrefix(pattern, "/")
310 name = strings.TrimPrefix(name, "/")
311 if pattern == name {
312 return true
313 }
314 re := globRegexp(pattern)
315 if re.MatchString(name) {
316 return true
317 }
318 if !strings.Contains(pattern, "/") && re.MatchString(path.Base(name)) {
319 return true
320 }
321 return false
322}
323
324func globRegexp(pattern string) *regexp.Regexp {
325 var b strings.Builder
326 b.WriteString("^")
327 for i := 0; i < len(pattern); i++ {
328 if pattern[i] == '*' && i+1 < len(pattern) && pattern[i+1] == '*' {
329 b.WriteString(".*")
330 i++
331 if i+1 < len(pattern) && pattern[i+1] == '/' {
332 i++
333 }
334 continue
335 }
336 switch pattern[i] {
337 case '*':
338 b.WriteString("[^/]*")
339 case '?':
340 b.WriteString("[^/]")
341 default:
342 b.WriteString(regexp.QuoteMeta(pattern[i : i+1]))
343 }
344 }
345 b.WriteString("$")
346 return regexp.MustCompile(b.String())
347}
348
349// Gate beslist of een job mag starten.
350// "ready" betekent dat alle voorgangers klaar zijn.
351// "wait" betekent dat er nog een voorganger loopt of in de wachtrij staat.
352// "skip" betekent dat een voorganger mislukte zonder allow_failure,
353// of dat when: on_failure geen mislukking zag.
354// "fail" betekent dat een verplichte need niet in deze pipeline zit.
355//
356// NeedsSet volgt de genoemde jobs, ook als de lijst leeg is.
357// Zonder needs wacht de job op alle jobs in eerdere stages.
358func Gate(jobs []Job, status map[string]string, job Job) string {
359 byName := map[string]Job{}
360 for _, j := range jobs {
361 byName[j.Name] = j
362 }
363 optional := map[string]bool{}
364 for _, n := range job.Optional {
365 optional[n] = true
366 }
367 var deps []Job
368 if job.NeedsSet {
369 for _, n := range job.Needs {
370 d, ok := byName[n]
371 if !ok {
372 if optional[n] {
373 continue
374 }
375 return "fail"
376 }
377 deps = append(deps, d)
378 }
379 } else {
380 stagePos := map[string]int{}
381 order := 0
382 for _, j := range jobs {
383 if _, ok := stagePos[j.Stage]; !ok {
384 stagePos[j.Stage] = order
385 order++
386 }
387 }
388 my := stagePos[job.Stage]
389 for _, j := range jobs {
390 if stagePos[j.Stage] < my {
391 deps = append(deps, j)
392 }
393 }
394 }
395 failedAny := false
396 failedHard := false
397 for _, d := range deps {
398 switch status[d.Name] {
399 case "success", "skipped":
400 continue
401 case "failed":
402 failedAny = true
403 if !d.AllowFailure {
404 failedHard = true
405 }
406 case "manual":
407 if d.AllowFailure {
408 continue
409 }
410 return "wait"
411 default:
412 return "wait"
413 }
414 }
415 when := job.When
416 if when == "" {
417 when = "on_success"
418 }
419 switch when {
420 case "always":
421 return "ready"
422 case "on_failure":
423 if failedAny {
424 return "ready"
425 }
426 return "skip"
427 default:
428 if failedHard {
429 return "skip"
430 }
431 return "ready"
432 }
433}
434
435var (
436 reEq = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*==\s*(?:"([^"]*)"|\$([A-Za-z_][A-Za-z0-9_]*)|null)$`)
437 reNe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*!=\s*(?:"([^"]*)"|\$([A-Za-z_][A-Za-z0-9_]*)|null)$`)
438 reRe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*=~\s*/(.*)/$`)
439 reNRe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*!~\s*/(.*)/$`)
440)
441
442type compiledRule struct {
443 kind string
444 name string
445 arg string
446 other string
447 null bool
448 re *regexp.Regexp
449}
450
451func compileRule(expr string) (compiledRule, error) {
452 expr = strings.TrimSpace(expr)
453 if strings.Contains(expr, "&&") || strings.Contains(expr, "||") {
454 return compiledRule{}, i18n.E("ci.err.ruleCombine", expr)
455 }
456 if m := reEq.FindStringSubmatch(expr); m != nil {
457 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
458 }
459 if m := reNe.FindStringSubmatch(expr); m != nil {
460 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
461 }
462 if m := reRe.FindStringSubmatch(expr); m != nil {
463 re, err := regexp.Compile(m[2])
464 if err != nil {
465 return compiledRule{}, i18n.E("ci.err.regex", expr, err.Error())
466 }
467 return compiledRule{kind: "re", name: m[1], re: re}, nil
468 }
469 if m := reNRe.FindStringSubmatch(expr); m != nil {
470 re, err := regexp.Compile(m[2])
471 if err != nil {
472 return compiledRule{}, i18n.E("ci.err.regex", expr, err.Error())
473 }
474 return compiledRule{kind: "nre", name: m[1], re: re}, nil
475 }
476 return compiledRule{}, i18n.E("ci.err.ruleExpr", expr)
477}
478
479func evalRule(expr string, env map[string]string) (bool, error) {
480 c, err := compileRule(expr)
481 if err != nil {
482 return false, err
483 }
484 val := env[c.name]
485 right := c.arg
486 if c.other != "" {
487 right = env[c.other]
488 }
489 if c.null {
490 right = ""
491 }
492 switch c.kind {
493 case "eq":
494 return val == right, nil
495 case "ne":
496 return val != right, nil
497 case "re":
498 return c.re.MatchString(val), nil
499 case "nre":
500 return !c.re.MatchString(val), nil
501 default:
502 return false, i18n.E("ci.err.ruleExpr", expr)
503 }
504}
505
506func contains(list []string, s string) bool {
507 for _, item := range list {
508 if item == s {
509 return true
510 }
511 }
512 return false
513}