BlueGit

timfa bluegit

Files

bluegit / cmd / bluegit-runner / main.go

main.go

main.go 12.2 KiB Download Raw
1// Command bluegit-runner draait BlueGit CI-jobs op een eigen machine.
2// Hij maakt alleen uitgaande HTTPS-verbindingen (long-poll), er hoeft
3// geen poort open.
4package main
5
6import (
7 "bytes"
8 "context"
9 "encoding/json"
10 "errors"
11 "flag"
12 "fmt"
13 "io"
14 "log/slog"
15 "net/http"
16 "os"
17 "os/exec"
18 "os/signal"
19 "os/user"
20 "path/filepath"
21 "strconv"
22 "strings"
23 "sync"
24 "syscall"
25 "time"
26
27 "gopkg.in/yaml.v3"
28
29 "gitlab.com/Timfa/bluegit/internal/runner"
30)
31
32var version = "dev"
33
34const defaultConfig = "/etc/bluegit-runner/config.yml"
35
36// Config staat in /etc/bluegit-runner/config.yml.
37type Config struct {
38 URL string `yaml:"url"`
39 Token string `yaml:"token"`
40 Name string `yaml:"name"`
41 Docker string `yaml:"docker"`
42 Git string `yaml:"git"`
43 WorkDir string `yaml:"work_dir"`
44 Network string `yaml:"network"`
45 Concurrency int `yaml:"concurrency"`
46}
47
48func (c *Config) defaults() {
49 if c.Docker == "" {
50 c.Docker = "docker"
51 }
52 if c.Git == "" {
53 c.Git = "git"
54 }
55 if c.WorkDir == "" {
56 c.WorkDir = "/var/lib/bluegit-runner"
57 }
58 if c.Network == "" {
59 c.Network = "bridge"
60 }
61 if c.Concurrency < 1 {
62 c.Concurrency = 1
63 }
64 c.URL = strings.TrimRight(c.URL, "/")
65}
66
67func main() {
68 if len(os.Args) < 2 {
69 usage()
70 os.Exit(2)
71 }
72 var err error
73 switch os.Args[1] {
74 case "register":
75 err = cmdRegister(os.Args[2:])
76 case "run":
77 err = cmdRun(os.Args[2:])
78 case "version", "--version":
79 fmt.Println(version)
80 default:
81 usage()
82 os.Exit(2)
83 }
84 if err != nil {
85 fmt.Fprintln(os.Stderr, "bluegit-runner:", err)
86 os.Exit(1)
87 }
88}
89
90func usage() {
91 fmt.Fprintln(os.Stderr, `usage:
92 bluegit-runner register --url https://git.example.com --token bgrr_... [--name NAME] [--config PATH]
93 bluegit-runner run [--config PATH]
94 bluegit-runner version`)
95}
96
97func loadConfig(path string) (Config, error) {
98 var c Config
99 b, err := os.ReadFile(path)
100 if err != nil {
101 return c, err
102 }
103 if err := yaml.Unmarshal(b, &c); err != nil {
104 return c, err
105 }
106 c.defaults()
107 if c.URL == "" || c.Token == "" {
108 return c, fmt.Errorf("%s: url and token are required; run bluegit-runner register first", path)
109 }
110 return c, nil
111}
112
113func cmdRegister(args []string) error {
114 fs := flag.NewFlagSet("register", flag.ExitOnError)
115 url := fs.String("url", "", "BlueGit base URL")
116 token := fs.String("token", "", "registration token from the BlueGit UI")
117 name := fs.String("name", "", "runner name (default: hostname)")
118 cfgPath := fs.String("config", defaultConfig, "config file")
119 _ = fs.Parse(args)
120 // Niet-interactief (agents): alles mag ook via de omgeving.
121 if *token == "" {
122 *token = os.Getenv("BLUEGIT_RUNNER_REGISTRATION_TOKEN")
123 }
124 if *url == "" {
125 *url = os.Getenv("BLUEGIT_RUNNER_URL")
126 }
127 if *name == "" {
128 *name = os.Getenv("BLUEGIT_RUNNER_NAME")
129 }
130 if *url == "" || *token == "" {
131 return errors.New("--url and --token are required")
132 }
133 if *name == "" {
134 *name, _ = os.Hostname()
135 }
136 var existing Config
137 if b, err := os.ReadFile(*cfgPath); err == nil {
138 _ = yaml.Unmarshal(b, &existing)
139 }
140 body, _ := json.Marshal(map[string]string{"token": *token, "name": *name, "version": version})
141 resp, err := http.Post(strings.TrimRight(*url, "/")+"/api/v1/runners/register", "application/json", bytes.NewReader(body))
142 if err != nil {
143 return err
144 }
145 defer resp.Body.Close()
146 var out struct {
147 ID int64 `json:"id"`
148 Name string `json:"name"`
149 Token string `json:"token"`
150 Message string `json:"message"`
151 }
152 _ = json.NewDecoder(resp.Body).Decode(&out)
153 if resp.StatusCode != http.StatusCreated || out.Token == "" {
154 return fmt.Errorf("registration failed (%d): %s", resp.StatusCode, out.Message)
155 }
156 existing.URL, existing.Token, existing.Name = strings.TrimRight(*url, "/"), out.Token, out.Name
157 b, err := yaml.Marshal(existing)
158 if err != nil {
159 return err
160 }
161 if err := os.MkdirAll(filepath.Dir(*cfgPath), 0o755); err != nil {
162 return err
163 }
164 if err := os.WriteFile(*cfgPath, b, 0o600); err != nil {
165 return err
166 }
167 if os.Geteuid() == 0 {
168 if u, err := user.Lookup("bluegit-runner"); err == nil {
169 uid, _ := strconv.Atoi(u.Uid)
170 gid, _ := strconv.Atoi(u.Gid)
171 _ = os.Chown(*cfgPath, uid, gid)
172 }
173 }
174 fmt.Printf("registered runner %q (id %d); config written to %s\n", out.Name, out.ID, *cfgPath)
175 // Met het AUR-pakket: de service is al enabled en wacht op de config.
176 if os.Geteuid() == 0 && *cfgPath == defaultConfig {
177 if _, err := os.Stat("/usr/lib/systemd/system/bluegit-runner.service"); err == nil {
178 if err := exec.Command("systemctl", "enable", "--now", "bluegit-runner.service").Run(); err == nil {
179 _ = exec.Command("systemctl", "restart", "bluegit-runner.service").Run()
180 fmt.Println("bluegit-runner.service started")
181 return nil
182 }
183 }
184 }
185 fmt.Println("start it with: sudo systemctl enable --now bluegit-runner")
186 return nil
187}
188
189type client struct {
190 cfg Config
191 http *http.Client
192 log *slog.Logger
193}
194
195func (c *client) do(ctx context.Context, method, path string, body io.Reader, ctype string) (*http.Response, error) {
196 req, err := http.NewRequestWithContext(ctx, method, c.cfg.URL+path, body)
197 if err != nil {
198 return nil, err
199 }
200 req.Header.Set("Authorization", "Bearer "+c.cfg.Token)
201 req.Header.Set("X-Runner-Version", version)
202 if ctype != "" {
203 req.Header.Set("Content-Type", ctype)
204 }
205 return c.http.Do(req)
206}
207
208func (c *client) postJSON(ctx context.Context, path string, in, out any) error {
209 b, _ := json.Marshal(in)
210 resp, err := c.do(ctx, http.MethodPost, path, bytes.NewReader(b), "application/json")
211 if err != nil {
212 return err
213 }
214 defer resp.Body.Close()
215 if resp.StatusCode >= 300 {
216 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
217 return fmt.Errorf("%s: %d %s", path, resp.StatusCode, strings.TrimSpace(string(msg)))
218 }
219 if out != nil {
220 return json.NewDecoder(resp.Body).Decode(out)
221 }
222 return nil
223}
224
225func cmdRun(args []string) error {
226 fs := flag.NewFlagSet("run", flag.ExitOnError)
227 cfgPath := fs.String("config", defaultConfig, "config file")
228 once := fs.Bool("once", false, "run at most one job, then exit (for tests)")
229 _ = fs.Parse(args)
230 cfg, err := loadConfig(*cfgPath)
231 if err != nil {
232 return err
233 }
234 log := slog.New(slog.NewTextHandler(os.Stderr, nil))
235 ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
236 defer stop()
237 c := &client{cfg: cfg, http: &http.Client{Timeout: 0}, log: log}
238 if err := c.postJSON(ctx, "/api/v1/runner/heartbeat", map[string]string{}, nil); err != nil {
239 return fmt.Errorf("cannot reach BlueGit: %w", err)
240 }
241 log.Info("bluegit-runner started", "url", cfg.URL, "name", cfg.Name, "version", version, "concurrency", cfg.Concurrency)
242 go func() {
243 t := time.NewTicker(30 * time.Second)
244 defer t.Stop()
245 for {
246 select {
247 case <-ctx.Done():
248 return
249 case <-t.C:
250 if err := c.postJSON(ctx, "/api/v1/runner/heartbeat", map[string]string{}, nil); err != nil && ctx.Err() == nil {
251 log.Warn("heartbeat", "err", err)
252 }
253 }
254 }
255 }()
256 var wg sync.WaitGroup
257 for i := 0; i < cfg.Concurrency; i++ {
258 wg.Add(1)
259 go func() {
260 defer wg.Done()
261 for ctx.Err() == nil {
262 ran, err := c.poll(ctx)
263 if err != nil && ctx.Err() == nil {
264 log.Warn("poll", "err", err)
265 select {
266 case <-ctx.Done():
267 case <-time.After(5 * time.Second):
268 }
269 }
270 if ran && *once {
271 stop()
272 }
273 }
274 }()
275 }
276 wg.Wait()
277 return nil
278}
279
280func (c *client) poll(ctx context.Context) (bool, error) {
281 pctx, cancel := context.WithTimeout(ctx, 60*time.Second)
282 defer cancel()
283 resp, err := c.do(pctx, http.MethodPost, "/api/v1/runner/jobs/request", strings.NewReader("{}"), "application/json")
284 if err != nil {
285 return false, err
286 }
287 defer resp.Body.Close()
288 if resp.StatusCode == http.StatusNoContent {
289 return false, nil
290 }
291 if resp.StatusCode != http.StatusOK {
292 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
293 return false, fmt.Errorf("request: %d %s", resp.StatusCode, strings.TrimSpace(string(msg)))
294 }
295 var pl runner.RemotePayload
296 if err := json.NewDecoder(resp.Body).Decode(&pl); err != nil {
297 return false, err
298 }
299 c.runJob(ctx, pl)
300 return true, nil
301}
302
303// logBuffer verzamelt logregels en stuurt ze elke seconde door.
304type logBuffer struct {
305 mu sync.Mutex
306 buf strings.Builder
307}
308
309func (l *logBuffer) add(s string) {
310 l.mu.Lock()
311 l.buf.WriteString(s)
312 l.mu.Unlock()
313}
314
315func (l *logBuffer) take() string {
316 l.mu.Lock()
317 defer l.mu.Unlock()
318 s := l.buf.String()
319 l.buf.Reset()
320 return s
321}
322
323func (c *client) runJob(parent context.Context, pl runner.RemotePayload) {
324 c.log.Info("job", "id", pl.JobID, "name", pl.Job.Name)
325 base := fmt.Sprintf("/api/v1/runner/jobs/%d", pl.JobID)
326 ctx, cancel := context.WithCancel(parent)
327 defer cancel()
328 runCtx := ctx
329 if pl.Timeout > 0 {
330 var tc context.CancelFunc
331 runCtx, tc = context.WithTimeout(ctx, time.Duration(pl.Timeout)*time.Second)
332 defer tc()
333 }
334 var canceled bool
335 var cmu sync.Mutex
336 logs := &logBuffer{}
337 send := func() {
338 chunk := logs.take()
339 var out struct {
340 Cancel bool `json:"cancel"`
341 }
342 sctx, sc := context.WithTimeout(context.Background(), 30*time.Second)
343 defer sc()
344 err := func() error {
345 resp, err := c.do(sctx, http.MethodPost, base+"/log", strings.NewReader(chunk), "text/plain")
346 if err != nil {
347 return err
348 }
349 defer resp.Body.Close()
350 if resp.StatusCode != http.StatusOK {
351 return fmt.Errorf("log: %d", resp.StatusCode)
352 }
353 return json.NewDecoder(resp.Body).Decode(&out)
354 }()
355 if err != nil {
356 // Bij een fout gaat de chunk terug in de buffer voor de volgende poging.
357 if chunk != "" {
358 logs.mu.Lock()
359 rest := logs.buf.String()
360 logs.buf.Reset()
361 logs.buf.WriteString(chunk + rest)
362 logs.mu.Unlock()
363 }
364 return
365 }
366 if out.Cancel {
367 cmu.Lock()
368 canceled = true
369 cmu.Unlock()
370 cancel()
371 }
372 }
373 done := make(chan struct{})
374 flushed := make(chan struct{})
375 go func() {
376 defer close(flushed)
377 t := time.NewTicker(time.Second)
378 defer t.Stop()
379 for {
380 select {
381 case <-done:
382 return
383 case <-t.C:
384 send()
385 }
386 }
387 }()
388 r := &runner.Runner{GitBin: c.cfg.Git, Docker: c.cfg.Docker, Storage: c.cfg.WorkDir, Network: c.cfg.Network, Name: c.cfg.Name}
389 work := filepath.Join(c.cfg.WorkDir, "work", strconv.FormatInt(pl.JobID, 10))
390 defer os.RemoveAll(work)
391 clone := func(ctx context.Context, dir string) error {
392 cmd := exec.CommandContext(ctx, c.cfg.Git, "clone", "--quiet", pl.CloneURL, dir)
393 // Het runner-token via de omgeving, niet in de proceslijst.
394 cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_CONFIG_COUNT=1",
395 "GIT_CONFIG_KEY_0=http.extraHeader", "GIT_CONFIG_VALUE_0=Authorization: Bearer "+c.cfg.Token)
396 out, err := cmd.CombinedOutput()
397 if err != nil {
398 return fmt.Errorf("%s", strings.ReplaceAll(strings.TrimSpace(string(out)), c.cfg.Token, "[MASKED]"))
399 }
400 return nil
401 }
402 inputs := func(ctx context.Context, dir string) error {
403 resp, err := c.do(ctx, http.MethodGet, base+"/inputs", nil, "")
404 if err != nil {
405 return err
406 }
407 defer resp.Body.Close()
408 if resp.StatusCode != http.StatusOK {
409 return fmt.Errorf("inputs: %d", resp.StatusCode)
410 }
411 return runner.ReadTar(resp.Body, dir, nil, 0)
412 }
413 err := r.RunRemote(runCtx, pl, work, logs.add, clone, inputs)
414 if err == nil && len(pl.Job.ArtifactPaths) > 0 {
415 err = c.upload(runCtx, base, work, pl.Job.ArtifactPaths)
416 }
417 close(done)
418 <-flushed
419 send()
420 status, msg := "success", ""
421 cmu.Lock()
422 wasCanceled := canceled
423 cmu.Unlock()
424 switch {
425 case err == nil:
426 case wasCanceled:
427 status = "canceled"
428 case errors.Is(runCtx.Err(), context.DeadlineExceeded):
429 status, msg = "failed", "job_execution_timeout: "+err.Error()
430 default:
431 status, msg = "failed", err.Error()
432 }
433 fctx, fc := context.WithTimeout(context.Background(), time.Minute)
434 defer fc()
435 if ferr := c.postJSON(fctx, base+"/finish", map[string]string{"status": status, "message": msg}, nil); ferr != nil {
436 c.log.Error("finish", "job", pl.JobID, "err", ferr)
437 }
438 c.log.Info("job done", "id", pl.JobID, "status", status)
439}
440
441func (c *client) upload(ctx context.Context, base, work string, paths []string) error {
442 pr, pw := io.Pipe()
443 go func() { pw.CloseWithError(runner.WriteTar(pw, work, paths)) }()
444 resp, err := c.do(ctx, http.MethodPut, base+"/artifacts", pr, "application/gzip")
445 if err != nil {
446 return fmt.Errorf("artifacts upload: %w", err)
447 }
448 defer resp.Body.Close()
449 if resp.StatusCode != http.StatusOK {
450 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
451 return fmt.Errorf("artifacts upload: %d %s", resp.StatusCode, strings.TrimSpace(string(msg)))
452 }
453 return nil
454}