BlueGit

timfa bluegit

Files

bluegit / internal / runner / runner.go

runner.go

feat: webhooks weren privénetten en de beheerder kiest de datadisk
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
1ab44366 History
runner.go 10.1 KiB Download Raw
1// Package runner voert pipelinejobs uit, elk in een eigen Docker-container.
2package runner
3
4import (
5 "bytes"
6 "context"
7 "fmt"
8 "io"
9 "log/slog"
10 "os"
11 "os/exec"
12 "path/filepath"
13 "strings"
14 "sync"
15 "time"
16
17 "gitlab.com/Timfa/bluegit/internal/access"
18 "gitlab.com/Timfa/bluegit/internal/ci"
19 "gitlab.com/Timfa/bluegit/internal/gitrepo"
20 "gitlab.com/Timfa/bluegit/internal/store"
21 "gitlab.com/Timfa/bluegit/internal/webhook"
22)
23
24// Runner plant jobs en stuurt het resultaat door naar webhooks.
25type Runner struct {
26 Store *store.Store
27 GitBin string
28 Docker string
29 Storage string
30 BaseURL string
31 Network string
32 Timeout time.Duration
33 Log *slog.Logger
34 OnEvent func(repoID int64, ev webhook.Event)
35 slots chan struct{}
36 mu sync.RWMutex
37}
38
39// SetStorage wijzigt het pad waarop jobs hun clone en artifacts zetten.
40func (r *Runner) SetStorage(path string) {
41 r.mu.Lock()
42 r.Storage = path
43 r.mu.Unlock()
44}
45
46func (r *Runner) storage() string {
47 r.mu.RLock()
48 defer r.mu.RUnlock()
49 return r.Storage
50}
51
52// Loop blijft jobs oppakken tot ctx afloopt.
53func (r *Runner) Loop(ctx context.Context, concurrency int) {
54 if concurrency < 1 {
55 concurrency = 1
56 }
57 r.slots = make(chan struct{}, concurrency)
58 tick := time.NewTicker(2 * time.Second)
59 defer tick.Stop()
60 for {
61 select {
62 case <-ctx.Done():
63 return
64 case <-tick.C:
65 r.Tick(ctx)
66 }
67 }
68}
69
70// Tick bekijkt alle open pipelines één keer.
71// Zonder opslagpad gebeurt er niets.
72func (r *Runner) Tick(ctx context.Context) {
73 if r.storage() == "" {
74 return
75 }
76 pipes, err := r.Store.ActivePipelines(ctx)
77 if err != nil {
78 r.Log.Error("pipelines", "err", err)
79 return
80 }
81 for _, p := range pipes {
82 r.schedule(ctx, p)
83 }
84}
85
86func (r *Runner) schedule(ctx context.Context, p store.Pipeline) {
87 jobs, err := r.Store.JobsByPipeline(ctx, p.ID)
88 if err != nil {
89 r.Log.Error("jobs", "err", err)
90 return
91 }
92 specs := make([]ci.Job, len(jobs))
93 status := map[string]string{}
94 for i, j := range jobs {
95 specs[i] = ci.Job{Name: j.Name, Stage: j.Stage, Needs: j.Needs, NeedsSet: j.NeedsSet, AllowFailure: j.AllowFailure}
96 status[j.Name] = j.Status
97 }
98 for _, j := range jobs {
99 if j.Status != "queued" {
100 continue
101 }
102 switch ci.Gate(specs, status, specs[indexOf(jobs, j.Name)]) {
103 case "skip":
104 _ = r.Store.SkipJob(ctx, j.ID, "overgeslagen omdat een eerdere job mislukte")
105 status[j.Name] = "skipped"
106 case "ready":
107 ok, err := r.Store.MarkJobRunning(ctx, j.ID)
108 if err != nil || !ok {
109 continue
110 }
111 status[j.Name] = "running"
112 job := j
113 pipe := p
114 go r.execute(ctx, pipe, job)
115 }
116 }
117}
118
119func indexOf(jobs []store.Job, name string) int {
120 for i, j := range jobs {
121 if j.Name == name {
122 return i
123 }
124 }
125 return 0
126}
127
128func (r *Runner) execute(ctx context.Context, p store.Pipeline, job store.Job) {
129 if r.slots != nil {
130 r.slots <- struct{}{}
131 defer func() { <-r.slots }()
132 }
133 before, _ := r.Store.PipelineByID(context.Background(), p.RepoID, p.ID)
134 logText, err := r.runOne(ctx, p, job)
135 status := "success"
136 if err != nil {
137 status = "failed"
138 if logText != "" {
139 logText += "\n"
140 }
141 logText += err.Error() + "\n"
142 }
143 if ferr := r.Store.FinishJob(context.Background(), job.ID, status, logText); ferr != nil {
144 r.Log.Error("job afronden", "err", ferr)
145 }
146 final, rerr := r.Store.RefreshPipelineStatus(context.Background(), p.ID)
147 if rerr != nil {
148 r.Log.Error("pipelinestatus", "err", rerr)
149 return
150 }
151 if before.Status != final && (final == "success" || final == "failed") && r.OnEvent != nil {
152 kind := webhook.EventPipelineSuccess
153 word := "geslaagd"
154 if final == "failed" {
155 kind = webhook.EventPipelineFailure
156 word = "mislukt"
157 }
158 repo, err := r.Store.RepoByID(context.Background(), p.RepoID)
159 if err != nil {
160 return
161 }
162 branch, _ := gitrepo.BranchOfRef(p.Ref)
163 if branch == "" {
164 branch = strings.TrimPrefix(p.Ref, "refs/heads/")
165 }
166 r.OnEvent(p.RepoID, webhook.Event{
167 Type: kind,
168 Project: repo.FullPath(),
169 Branch: branch,
170 Commit: p.CommitSHA,
171 Summary: fmt.Sprintf("pipeline #%d voor %s is %s", p.ID, repo.FullPath(), word),
172 URL: strings.TrimRight(r.BaseURL, "/") + "/" + repo.FullPath() + "/-/pipelines/" + fmt.Sprint(p.ID),
173 PipelineID: fmt.Sprint(p.ID),
174 })
175 }
176}
177
178func (r *Runner) runOne(ctx context.Context, p store.Pipeline, job store.Job) (string, error) {
179 if r.Timeout > 0 {
180 var cancel context.CancelFunc
181 ctx, cancel = context.WithTimeout(ctx, r.Timeout)
182 defer cancel()
183 }
184 repo, err := r.Store.RepoByID(ctx, p.RepoID)
185 if err != nil {
186 return "", err
187 }
188 work := filepath.Join(r.storage(), "work", fmt.Sprint(p.ID), job.Name)
189 _ = os.RemoveAll(work)
190 if err := os.MkdirAll(work, 0o755); err != nil {
191 return "", err
192 }
193 bare := gitrepo.Dir(r.storage(), repo.OwnerPath, repo.Name)
194 if _, err := execOut(ctx, r.GitBin, "clone", "--local", bare, work); err != nil {
195 return "", fmt.Errorf("clone: %w", err)
196 }
197 if _, err := execOut(ctx, r.GitBin, "-C", work, "checkout", "--detach", p.CommitSHA); err != nil {
198 return "", fmt.Errorf("checkout %s: %w", p.CommitSHA, err)
199 }
200 if err := r.materialize(ctx, p, job, work); err != nil {
201 return "", err
202 }
203 scriptPath := filepath.Join(work, ".bluegit-job.sh")
204 if err := os.WriteFile(scriptPath, []byte(scriptOf(job.Script)), 0o755); err != nil {
205 return "", err
206 }
207 token, err := r.Store.CreateJobToken(ctx, job.ID)
208 if err != nil {
209 return "", err
210 }
211 env, err := r.environment(ctx, repo, p, job, token)
212 if err != nil {
213 return "", err
214 }
215 if _, err := exec.LookPath(r.Docker); err != nil {
216 return "", fmt.Errorf("docker (%s) is niet beschikbaar; de job draait alleen in een container", r.Docker)
217 }
218 // -e NAAM zonder waarde laat Docker de variabele uit de omgeving van
219 // deze client overnemen. Zo blijft een meerregelige sleutel heel en
220 // staat de waarde niet in de proceslijst.
221 args := []string{"run", "--rm", "--network", r.Network, "-v", work + ":/workspace", "-w", "/workspace"}
222 cmdEnv := append([]string{}, os.Environ()...)
223 for k, v := range env {
224 args = append(args, "-e", k)
225 cmdEnv = append(cmdEnv, k+"="+v)
226 }
227 args = append(args, "--entrypoint", "sh", job.Image, "/workspace/.bluegit-job.sh")
228 cmd := exec.CommandContext(ctx, r.Docker, args...)
229 cmd.Env = cmdEnv
230 var buf bytes.Buffer
231 cmd.Stdout = &buf
232 cmd.Stderr = &buf
233 err = cmd.Run()
234 logText := buf.String()
235 if err != nil {
236 return logText, fmt.Errorf("container eindigde met een fout: %w", err)
237 }
238 if err := r.collect(ctx, job, work); err != nil {
239 return logText, err
240 }
241 return logText, nil
242}
243
244func scriptOf(lines string) string {
245 var b strings.Builder
246 b.WriteString("#!/bin/sh\nset -e\ncd /workspace\n")
247 b.WriteString(lines)
248 if !strings.HasSuffix(lines, "\n") {
249 b.WriteByte('\n')
250 }
251 return b.String()
252}
253
254func (r *Runner) materialize(ctx context.Context, p store.Pipeline, job store.Job, work string) error {
255 jobs, err := r.Store.JobsByPipeline(ctx, p.ID)
256 if err != nil {
257 return err
258 }
259 wanted := map[string]bool{}
260 if job.NeedsSet {
261 for _, n := range job.Needs {
262 wanted[n] = true
263 }
264 } else {
265 stageOrder := map[string]int{}
266 n := 0
267 for _, j := range jobs {
268 if _, ok := stageOrder[j.Stage]; !ok {
269 stageOrder[j.Stage] = n
270 n++
271 }
272 }
273 my := stageOrder[job.Stage]
274 for _, j := range jobs {
275 if stageOrder[j.Stage] < my {
276 wanted[j.Name] = true
277 }
278 }
279 }
280 for _, j := range jobs {
281 if !wanted[j.Name] || j.Status != "success" {
282 continue
283 }
284 for _, rel := range j.ArtifactPaths {
285 src, err := r.Store.ArtifactPath(ctx, p.ID, j.Name, rel)
286 if err != nil {
287 continue
288 }
289 dst := filepath.Join(work, filepath.FromSlash(rel))
290 if err := copyFile(src, dst); err != nil {
291 return err
292 }
293 }
294 }
295 return nil
296}
297
298func (r *Runner) collect(ctx context.Context, job store.Job, work string) error {
299 var expires *time.Time
300 if job.ArtifactExpire > 0 {
301 t := time.Now().Add(job.ArtifactExpire)
302 expires = &t
303 }
304 for _, rel := range job.ArtifactPaths {
305 src := filepath.Join(work, filepath.FromSlash(rel))
306 info, err := os.Stat(src)
307 if err != nil || info.IsDir() {
308 return fmt.Errorf("artifact %s ontbreekt", rel)
309 }
310 dst := filepath.Join(r.storage(), "artifacts", fmt.Sprint(job.ID), filepath.FromSlash(rel))
311 if err := copyFile(src, dst); err != nil {
312 return err
313 }
314 if err := r.Store.AddArtifact(ctx, job.ID, rel, dst, info.Size(), expires); err != nil {
315 return err
316 }
317 }
318 return nil
319}
320
321func (r *Runner) environment(ctx context.Context, repo store.Repo, p store.Pipeline, job store.Job, token string) (map[string]string, error) {
322 branch := strings.TrimPrefix(p.Ref, "refs/heads/")
323 patterns, err := r.Store.ProtectedPatterns(ctx, repo.ID)
324 if err != nil {
325 return nil, err
326 }
327 refProtected := access.BranchProtected(patterns, branch)
328 env := map[string]string{}
329 if repo.OwnerKind == "group" {
330 groupSecrets, err := r.Store.SecretValues(ctx, "group", repo.OwnerID, refProtected)
331 if err != nil {
332 return nil, err
333 }
334 for k, v := range groupSecrets {
335 env[k] = v
336 }
337 }
338 repoSecrets, err := r.Store.SecretValues(ctx, "repo", repo.ID, refProtected)
339 if err != nil {
340 return nil, err
341 }
342 for k, v := range repoSecrets {
343 env[k] = v
344 }
345 for k, v := range job.Variables {
346 env[k] = v
347 }
348 env["CI"] = "true"
349 env["CI_COMMIT_SHA"] = p.CommitSHA
350 env["CI_COMMIT_BRANCH"] = branch
351 env["CI_COMMIT_REF"] = p.Ref
352 env["CI_PROJECT_PATH"] = repo.FullPath()
353 env["CI_PIPELINE_ID"] = fmt.Sprint(p.ID)
354 env["CI_JOB_ID"] = fmt.Sprint(job.ID)
355 env["CI_JOB_NAME"] = job.Name
356 env["CI_JOB_TOKEN"] = token
357 env["CI_API_URL"] = strings.TrimRight(r.BaseURL, "/") + "/api/v1"
358 return env, nil
359}
360
361func copyFile(src, dst string) error {
362 if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
363 return err
364 }
365 in, err := os.Open(src)
366 if err != nil {
367 return err
368 }
369 defer in.Close()
370 out, err := os.OpenFile(dst, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
371 if err != nil {
372 return err
373 }
374 defer out.Close()
375 _, err = io.Copy(out, in)
376 return err
377}
378
379func execOut(ctx context.Context, bin string, args ...string) (string, error) {
380 if bin == "" {
381 bin = "git"
382 }
383 cmd := exec.CommandContext(ctx, bin, args...)
384 var stdout, stderr bytes.Buffer
385 cmd.Stdout = &stdout
386 cmd.Stderr = &stderr
387 if err := cmd.Run(); err != nil {
388 msg := strings.TrimSpace(stderr.String())
389 if msg == "" {
390 msg = err.Error()
391 }
392 return "", fmt.Errorf("%s", msg)
393 }
394 return stdout.String(), nil
395}