| 1 | package ci |
| 2 | |
| 3 | import ( |
| 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. |
| 14 | func 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. |
| 72 | func 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 | |
| 83 | func 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 | |
| 91 | func 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. |
| 110 | func (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. |
| 154 | func (p Pipeline) ActiveJobs(env map[string]string) ([]Job, error) { |
| 155 | return p.Select(Eval{Env: env}) |
| 156 | } |
| 157 | |
| 158 | func (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 | |
| 187 | func 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 | |
| 210 | func 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 | |
| 243 | func 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 | |
| 280 | func 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 | |
| 291 | func 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. |
| 308 | func 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 | |
| 324 | func 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. |
| 358 | func 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 | |
| 435 | var ( |
| 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 | |
| 442 | type compiledRule struct { |
| 443 | kind string |
| 444 | name string |
| 445 | arg string |
| 446 | other string |
| 447 | null bool |
| 448 | re *regexp.Regexp |
| 449 | } |
| 450 | |
| 451 | func 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 | |
| 479 | func 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 | |
| 506 | func contains(list []string, s string) bool { |
| 507 | for _, item := range list { |
| 508 | if item == s { |
| 509 | return true |
| 510 | } |
| 511 | } |
| 512 | return false |
| 513 | } |