BlueGit

timfa bluegit

Files

bluegit / internal / ci / eval.go

eval.go

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