BlueGit

timfa bluegit

Files

bluegit / cmd / bluegit-runner / main.go

main.go

main.go 11.6 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 if *token == "" {
121 *token = os.Getenv("BLUEGIT_RUNNER_REGISTRATION_TOKEN")
122 }
123 if *url == "" || *token == "" {
124 return errors.New("--url and --token are required")
125 }
126 if *name == "" {
127 *name, _ = os.Hostname()
128 }
129 var existing Config
130 if b, err := os.ReadFile(*cfgPath); err == nil {
131 _ = yaml.Unmarshal(b, &existing)
132 }
133 body, _ := json.Marshal(map[string]string{"token": *token, "name": *name, "version": version})
134 resp, err := http.Post(strings.TrimRight(*url, "/")+"/api/v1/runners/register", "application/json", bytes.NewReader(body))
135 if err != nil {
136 return err
137 }
138 defer resp.Body.Close()
139 var out struct {
140 ID int64 `json:"id"`
141 Name string `json:"name"`
142 Token string `json:"token"`
143 Message string `json:"message"`
144 }
145 _ = json.NewDecoder(resp.Body).Decode(&out)
146 if resp.StatusCode != http.StatusCreated || out.Token == "" {
147 return fmt.Errorf("registration failed (%d): %s", resp.StatusCode, out.Message)
148 }
149 existing.URL, existing.Token, existing.Name = strings.TrimRight(*url, "/"), out.Token, out.Name
150 b, err := yaml.Marshal(existing)
151 if err != nil {
152 return err
153 }
154 if err := os.MkdirAll(filepath.Dir(*cfgPath), 0o755); err != nil {
155 return err
156 }
157 if err := os.WriteFile(*cfgPath, b, 0o600); err != nil {
158 return err
159 }
160 if os.Geteuid() == 0 {
161 if u, err := user.Lookup("bluegit-runner"); err == nil {
162 uid, _ := strconv.Atoi(u.Uid)
163 gid, _ := strconv.Atoi(u.Gid)
164 _ = os.Chown(*cfgPath, uid, gid)
165 }
166 }
167 fmt.Printf("registered runner %q (id %d); config written to %s\n", out.Name, out.ID, *cfgPath)
168 fmt.Println("start it with: sudo systemctl enable --now bluegit-runner")
169 return nil
170}
171
172type client struct {
173 cfg Config
174 http *http.Client
175 log *slog.Logger
176}
177
178func (c *client) do(ctx context.Context, method, path string, body io.Reader, ctype string) (*http.Response, error) {
179 req, err := http.NewRequestWithContext(ctx, method, c.cfg.URL+path, body)
180 if err != nil {
181 return nil, err
182 }
183 req.Header.Set("Authorization", "Bearer "+c.cfg.Token)
184 req.Header.Set("X-Runner-Version", version)
185 if ctype != "" {
186 req.Header.Set("Content-Type", ctype)
187 }
188 return c.http.Do(req)
189}
190
191func (c *client) postJSON(ctx context.Context, path string, in, out any) error {
192 b, _ := json.Marshal(in)
193 resp, err := c.do(ctx, http.MethodPost, path, bytes.NewReader(b), "application/json")
194 if err != nil {
195 return err
196 }
197 defer resp.Body.Close()
198 if resp.StatusCode >= 300 {
199 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
200 return fmt.Errorf("%s: %d %s", path, resp.StatusCode, strings.TrimSpace(string(msg)))
201 }
202 if out != nil {
203 return json.NewDecoder(resp.Body).Decode(out)
204 }
205 return nil
206}
207
208func cmdRun(args []string) error {
209 fs := flag.NewFlagSet("run", flag.ExitOnError)
210 cfgPath := fs.String("config", defaultConfig, "config file")
211 once := fs.Bool("once", false, "run at most one job, then exit (for tests)")
212 _ = fs.Parse(args)
213 cfg, err := loadConfig(*cfgPath)
214 if err != nil {
215 return err
216 }
217 log := slog.New(slog.NewTextHandler(os.Stderr, nil))
218 ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
219 defer stop()
220 c := &client{cfg: cfg, http: &http.Client{Timeout: 0}, log: log}
221 if err := c.postJSON(ctx, "/api/v1/runner/heartbeat", map[string]string{}, nil); err != nil {
222 return fmt.Errorf("cannot reach BlueGit: %w", err)
223 }
224 log.Info("bluegit-runner started", "url", cfg.URL, "name", cfg.Name, "version", version, "concurrency", cfg.Concurrency)
225 go func() {
226 t := time.NewTicker(30 * time.Second)
227 defer t.Stop()
228 for {
229 select {
230 case <-ctx.Done():
231 return
232 case <-t.C:
233 if err := c.postJSON(ctx, "/api/v1/runner/heartbeat", map[string]string{}, nil); err != nil && ctx.Err() == nil {
234 log.Warn("heartbeat", "err", err)
235 }
236 }
237 }
238 }()
239 var wg sync.WaitGroup
240 for i := 0; i < cfg.Concurrency; i++ {
241 wg.Add(1)
242 go func() {
243 defer wg.Done()
244 for ctx.Err() == nil {
245 ran, err := c.poll(ctx)
246 if err != nil && ctx.Err() == nil {
247 log.Warn("poll", "err", err)
248 select {
249 case <-ctx.Done():
250 case <-time.After(5 * time.Second):
251 }
252 }
253 if ran && *once {
254 stop()
255 }
256 }
257 }()
258 }
259 wg.Wait()
260 return nil
261}
262
263func (c *client) poll(ctx context.Context) (bool, error) {
264 pctx, cancel := context.WithTimeout(ctx, 60*time.Second)
265 defer cancel()
266 resp, err := c.do(pctx, http.MethodPost, "/api/v1/runner/jobs/request", strings.NewReader("{}"), "application/json")
267 if err != nil {
268 return false, err
269 }
270 defer resp.Body.Close()
271 if resp.StatusCode == http.StatusNoContent {
272 return false, nil
273 }
274 if resp.StatusCode != http.StatusOK {
275 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
276 return false, fmt.Errorf("request: %d %s", resp.StatusCode, strings.TrimSpace(string(msg)))
277 }
278 var pl runner.RemotePayload
279 if err := json.NewDecoder(resp.Body).Decode(&pl); err != nil {
280 return false, err
281 }
282 c.runJob(ctx, pl)
283 return true, nil
284}
285
286// logBuffer verzamelt logregels en stuurt ze elke seconde door.
287type logBuffer struct {
288 mu sync.Mutex
289 buf strings.Builder
290}
291
292func (l *logBuffer) add(s string) {
293 l.mu.Lock()
294 l.buf.WriteString(s)
295 l.mu.Unlock()
296}
297
298func (l *logBuffer) take() string {
299 l.mu.Lock()
300 defer l.mu.Unlock()
301 s := l.buf.String()
302 l.buf.Reset()
303 return s
304}
305
306func (c *client) runJob(parent context.Context, pl runner.RemotePayload) {
307 c.log.Info("job", "id", pl.JobID, "name", pl.Job.Name)
308 base := fmt.Sprintf("/api/v1/runner/jobs/%d", pl.JobID)
309 ctx, cancel := context.WithCancel(parent)
310 defer cancel()
311 runCtx := ctx
312 if pl.Timeout > 0 {
313 var tc context.CancelFunc
314 runCtx, tc = context.WithTimeout(ctx, time.Duration(pl.Timeout)*time.Second)
315 defer tc()
316 }
317 var canceled bool
318 var cmu sync.Mutex
319 logs := &logBuffer{}
320 send := func() {
321 chunk := logs.take()
322 var out struct {
323 Cancel bool `json:"cancel"`
324 }
325 sctx, sc := context.WithTimeout(context.Background(), 30*time.Second)
326 defer sc()
327 err := func() error {
328 resp, err := c.do(sctx, http.MethodPost, base+"/log", strings.NewReader(chunk), "text/plain")
329 if err != nil {
330 return err
331 }
332 defer resp.Body.Close()
333 if resp.StatusCode != http.StatusOK {
334 return fmt.Errorf("log: %d", resp.StatusCode)
335 }
336 return json.NewDecoder(resp.Body).Decode(&out)
337 }()
338 if err != nil {
339 // Bij een fout gaat de chunk terug in de buffer voor de volgende poging.
340 if chunk != "" {
341 logs.mu.Lock()
342 rest := logs.buf.String()
343 logs.buf.Reset()
344 logs.buf.WriteString(chunk + rest)
345 logs.mu.Unlock()
346 }
347 return
348 }
349 if out.Cancel {
350 cmu.Lock()
351 canceled = true
352 cmu.Unlock()
353 cancel()
354 }
355 }
356 done := make(chan struct{})
357 flushed := make(chan struct{})
358 go func() {
359 defer close(flushed)
360 t := time.NewTicker(time.Second)
361 defer t.Stop()
362 for {
363 select {
364 case <-done:
365 return
366 case <-t.C:
367 send()
368 }
369 }
370 }()
371 r := &runner.Runner{GitBin: c.cfg.Git, Docker: c.cfg.Docker, Storage: c.cfg.WorkDir, Network: c.cfg.Network, Name: c.cfg.Name}
372 work := filepath.Join(c.cfg.WorkDir, "work", strconv.FormatInt(pl.JobID, 10))
373 defer os.RemoveAll(work)
374 clone := func(ctx context.Context, dir string) error {
375 cmd := exec.CommandContext(ctx, c.cfg.Git, "clone", "--quiet", pl.CloneURL, dir)
376 // Het runner-token via de omgeving, niet in de proceslijst.
377 cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_CONFIG_COUNT=1",
378 "GIT_CONFIG_KEY_0=http.extraHeader", "GIT_CONFIG_VALUE_0=Authorization: Bearer "+c.cfg.Token)
379 out, err := cmd.CombinedOutput()
380 if err != nil {
381 return fmt.Errorf("%s", strings.ReplaceAll(strings.TrimSpace(string(out)), c.cfg.Token, "[MASKED]"))
382 }
383 return nil
384 }
385 inputs := func(ctx context.Context, dir string) error {
386 resp, err := c.do(ctx, http.MethodGet, base+"/inputs", nil, "")
387 if err != nil {
388 return err
389 }
390 defer resp.Body.Close()
391 if resp.StatusCode != http.StatusOK {
392 return fmt.Errorf("inputs: %d", resp.StatusCode)
393 }
394 return runner.ReadTar(resp.Body, dir, nil, 0)
395 }
396 err := r.RunRemote(runCtx, pl, work, logs.add, clone, inputs)
397 if err == nil && len(pl.Job.ArtifactPaths) > 0 {
398 err = c.upload(runCtx, base, work, pl.Job.ArtifactPaths)
399 }
400 close(done)
401 <-flushed
402 send()
403 status, msg := "success", ""
404 cmu.Lock()
405 wasCanceled := canceled
406 cmu.Unlock()
407 switch {
408 case err == nil:
409 case wasCanceled:
410 status = "canceled"
411 case errors.Is(runCtx.Err(), context.DeadlineExceeded):
412 status, msg = "failed", "job_execution_timeout: "+err.Error()
413 default:
414 status, msg = "failed", err.Error()
415 }
416 fctx, fc := context.WithTimeout(context.Background(), time.Minute)
417 defer fc()
418 if ferr := c.postJSON(fctx, base+"/finish", map[string]string{"status": status, "message": msg}, nil); ferr != nil {
419 c.log.Error("finish", "job", pl.JobID, "err", ferr)
420 }
421 c.log.Info("job done", "id", pl.JobID, "status", status)
422}
423
424func (c *client) upload(ctx context.Context, base, work string, paths []string) error {
425 pr, pw := io.Pipe()
426 go func() { pw.CloseWithError(runner.WriteTar(pw, work, paths)) }()
427 resp, err := c.do(ctx, http.MethodPut, base+"/artifacts", pr, "application/gzip")
428 if err != nil {
429 return fmt.Errorf("artifacts upload: %w", err)
430 }
431 defer resp.Body.Close()
432 if resp.StatusCode != http.StatusOK {
433 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
434 return fmt.Errorf("artifacts upload: %d %s", resp.StatusCode, strings.TrimSpace(string(msg)))
435 }
436 return nil
437}