BlueGit

timfa bluegit

Files

bluegit / internal / runner / runner.go

runner.go

runner.go 37.8 KiB Download Raw
1// Package runner voert pipelinejobs uit, elk in een eigen Docker-container.
2package runner
3
4import (
5 "bytes"
6 "context"
7 "errors"
8 "fmt"
9 "io"
10 "io/fs"
11 "log/slog"
12 "os"
13 "os/exec"
14 "path/filepath"
15 "strconv"
16 "strings"
17 "sync"
18 "sync/atomic"
19 "time"
20
21 "gitlab.com/Timfa/bluegit/internal/access"
22 "gitlab.com/Timfa/bluegit/internal/ci"
23 "gitlab.com/Timfa/bluegit/internal/gitrepo"
24 "gitlab.com/Timfa/bluegit/internal/images"
25 "gitlab.com/Timfa/bluegit/internal/runnercfg"
26 "gitlab.com/Timfa/bluegit/internal/store"
27 "gitlab.com/Timfa/bluegit/internal/webhook"
28)
29
30// Runner plant jobs en stuurt het resultaat door naar webhooks.
31type Runner struct {
32 // Hold houdt een pipeline vast, bijvoorbeeld tijdens een self-update.
33 Hold func(store.Pipeline) bool
34 Store *store.Store
35 GitBin string
36 Docker string
37 Storage string
38 BaseURL string
39 Network string
40 Name string
41 Timeout time.Duration
42 Log *slog.Logger
43 OnEvent func(repoID int64, ev webhook.Event)
44 // Presets zijn de image-aliassen uit ci.presets. Nil is de ingebouwde lijst.
45 Presets map[string]images.Override
46 // Jobs is het overzicht en de pauze (drain) voor de beheer-UI.
47 Jobs *runnercfg.Tracker
48 ctl control
49 slots chan struct{}
50 mu sync.RWMutex
51 cancelMu sync.Mutex
52 // protected telt lopende doNotInterrupt-jobs van de ingebouwde runner.
53 protected atomic.Int64
54 cancel map[int64]context.CancelFunc
55}
56
57// Interrupt stopt lopende jobs waarvan een nieuwere pipeline de beurt overneemt.
58func (r *Runner) Interrupt(ids []int64) {
59 r.cancelMu.Lock()
60 defer r.cancelMu.Unlock()
61 for _, id := range ids {
62 if c := r.cancel[id]; c != nil {
63 c()
64 }
65 }
66}
67
68// cancelReason leest waarom een lopende job gestopt werd. CancelJob (door
69// een gebruiker) zet canceled_by_user al in de database; anders was het
70// een nieuwere pipeline op dezelfde ref.
71func (r *Runner) cancelReason(repoID, id int64) string {
72 if j, err := r.Store.JobByID(context.Background(), repoID, id); err == nil && j.Reason == "canceled_by_user" {
73 return j.Reason
74 }
75 return "canceled_by_newer_pipeline"
76}
77
78func cancelText(reason string) string {
79 if reason == "canceled_by_user" {
80 return "canceled by a user"
81 }
82 return "canceled because a newer pipeline started for the same ref"
83}
84
85func (r *Runner) track(id int64, cancel context.CancelFunc) {
86 r.cancelMu.Lock()
87 defer r.cancelMu.Unlock()
88 if r.cancel == nil {
89 r.cancel = map[int64]context.CancelFunc{}
90 }
91 r.cancel[id] = cancel
92}
93
94func (r *Runner) untrack(id int64) {
95 r.cancelMu.Lock()
96 defer r.cancelMu.Unlock()
97 delete(r.cancel, id)
98}
99
100// SetStorage wijzigt het pad waarop jobs hun clone en artifacts zetten.
101func (r *Runner) SetStorage(path string) {
102 r.mu.Lock()
103 r.Storage = path
104 r.mu.Unlock()
105}
106
107func (r *Runner) storage() string {
108 r.mu.RLock()
109 defer r.mu.RUnlock()
110 return r.Storage
111}
112
113// Loop blijft jobs oppakken tot ctx afloopt.
114func (r *Runner) Loop(ctx context.Context, concurrency int) {
115 if concurrency < 1 {
116 concurrency = 1
117 }
118 r.slots = make(chan struct{}, maxSlots)
119 r.mu.Lock()
120 if !r.ctl.set {
121 r.ctl.limit = concurrency
122 }
123 r.mu.Unlock()
124 tick := time.NewTicker(2 * time.Second)
125 defer tick.Stop()
126 for {
127 select {
128 case <-ctx.Done():
129 return
130 case <-tick.C:
131 r.Tick(ctx)
132 }
133 }
134}
135
136// Tick bekijkt alle open pipelines één keer.
137// Zonder opslagpad gebeurt er niets.
138func (r *Runner) Tick(ctx context.Context) {
139 if r.storage() == "" {
140 return
141 }
142 pipes, err := r.Store.ActivePipelines(ctx)
143 if err != nil {
144 r.Log.Error("pipelines", "err", err)
145 return
146 }
147 for _, p := range pipes {
148 r.schedule(ctx, p)
149 }
150 r.reapRemote(ctx)
151}
152
153func (r *Runner) schedule(ctx context.Context, p store.Pipeline) {
154 r.settle(ctx, p.ID)
155 if r.Hold != nil && r.Hold(p) {
156 return // wacht op de self-update
157 }
158 jobs, err := r.Store.JobsByPipeline(ctx, p.ID)
159 if err != nil {
160 r.Log.Error("jobs", "err", err)
161 return
162 }
163 specs := make([]ci.Job, len(jobs))
164 status := map[string]string{}
165 for i, j := range jobs {
166 specs[i] = ci.Job{Name: j.Name, Stage: j.Stage, Needs: j.Needs, Optional: j.Optional, NeedsSet: j.NeedsSet, AllowFailure: j.AllowFailure, When: j.When}
167 status[j.Name] = j.Status
168 }
169 tierCache := map[int64][]Tier{}
170 for _, j := range jobs {
171 if j.Status != "queued" && j.Status != "manual" {
172 continue
173 }
174 switch ci.Gate(specs, status, specs[indexOf(jobs, j.Name)]) {
175 case "skip":
176 _ = r.Store.SkipJob(ctx, j.ID, "skipped because an earlier job failed\n")
177 status[j.Name] = "skipped"
178 case "fail":
179 _ = r.Store.FinishJob(ctx, j.ID, "failed", "a required job is not part of this pipeline\n")
180 status[j.Name] = "failed"
181 case "ready":
182 if j.Status != "queued" {
183 continue
184 }
185 if busy, _ := r.Store.ResourceBusy(ctx, j.RepoID, j.ResourceGroup, j.ID); busy {
186 continue
187 }
188 // Meer jobs dan ci.concurrency blijven queued, met een plek
189 // in de wachtrij. Het slot gaat pas vrij als execute klaar is.
190 free := r.acquireSlot()
191 prot := r.refProtected(ctx, j.RepoID, p.Ref)
192 if prot {
193 r.noteProtected(ctx, j.RepoID, j)
194 }
195 if tiers := r.tiersFor(ctx, tierCache, j.RepoID, prot); len(tiers) > 1 {
196 jr := r.Store.JobRun(ctx, j.ID)
197 step := Advance(tiers, jr.OfferTier, jr.OfferAt, time.Now(), free)
198 if !step.Builtin {
199 if free {
200 r.releaseSlot()
201 }
202 if step.Moved {
203 _ = r.Store.SetJobOffer(ctx, j.ID, step.Tier, time.Now())
204 }
205 continue
206 }
207 }
208 if !free {
209 continue
210 }
211 ok, err := r.Store.MarkJobRunning(ctx, j.ID)
212 if err != nil || !ok {
213 r.releaseSlot()
214 continue
215 }
216 _ = r.Store.SetJobRunner(ctx, j.ID, 0, r.BuiltinName())
217 _ = r.Store.ClearJobOffer(ctx, j.ID)
218 status[j.Name] = "running"
219 job := j
220 pipe := p
221 go r.execute(ctx, pipe, job)
222 }
223 }
224}
225
226// settle slaat jobs over die door een harde mislukking of een
227// overgeslagen need niet meer hoeven. Dat gebeurt meteen, ook als de
228// pipelinestatus al op failed was gezet.
229func (r *Runner) settle(ctx context.Context, pipelineID int64) {
230 for {
231 jobs, err := r.Store.JobsByPipeline(ctx, pipelineID)
232 if err != nil {
233 if r.Log != nil {
234 r.Log.Error("jobs", "err", err)
235 }
236 return
237 }
238 specs := make([]ci.Job, len(jobs))
239 status := map[string]string{}
240 for i, j := range jobs {
241 specs[i] = ci.Job{Name: j.Name, Stage: j.Stage, Needs: j.Needs, Optional: j.Optional, NeedsSet: j.NeedsSet, AllowFailure: j.AllowFailure, When: j.When}
242 status[j.Name] = j.Status
243 }
244 moved := false
245 for _, j := range jobs {
246 if j.Status != "queued" && j.Status != "manual" {
247 continue
248 }
249 switch ci.Gate(specs, status, specs[indexOf(jobs, j.Name)]) {
250 case "skip":
251 if err := r.Store.SkipJob(ctx, j.ID, "skipped because an earlier job failed\n"); err != nil && r.Log != nil {
252 r.Log.Error("skip", "err", err)
253 continue
254 }
255 status[j.Name] = "skipped"
256 moved = true
257 case "fail":
258 if err := r.Store.FinishJob(ctx, j.ID, "failed", "a required job is not part of this pipeline\n"); err != nil && r.Log != nil {
259 r.Log.Error("fail", "err", err)
260 continue
261 }
262 status[j.Name] = "failed"
263 moved = true
264 }
265 }
266 if !moved {
267 return
268 }
269 }
270}
271
272// BuiltinName is de naam van de ingebouwde runner in de job-UI.
273func (r *Runner) BuiltinName() string {
274 if r.Name != "" {
275 return r.Name
276 }
277 return "BlueGit runner"
278}
279
280func (r *Runner) tiersFor(ctx context.Context, cache map[int64][]Tier, repoID int64, protected bool) []Tier {
281 key := repoID * 2
282 if protected {
283 key++
284 }
285 if t, ok := cache[key]; ok {
286 return t
287 }
288 var tiers []Tier
289 if repo, err := r.Store.RepoByID(ctx, repoID); err == nil {
290 tiers, _ = Tiers(ctx, r.Store, repo, protected)
291 }
292 cache[key] = tiers
293 return tiers
294}
295
296// refProtected: draait een pipeline op een beschermde branch (en krijgt
297// hij dus beschermde geheimen)?
298func (r *Runner) refProtected(ctx context.Context, repoID int64, ref string) bool {
299 name, _ := ci.SplitRef(ref)
300 patterns, err := r.Store.ProtectedPatterns(ctx, repoID)
301 if err != nil {
302 return true // bij twijfel streng
303 }
304 return access.BranchProtected(patterns, name)
305}
306
307var protectedNoted sync.Map // job id → melding al in het log
308
309// noteProtected zet één keer een melding in het joblog als er opt-in
310// runners zijn die deze job niet mogen draaien.
311func (r *Runner) noteProtected(ctx context.Context, repoID int64, job store.Job) {
312 if _, done := protectedNoted.LoadOrStore(job.ID, true); done {
313 return
314 }
315 repo, err := r.Store.RepoByID(ctx, repoID)
316 if err != nil {
317 return
318 }
319 if names := ExcludedForProtected(ctx, r.Store, repo); len(names) > 0 {
320 _ = r.Store.AppendJobLog(ctx, job.ID, "Protected branch: this job only runs on the built-in runner, global runners, group runners and account runners of maintainers. Skipped: "+strings.Join(names, ", ")+"\n")
321 }
322}
323
324func indexOf(jobs []store.Job, name string) int {
325 for i, j := range jobs {
326 if j.Name == name {
327 return i
328 }
329 }
330 return 0
331}
332
333func (r *Runner) acquireSlot() bool {
334 if r.Paused() {
335 return false
336 }
337 if r.slots == nil {
338 return true
339 }
340 if l := r.controls().limit; l > 0 && len(r.slots) >= l {
341 return false
342 }
343 select {
344 case r.slots <- struct{}{}:
345 return true
346 default:
347 return false
348 }
349}
350
351func (r *Runner) releaseSlot() {
352 if r.slots == nil {
353 return
354 }
355 select {
356 case <-r.slots:
357 default:
358 }
359}
360
361func (r *Runner) execute(ctx context.Context, p store.Pipeline, job store.Job) {
362 defer r.releaseSlot()
363 before, _ := r.Store.PipelineByID(context.Background(), p.RepoID, p.ID)
364 parent := ctx
365 if job.DoNotInterrupt {
366 // Een herstart of stop van BlueGit breekt deze job niet af; main
367 // wacht met afsluiten tot hij klaar is (zie WaitProtected).
368 parent = context.WithoutCancel(ctx)
369 r.protected.Add(1)
370 defer r.protected.Add(-1)
371 }
372 base, stop := context.WithCancel(parent)
373 r.track(job.ID, stop)
374 defer func() {
375 r.untrack(job.ID)
376 stop()
377 }()
378 runCtx := base
379 limit, source := EffectiveTimeout(job.Timeout, r.Timeout, r.controls().timeout)
380 r.trackStart(job)
381 if limit > 0 {
382 var cancel context.CancelFunc
383 runCtx, cancel = context.WithTimeout(base, limit)
384 defer cancel()
385 }
386 mask, err := r.runOne(runCtx, p, job)
387 status := "success"
388 extra := ""
389 kind := ""
390 switch {
391 case err == nil:
392 case parent.Err() == nil && base.Err() != nil:
393 status = "canceled"
394 kind = r.cancelReason(job.RepoID, job.ID)
395 extra = stamp(cancelText(kind))
396 case errors.Is(runCtx.Err(), context.DeadlineExceeded):
397 status = "failed"
398 kind = "job_execution_timeout"
399 extra = stamp(TimedOutLine(limit, source))
400 default:
401 status = "failed"
402 kind = classifyFailure(err)
403 extra = stamp(ci.Mask(err.Error(), mask))
404 }
405 r.trackDone(job.ID, status)
406 r.complete(p, job, before, status, extra, kind)
407}
408
409// complete rondt een job af: opnieuw proberen, afronden, pipelinestatus
410// en webhook. Gedeeld door de ingebouwde en de aparte runner.
411func (r *Runner) complete(p store.Pipeline, job store.Job, before store.Pipeline, status, extra, kind string) {
412 if status == "failed" && shouldRetry(job, kind) {
413 note := stamp(fmt.Sprintf("retrying (%d/%d) after %s", job.Attempt+1, job.RetryMax, kind))
414 _ = r.Store.ClearJobOffer(context.Background(), job.ID)
415 if ferr := r.Store.RequeueJob(context.Background(), job.ID, job.Attempt+1, note+extra); ferr != nil && r.Log != nil {
416 r.Log.Error("job opnieuw", "err", ferr)
417 } else if ferr == nil {
418 r.settle(context.Background(), p.ID)
419 if _, rerr := r.Store.RefreshPipelineStatus(context.Background(), p.ID); rerr != nil && r.Log != nil {
420 r.Log.Error("pipelinestatus", "err", rerr)
421 }
422 return
423 }
424 }
425 if ferr := r.Store.FinishJobReason(context.Background(), job.ID, status, extra, kind); ferr != nil {
426 r.Log.Error("job afronden", "err", ferr)
427 }
428 r.settle(context.Background(), p.ID)
429 final, rerr := r.Store.RefreshPipelineStatus(context.Background(), p.ID)
430 if rerr != nil {
431 r.Log.Error("pipelinestatus", "err", rerr)
432 return
433 }
434 if before.Status != final && (final == "success" || final == "failed") && r.OnEvent != nil {
435 kind := webhook.EventPipelineSuccess
436 word := "geslaagd"
437 if final == "failed" {
438 kind = webhook.EventPipelineFailure
439 word = "mislukt"
440 }
441 repo, err := r.Store.RepoByID(context.Background(), p.RepoID)
442 if err != nil {
443 return
444 }
445 branch, _ := gitrepo.BranchOfRef(p.Ref)
446 if branch == "" {
447 branch = strings.TrimPrefix(p.Ref, "refs/heads/")
448 }
449 r.OnEvent(p.RepoID, webhook.Event{
450 Type: kind,
451 Project: repo.FullPath(),
452 Branch: branch,
453 Commit: p.CommitSHA,
454 Summary: fmt.Sprintf("pipeline #%d voor %s is %s", p.ID, repo.FullPath(), word),
455 URL: strings.TrimRight(r.BaseURL, "/") + "/" + repo.FullPath() + "/-/pipelines/" + fmt.Sprint(p.ID),
456 PipelineID: fmt.Sprint(p.ID),
457 })
458 }
459}
460
461func (r *Runner) runOne(ctx context.Context, p store.Pipeline, job store.Job) ([]string, error) {
462 repo, err := r.Store.RepoByID(ctx, p.RepoID)
463 if err != nil {
464 return nil, err
465 }
466 sink := &logSink{store: r.Store, jobID: job.ID}
467 sink.section("prepare", "Preparing the docker executor")
468 work := filepath.Join(r.storage(), "work", fmt.Sprint(p.ID), safeSegment(job.Name))
469 if err := clearWorkDir(work); err != nil {
470 sink.closeSection()
471 return nil, fmt.Errorf("runner_system_failure: work dir: %w", err)
472 }
473 if err := os.MkdirAll(work, 0o755); err != nil {
474 sink.closeSection()
475 return nil, err
476 }
477 // Na afloop (ook bij falen of annuleren) gaat de werkmap weg. Artifacts
478 // en cache staan dan al gekopieerd buiten de werkmap (collect, saveCache)
479 // en de container is gestopt. Met cleanup_work uit blijft hij staan.
480 defer r.finishWorkDir(work)
481 bare := gitrepo.Dir(r.storage(), repo.OwnerPath, repo.Name)
482 if _, err := execOut(ctx, r.GitBin, cloneArgs(bare, work)...); err != nil {
483 sink.closeSection()
484 return nil, fmt.Errorf("clone: %w", err)
485 }
486 // origin wijst naar de echte repo-URL, niet naar het pad van de bare repo
487 // op de host. In de container kan de job zo met CI_JOB_TOKEN fetchen.
488 if r.BaseURL != "" {
489 _, _ = execOut(ctx, r.GitBin, "-C", work, "remote", "set-url", "origin", strings.TrimRight(r.BaseURL, "/")+"/"+repo.FullPath()+".git")
490 }
491 if _, err := execOut(ctx, r.GitBin, "-C", work, "checkout", "--detach", p.CommitSHA); err != nil {
492 sink.closeSection()
493 return nil, fmt.Errorf("checkout %s: %w", p.CommitSHA, err)
494 }
495 if err := r.restoreCache(repo.ID, job, work); err != nil {
496 sink.closeSection()
497 return nil, err
498 }
499 if err := r.materialize(ctx, p, job, work); err != nil {
500 sink.closeSection()
501 return nil, err
502 }
503 scriptPath := filepath.Join(work, ".bluegit-job.sh")
504 host, _ := os.Hostname()
505 script := shellScript(job, placeNote{
506 Runner: r.Name, Host: host, WorkDir: "/workspace",
507 PipelineID: p.ID, JobID: job.ID,
508 })
509 if err := os.WriteFile(scriptPath, []byte(script), 0o755); err != nil {
510 sink.closeSection()
511 return nil, err
512 }
513 token, err := r.Store.CreateJobToken(ctx, job.ID)
514 if err != nil {
515 sink.closeSection()
516 return nil, err
517 }
518 env, mask, err := r.environment(ctx, repo, p, job, token)
519 if err != nil {
520 sink.closeSection()
521 return nil, err
522 }
523 sink.secrets = mask
524 if err := r.execContainer(ctx, sink, job, work, env); err != nil {
525 return mask, err
526 }
527 if err := r.collect(ctx, job, work); err != nil {
528 return mask, err
529 }
530 if err := r.saveCache(repo.ID, job, work); err != nil {
531 return mask, err
532 }
533 return mask, nil
534}
535
536// execContainer haalt het image op, start services en draait het
537// jobscript in de container. De sectie prepare moet open staan.
538func (r *Runner) execContainer(ctx context.Context, sink *logSink, job store.Job, work string, env map[string]string) error {
539 ref, lines, rerr := r.resolveImage(ctx, job.Image)
540 for _, line := range lines {
541 sink.emit(line)
542 }
543 if rerr != nil {
544 sink.closeSection()
545 return rerr
546 }
547 job.Image = ref
548 job.Services = append([]store.Service(nil), job.Services...)
549 for i := range job.Services {
550 sref, slines, serr := r.resolveImage(ctx, job.Services[i].Name)
551 for _, line := range slines {
552 sink.emit(line)
553 }
554 if serr != nil {
555 sink.closeSection()
556 return serr
557 }
558 job.Services[i].Name = sref
559 }
560 network := r.Network
561 if network == "" {
562 network = "bridge"
563 }
564 if len(job.Services) > 0 {
565 net, cleanup, serr := r.startServices(ctx, job)
566 if serr != nil {
567 sink.closeSection()
568 return serr
569 }
570 defer cleanup()
571 network = net
572 }
573 sink.closeSection()
574 // -e NAAM zonder waarde laat Docker de variabele uit de omgeving van
575 // deze client overnemen. Zo blijft een meerregelige sleutel heel en
576 // staat de waarde niet in de proceslijst.
577 // Een vaste naam per job: een geannuleerde of afgebroken container
578 // (de docker-client stopt dan, de container niet) wordt voor de start en
579 // na afloop opgeruimd.
580 cname := fmt.Sprintf("bluegit-job-%d", job.ID)
581 removeContainer(r.Docker, cname)
582 defer removeContainer(r.Docker, cname)
583 args := []string{"run", "--rm", "--name", cname, "--network", network, "-v", work + ":/workspace", "-w", "/workspace"}
584 ctl := r.controls()
585 args = append(args, ctl.runArgs...)
586 if ctl.pull == runnercfg.PullNever {
587 args = append(args, "--pull", "never")
588 }
589 cmdEnv := append([]string{}, os.Environ()...)
590 for k, v := range env {
591 args = append(args, "-e", k)
592 cmdEnv = append(cmdEnv, k+"="+v)
593 }
594 args = append(args, "--entrypoint", "sh", job.Image, "/workspace/.bluegit-job.sh")
595 cmd := exec.CommandContext(ctx, r.Docker, args...)
596 cmd.Env = cmdEnv
597 cmd.Stdout = sink
598 cmd.Stderr = sink
599 err := cmd.Run()
600 sink.flush()
601 if err != nil {
602 return fmt.Errorf("container ended with an error: %w", err)
603 }
604 return nil
605}
606
607func removeContainer(docker, name string) {
608 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
609 defer cancel()
610 _, _ = execOut(ctx, docker, "rm", "-f", name)
611}
612
613// finishWorkDir ruimt de werkmap van een afgelopen job op, plus de lege
614// pipelinemap erboven, tenzij de instelling cleanup_work uit staat.
615func (r *Runner) finishWorkDir(work string) {
616 if r.controls().keep {
617 return
618 }
619 _ = clearWorkDir(work)
620 _ = os.Remove(filepath.Dir(work)) // alleen als hij leeg is
621}
622
623// ClearWorkDir is clearWorkDir voor de aparte runner.
624func ClearWorkDir(work string) error { return clearWorkDir(work) }
625
626// clearWorkDir maakt de werkmap leeg. Mappen zonder schrijfrecht (uit een
627// container) worden eerst beschrijfbaar gemaakt. Lukt verwijderen dan nog
628// niet (bestanden van root), dan gaat de oude map opzij, zodat de clone in
629// een lege map begint. Alleen als ook dat faalt, is het een fout.
630func clearWorkDir(work string) error {
631 if err := os.RemoveAll(work); err == nil {
632 return nil
633 }
634 _ = filepath.WalkDir(work, func(p string, d fs.DirEntry, err error) error {
635 if err == nil && d.IsDir() {
636 _ = os.Chmod(p, 0o755)
637 }
638 return nil
639 })
640 if err := os.RemoveAll(work); err == nil {
641 return nil
642 }
643 stale := fmt.Sprintf("%s.stale-%d", work, time.Now().UnixNano())
644 if err := os.Rename(work, stale); err != nil {
645 return err
646 }
647 go func() { _ = os.RemoveAll(stale) }()
648 return nil
649}
650
651// placeNote zijn de vaste regels in de sectie Preparing environment.
652type placeNote struct {
653 Runner string
654 Host string
655 WorkDir string
656 PipelineID int64
657 JobID int64
658}
659
660func (n placeNote) lines() []string {
661 runner := strings.TrimSpace(n.Runner)
662 if runner == "" {
663 runner = "Steve"
664 }
665 host := strings.TrimSpace(n.Host)
666 if host == "" {
667 host = "localhost"
668 }
669 dir := strings.TrimSpace(n.WorkDir)
670 if dir == "" {
671 dir = "/workspace"
672 }
673 return []string{
674 fmt.Sprintf("Running on %s via %s...", runner, host),
675 fmt.Sprintf("Working directory: %s", dir),
676 fmt.Sprintf("Pipeline #%d, job #%d", n.PipelineID, n.JobID),
677 }
678}
679
680func shSingle(s string) string {
681 return "'" + strings.ReplaceAll(s, "'", `'"'"'`) + "'"
682}
683
684func shellScript(job store.Job, note placeNote) string {
685 var b strings.Builder
686 b.WriteString("#!/bin/sh\ncd /workspace\nrc=0\n")
687 fmt.Fprintf(&b, "echo \"section_start:before:Preparing environment\"\n")
688 for _, line := range note.lines() {
689 fmt.Fprintf(&b, "echo %s\n", shSingle(line))
690 }
691 if strings.TrimSpace(job.Before) != "" {
692 b.WriteString("(\nset -e\n")
693 b.WriteString(job.Before)
694 if !strings.HasSuffix(job.Before, "\n") {
695 b.WriteByte('\n')
696 }
697 b.WriteString(")\nbrc=$?\n")
698 } else {
699 b.WriteString("brc=0\n")
700 }
701 b.WriteString("echo \"section_end:before:Preparing environment\"\n")
702 b.WriteString("echo \"section_start:script:Running script\"\n")
703 b.WriteString("if [ \"$brc\" -eq 0 ]; then\n(\nset -e\n")
704 b.WriteString(job.Script)
705 if !strings.HasSuffix(job.Script, "\n") {
706 b.WriteByte('\n')
707 }
708 b.WriteString(")\nrc=$?\nelse\nrc=$brc\nfi\n")
709 b.WriteString("echo \"section_end:script:Running script\"\n")
710 b.WriteString("echo \"section_start:after:After script\"\n")
711 if strings.TrimSpace(job.After) != "" {
712 b.WriteString("(\nset -e\n")
713 b.WriteString(job.After)
714 if !strings.HasSuffix(job.After, "\n") {
715 b.WriteByte('\n')
716 }
717 b.WriteString(")\n")
718 }
719 b.WriteString("echo \"section_end:after:After script\"\nexit \"$rc\"\n")
720 return b.String()
721}
722
723// resolveImage kiest het image waarmee de container start.
724// Een alias zoals bluegit/node wordt gebouwd. node:22 blijft zichzelf.
725func (r *Runner) resolveImage(ctx context.Context, image string) (string, []string, error) {
726 image = strings.TrimSpace(image)
727 set, err := images.Effective(r.presetSet())
728 if err != nil {
729 return image, nil, fmt.Errorf("runner_system_failure: %w", err)
730 }
731 missing := fmt.Errorf("runner_system_failure: docker (%s) is not available; the job only runs in a container", r.Docker)
732 if _, lookErr := exec.LookPath(r.Docker); lookErr != nil {
733 if p, ok := images.Find(set, image); ok {
734 return "", imageLog(p.Name, p.From, p.From, "", nil, nil), missing
735 }
736 return image, dockerImageLines(image, "", nil), missing
737 }
738 p, ok := images.Find(set, image)
739 if !ok {
740 if r.controls().pull == runnercfg.PullAlways {
741 _, _ = execOut(ctx, r.Docker, "pull", "--quiet", image)
742 }
743 id, digests := r.inspectImage(ctx, image)
744 return image, dockerImageLines(image, id, digests), nil
745 }
746 ref, built, err := p.Ensure(ctx, r.Docker)
747 if err != nil {
748 return "", imageLog(p.Name, p.From, "", "", nil, nil), fmt.Errorf("runner_system_failure: preset %s: %w", p.Name, err)
749 }
750 var lines []string
751 if built {
752 lines = append(lines, fmt.Sprintf("Building image preset %s ...", p.Name))
753 }
754 id, digests := r.inspectImage(ctx, ref)
755 var baseDigests []string
756 if ref != p.From {
757 _, baseDigests = r.inspectImage(ctx, p.From)
758 }
759 lines = append(lines, imageLog(p.Name, p.From, ref, id, digests, baseDigests)...)
760 return ref, lines, nil
761}
762
763func imageLog(preset, base, ref, id string, digests, baseDigests []string) []string {
764 var lines []string
765 if preset != "" {
766 lines = append(lines, fmt.Sprintf("Using image preset %s based on %s", preset, base))
767 }
768 if ref == "" {
769 return lines
770 }
771 lines = append(lines, dockerImageLines(ref, id, digests)...)
772 if preset != "" && ref != base {
773 digest := matchingDigest(base, baseDigests)
774 if digest == "" && len(baseDigests) > 0 {
775 digest = strings.TrimSpace(baseDigests[0])
776 }
777 if digest != "" {
778 lines = append(lines, fmt.Sprintf("Underlying image %s with digest %s ...", base, digest))
779 } else {
780 lines = append(lines, fmt.Sprintf("Underlying image %s ...", base))
781 }
782 }
783 return lines
784}
785
786func (r *Runner) inspectImage(ctx context.Context, image string) (string, []string) {
787 if strings.TrimSpace(image) == "" || r.Docker == "" {
788 return "", nil
789 }
790 out, err := execOut(ctx, r.Docker, "image", "inspect", "--format", "{{.Id}}\n{{range .RepoDigests}}{{.}}\n{{end}}", image)
791 if err != nil {
792 return "", nil
793 }
794 return parseImageInspect(out)
795}
796
797func parseImageInspect(out string) (string, []string) {
798 lines := strings.Split(out, "\n")
799 id := ""
800 if len(lines) > 0 {
801 id = strings.TrimSpace(lines[0])
802 }
803 var digests []string
804 for _, line := range lines[1:] {
805 line = strings.TrimSpace(line)
806 if line != "" {
807 digests = append(digests, line)
808 }
809 }
810 return id, digests
811}
812
813func dockerImageLines(image, id string, digests []string) []string {
814 image = strings.TrimSpace(image)
815 lines := []string{fmt.Sprintf("Using docker image %s ...", image)}
816 id = strings.TrimSpace(id)
817 digest := matchingDigest(image, digests)
818 switch {
819 case id != "" && digest != "":
820 lines = append(lines, fmt.Sprintf("Using docker image %s for %s with digest %s ...", id, image, digest))
821 case digest != "":
822 lines = append(lines, fmt.Sprintf("Using digest %s for %s ...", digest, image))
823 case id != "":
824 lines = append(lines, fmt.Sprintf("Using docker image %s for %s ...", id, image))
825 }
826 return lines
827}
828
829func matchingDigest(image string, digests []string) string {
830 name := imageName(image)
831 fallback := ""
832 for _, digest := range digests {
833 digest = strings.TrimSpace(digest)
834 at := strings.LastIndex(digest, "@")
835 if digest == "" || at <= 0 {
836 continue
837 }
838 if fallback == "" {
839 fallback = digest
840 }
841 repo := digest[:at]
842 if repo == name || strings.HasSuffix(repo, "/"+name) || imageName(repo) == name {
843 return digest
844 }
845 }
846 return fallback
847}
848
849func imageName(image string) string {
850 image = strings.TrimSpace(image)
851 if i := strings.LastIndex(image, "@"); i >= 0 {
852 image = image[:i]
853 }
854 slash := strings.LastIndex(image, "/")
855 name := image
856 if slash >= 0 {
857 name = image[slash+1:]
858 }
859 if i := strings.Index(name, ":"); i >= 0 {
860 name = name[:i]
861 }
862 return name
863}
864
865func (r *Runner) materialize(ctx context.Context, p store.Pipeline, job store.Job, work string) error {
866 jobs, err := r.Store.JobsByPipeline(ctx, p.ID)
867 if err != nil {
868 return err
869 }
870 wanted := map[string]bool{}
871 if job.NeedsSet {
872 for _, n := range job.Needs {
873 wanted[n] = true
874 }
875 } else {
876 stageOrder := map[string]int{}
877 n := 0
878 for _, j := range jobs {
879 if _, ok := stageOrder[j.Stage]; !ok {
880 stageOrder[j.Stage] = n
881 n++
882 }
883 }
884 my := stageOrder[job.Stage]
885 for _, j := range jobs {
886 if stageOrder[j.Stage] < my {
887 wanted[j.Name] = true
888 }
889 }
890 }
891 for _, j := range jobs {
892 if !wanted[j.Name] || j.Status != "success" {
893 continue
894 }
895 for _, rel := range j.ArtifactPaths {
896 src, err := r.Store.ArtifactPath(ctx, p.ID, j.Name, rel)
897 if err != nil {
898 continue
899 }
900 dst := filepath.Join(work, filepath.FromSlash(rel))
901 if err := copyFile(src, dst); err != nil {
902 return err
903 }
904 }
905 }
906 return nil
907}
908
909func (r *Runner) collect(ctx context.Context, job store.Job, work string) error {
910 var expires *time.Time
911 if job.ArtifactExpire > 0 {
912 t := time.Now().Add(job.ArtifactExpire)
913 expires = &t
914 }
915 for _, rel := range job.ArtifactPaths {
916 src := filepath.Join(work, filepath.FromSlash(rel))
917 info, err := os.Stat(src)
918 if err != nil || info.IsDir() {
919 return fmt.Errorf("artifact %s ontbreekt", rel)
920 }
921 dst := filepath.Join(r.storage(), "artifacts", fmt.Sprint(job.ID), filepath.FromSlash(rel))
922 if err := copyFile(src, dst); err != nil {
923 return err
924 }
925 if err := r.Store.AddArtifact(ctx, job.ID, rel, dst, info.Size(), expires); err != nil {
926 return err
927 }
928 }
929 return nil
930}
931
932func (r *Runner) environment(ctx context.Context, repo store.Repo, p store.Pipeline, job store.Job, token string) (map[string]string, []string, error) {
933 name, _ := ci.SplitRef(p.Ref)
934 patterns, err := r.Store.ProtectedPatterns(ctx, repo.ID)
935 if err != nil {
936 return nil, nil, err
937 }
938 refProtected := access.BranchProtected(patterns, name)
939 env := map[string]string{}
940 var mask []string
941 if repo.OwnerKind == "group" {
942 groupSecrets, err := r.Store.SecretValues(ctx, "group", repo.OwnerID, refProtected)
943 if err != nil {
944 return nil, nil, err
945 }
946 for k, v := range groupSecrets {
947 env[k] = v
948 mask = append(mask, v)
949 }
950 }
951 repoSecrets, err := r.Store.SecretValues(ctx, "repo", repo.ID, refProtected)
952 if err != nil {
953 return nil, nil, err
954 }
955 for k, v := range repoSecrets {
956 env[k] = v
957 mask = append(mask, v)
958 }
959 for k, v := range job.Variables {
960 env[k] = v
961 }
962 base := strings.TrimRight(r.BaseURL, "/")
963 dir := gitrepo.Dir(r.storage(), repo.OwnerPath, repo.Name)
964 var info *ci.MRInfo
965 if p.MRID != 0 {
966 if m, merr := r.Store.MergeRequest(ctx, repo.ID, p.MRID); merr == nil {
967 target := ""
968 if out, gerr := exec.CommandContext(ctx, r.GitBin, "-C", dir, "rev-parse", "--verify", "refs/heads/"+m.TargetBranch).Output(); gerr == nil {
969 target = strings.TrimSpace(string(out))
970 }
971 info = &ci.MRInfo{
972 ID: m.ID, IID: m.Number, Title: m.Title,
973 SourceBranch: m.SourceBranch, TargetBranch: m.TargetBranch,
974 ProjectPath: repo.FullPath(), ProjectURL: base + "/" + repo.FullPath(),
975 TargetSHA: target,
976 }
977 }
978 }
979 stamp, _ := gitrepo.CommitterTimestamp(ctx, r.GitBin, dir, p.CommitSHA)
980 pre := ci.Variables(ci.Ref{
981 SHA: p.CommitSHA, FullRef: p.Ref, Title: p.CommitTitle, Timestamp: stamp,
982 DefaultBranch: repo.DefaultBranch, Source: p.Source,
983 ProjectPath: repo.FullPath(), ProjectURL: base + "/" + repo.FullPath(),
984 APIURL: base + "/api/v1", PipelineID: p.ID, MR: info,
985 })
986 for k, v := range pre {
987 env[k] = v
988 }
989 env["CI_JOB_ID"] = fmt.Sprint(job.ID)
990 env["CI_JOB_NAME"] = job.Name
991 env["CI_JOB_STAGE"] = job.Stage
992 env["CI_JOB_URL"] = base + "/" + repo.FullPath() + "/-/pipelines/" + fmt.Sprint(p.ID) + "/jobs/" + fmt.Sprint(job.ID)
993 env["CI_JOB_TOKEN"] = token
994 if job.Environment != "" {
995 env["CI_ENVIRONMENT_NAME"] = job.Environment
996 if job.EnvironmentURL != "" {
997 env["CI_ENVIRONMENT_URL"] = ci.Expand(job.EnvironmentURL, env)
998 }
999 }
1000 for k, v := range job.Variables {
1001 if strings.HasPrefix(k, "CI_NODE_") {
1002 env[k] = v
1003 }
1004 }
1005 // Na de jobvariabelen, zodat een eigen GIT_CONFIG_COUNT blijft staan
1006 // en safe.directory er alsnog bij komt.
1007 markWorkspaceSafe(env)
1008 JobGitAuth(env, base+"/"+repo.FullPath(), token)
1009 mask = append(mask, token)
1010 return env, mask, nil
1011}
1012
1013// JobGitAuth geeft git in de job leestoegang tot de eigen repo met het
1014// job-token. De header geldt alleen voor de URL van dit project (met en
1015// zonder .git) en het token vervalt als de job stopt. Via GIT_CONFIG_* werkt
1016// het in elk image, zonder bestanden in de container.
1017func JobGitAuth(env map[string]string, projectURL, token string) {
1018 if projectURL == "" || token == "" || !strings.Contains(projectURL, "://") {
1019 return
1020 }
1021 n := 0
1022 if v, err := strconv.Atoi(strings.TrimSpace(env["GIT_CONFIG_COUNT"])); err == nil && v > 0 {
1023 n = v
1024 }
1025 for _, u := range []string{projectURL, projectURL + ".git"} {
1026 env[fmt.Sprintf("GIT_CONFIG_KEY_%d", n)] = "http." + u + ".extraHeader"
1027 env[fmt.Sprintf("GIT_CONFIG_VALUE_%d", n)] = "Authorization: Bearer " + token
1028 n++
1029 }
1030 env["GIT_CONFIG_COUNT"] = strconv.Itoa(n)
1031}
1032
1033// markWorkspaceSafe zet safe.directory voor elke job.
1034// De checkout is van de host-uid; de container-user is dat niet.
1035// Git 2.35+ weigert die repo anders. Een job die safe.directory al op
1036// * of /workspace zet, blijft zoals hij is.
1037func markWorkspaceSafe(env map[string]string) {
1038 const key = "safe.directory"
1039 n := 0
1040 if raw, ok := env["GIT_CONFIG_COUNT"]; ok {
1041 if v, err := strconv.Atoi(strings.TrimSpace(raw)); err == nil && v > 0 {
1042 n = v
1043 }
1044 }
1045 for i := 0; i < n; i++ {
1046 if env[fmt.Sprintf("GIT_CONFIG_KEY_%d", i)] != key {
1047 continue
1048 }
1049 switch env[fmt.Sprintf("GIT_CONFIG_VALUE_%d", i)] {
1050 case "*", "/workspace":
1051 return
1052 }
1053 }
1054 env[fmt.Sprintf("GIT_CONFIG_KEY_%d", n)] = key
1055 env[fmt.Sprintf("GIT_CONFIG_VALUE_%d", n)] = "*"
1056 env["GIT_CONFIG_COUNT"] = strconv.Itoa(n + 1)
1057}
1058
1059func (r *Runner) startServices(ctx context.Context, job store.Job) (string, func(), error) {
1060 netName := fmt.Sprintf("bluegit-%d", job.ID)
1061 if _, err := execOut(ctx, r.Docker, "network", "create", netName); err != nil {
1062 return "", func() {}, fmt.Errorf("runner_system_failure: docker network: %w", err)
1063 }
1064 var names []string
1065 cleanup := func() {
1066 cctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
1067 defer cancel()
1068 for _, name := range names {
1069 _, _ = execOut(cctx, r.Docker, "rm", "-f", name)
1070 }
1071 _, _ = execOut(cctx, r.Docker, "network", "rm", netName)
1072 }
1073 for i, svc := range job.Services {
1074 cname := fmt.Sprintf("bluegit-svc-%d-%d", job.ID, i)
1075 args := []string{"run", "-d", "--name", cname, "--network", netName}
1076 if svc.Alias != "" {
1077 args = append(args, "--network-alias", svc.Alias)
1078 }
1079 cmdEnv := append([]string{}, os.Environ()...)
1080 for k, v := range svc.Variables {
1081 args = append(args, "-e", k)
1082 cmdEnv = append(cmdEnv, k+"="+v)
1083 }
1084 if len(svc.Entrypoint) > 0 {
1085 args = append(args, "--entrypoint", svc.Entrypoint[0])
1086 }
1087 args = append(args, svc.Name)
1088 if len(svc.Entrypoint) > 1 {
1089 args = append(args, svc.Entrypoint[1:]...)
1090 }
1091 args = append(args, svc.Command...)
1092 cmd := exec.CommandContext(ctx, r.Docker, args...)
1093 cmd.Env = cmdEnv
1094 var stderr bytes.Buffer
1095 cmd.Stderr = &stderr
1096 if err := cmd.Run(); err != nil {
1097 cleanup()
1098 msg := strings.TrimSpace(stderr.String())
1099 if msg == "" {
1100 msg = err.Error()
1101 }
1102 return "", func() {}, fmt.Errorf("runner_system_failure: service %s: %s", svc.Name, msg)
1103 }
1104 names = append(names, cname)
1105 }
1106 return netName, cleanup, nil
1107}
1108
1109func shouldRetry(job store.Job, kind string) bool {
1110 if job.RetryMax <= 0 || job.Attempt >= job.RetryMax || kind == "" {
1111 return false
1112 }
1113 if len(job.RetryWhen) == 0 || containsStr(job.RetryWhen, "always") {
1114 return true
1115 }
1116 if containsStr(job.RetryWhen, kind) {
1117 return true
1118 }
1119 return kind == "job_execution_timeout" && containsStr(job.RetryWhen, "stuck_or_timeout_failure")
1120}
1121
1122func classifyFailure(err error) string {
1123 msg := err.Error()
1124 if strings.Contains(msg, "runner_system_failure") || strings.Contains(msg, "is not available") {
1125 return "runner_system_failure"
1126 }
1127 if errors.Is(err, context.DeadlineExceeded) || strings.Contains(msg, "deadline exceeded") {
1128 return "job_execution_timeout"
1129 }
1130 return "script_failure"
1131}
1132
1133func containsStr(list []string, s string) bool {
1134 for _, item := range list {
1135 if item == s {
1136 return true
1137 }
1138 }
1139 return false
1140}
1141
1142func safeSegment(name string) string {
1143 var b strings.Builder
1144 for _, r := range name {
1145 if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '.' || r == '_' || r == '-' {
1146 b.WriteRune(r)
1147 } else {
1148 b.WriteByte('_')
1149 }
1150 }
1151 if b.Len() == 0 {
1152 return "job"
1153 }
1154 return b.String()
1155}
1156
1157func (r *Runner) restoreCache(repoID int64, job store.Job, work string) error {
1158 if len(job.CachePaths) == 0 {
1159 return nil
1160 }
1161 root := r.cacheDir(repoID, job.CacheKey)
1162 for _, rel := range job.CachePaths {
1163 src := filepath.Join(root, filepath.FromSlash(rel))
1164 if _, err := os.Stat(src); err != nil {
1165 continue
1166 }
1167 if err := copyFile(src, filepath.Join(work, filepath.FromSlash(rel))); err != nil {
1168 return err
1169 }
1170 }
1171 return nil
1172}
1173
1174func (r *Runner) saveCache(repoID int64, job store.Job, work string) error {
1175 if len(job.CachePaths) == 0 {
1176 return nil
1177 }
1178 root := r.cacheDir(repoID, job.CacheKey)
1179 for _, rel := range job.CachePaths {
1180 src := filepath.Join(work, filepath.FromSlash(rel))
1181 info, err := os.Stat(src)
1182 if err != nil || info.IsDir() {
1183 continue
1184 }
1185 if err := copyFile(src, filepath.Join(root, filepath.FromSlash(rel))); err != nil {
1186 return err
1187 }
1188 }
1189 return nil
1190}
1191
1192func (r *Runner) cacheDir(repoID int64, key string) string {
1193 if key == "" {
1194 key = "default"
1195 }
1196 var b strings.Builder
1197 for _, r := range key {
1198 if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '.' || r == '_' || r == '-' {
1199 b.WriteRune(r)
1200 }
1201 }
1202 safe := b.String()
1203 if safe == "" {
1204 safe = "default"
1205 }
1206 return filepath.Join(r.storage(), "cache", fmt.Sprint(repoID), safe)
1207}
1208
1209func stamp(line string) string {
1210 return time.Now().UTC().Format(time.RFC3339) + "\t" + line + "\n"
1211}
1212
1213type logSink struct {
1214 mu sync.Mutex
1215 store *store.Store
1216 jobID int64
1217 out func(string)
1218 secrets []string
1219 partial string
1220 current string
1221 opened time.Time
1222}
1223
1224func (l *logSink) Write(p []byte) (int, error) {
1225 l.mu.Lock()
1226 defer l.mu.Unlock()
1227 l.partial += string(p)
1228 for {
1229 i := strings.IndexByte(l.partial, '\n')
1230 if i < 0 {
1231 break
1232 }
1233 l.emit(strings.TrimRight(l.partial[:i], "\r"))
1234 l.partial = l.partial[i+1:]
1235 }
1236 return len(p), nil
1237}
1238
1239func (l *logSink) flush() {
1240 l.mu.Lock()
1241 defer l.mu.Unlock()
1242 if strings.TrimSpace(l.partial) != "" {
1243 l.emit(l.partial)
1244 }
1245 l.partial = ""
1246}
1247
1248func (l *logSink) emit(line string) {
1249 line = ci.Mask(line, l.secrets)
1250 if strings.HasPrefix(line, "section_start:") || strings.HasPrefix(line, "section_end:") {
1251 if l.current != "" && strings.HasPrefix(line, "section_end:") {
1252 dur := int(time.Since(l.opened).Seconds())
1253 line = line + "\t" + fmt.Sprintf("%02d:%02d", dur/60, dur%60)
1254 l.current = ""
1255 }
1256 if strings.HasPrefix(line, "section_start:") {
1257 l.current = line
1258 l.opened = time.Now()
1259 }
1260 }
1261 if l.out != nil {
1262 l.out(stamp(line))
1263 return
1264 }
1265 _ = l.store.AppendJobLog(context.Background(), l.jobID, stamp(line))
1266}
1267
1268func (l *logSink) section(name, title string) {
1269 l.emit("section_start:" + name + ":" + title)
1270}
1271
1272func (l *logSink) closeSection() {
1273 if l.current == "" {
1274 return
1275 }
1276 name := "prepare"
1277 if parts := strings.SplitN(strings.TrimPrefix(l.current, "section_start:"), ":", 2); len(parts) > 0 && parts[0] != "" {
1278 name = parts[0]
1279 }
1280 l.emit("section_end:" + name + ":done")
1281}
1282
1283func copyFile(src, dst string) error {
1284 if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
1285 return err
1286 }
1287 in, err := os.Open(src)
1288 if err != nil {
1289 return err
1290 }
1291 defer in.Close()
1292 out, err := os.OpenFile(dst, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
1293 if err != nil {
1294 return err
1295 }
1296 defer out.Close()
1297 _, err = io.Copy(out, in)
1298 return err
1299}
1300
1301func execOut(ctx context.Context, bin string, args ...string) (string, error) {
1302 if bin == "" {
1303 bin = "git"
1304 }
1305 cmd := exec.CommandContext(ctx, bin, args...)
1306 var stdout, stderr bytes.Buffer
1307 cmd.Stdout = &stdout
1308 cmd.Stderr = &stderr
1309 if err := cmd.Run(); err != nil {
1310 msg := strings.TrimSpace(stderr.String())
1311 if msg == "" {
1312 msg = err.Error()
1313 }
1314 return "", fmt.Errorf("%s", msg)
1315 }
1316 return stdout.String(), nil
1317}
1318
1319// cloneArgs kopieert de objecten in plaats van hardlinks te maken: de
1320// werkmap en de bare repo kunnen andere eigenaars hebben, en met
1321// fs.protected_hardlinks geeft link() dan "Operation not permitted".
1322func cloneArgs(bare, work string) []string {
1323 return []string{"clone", "--no-hardlinks", bare, work}
1324}
1325
1326// ProtectedRunning is het aantal lopende doNotInterrupt-jobs in dit proces.
1327func (r *Runner) ProtectedRunning() int64 { return r.protected.Load() }
1328
1329// WaitProtected wacht bij het afsluiten tot alle lopende
1330// doNotInterrupt-jobs klaar zijn. Hun eigen timeout begrenst het wachten.
1331func (r *Runner) WaitProtected(log func(n int64)) {
1332 last := int64(-1)
1333 for n := r.protected.Load(); n > 0; n = r.protected.Load() {
1334 if n != last && log != nil {
1335 log(n)
1336 last = n
1337 }
1338 time.Sleep(time.Second)
1339 }
1340}