BlueGit

timfa bluegit

Files

bluegit / cmd / bluegit-runner / main.go

main.go

main.go 18.5 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/apppaths"
30 "gitlab.com/Timfa/bluegit/internal/runner"
31 "gitlab.com/Timfa/bluegit/internal/runnercfg"
32)
33
34var version = "dev"
35
36var defaultConfig = apppaths.ConfigFile("", "BLUEGIT_RUNNER_CONFIG", "", "/etc/bluegit-runner/config.yml", "BlueGit-runner")
37
38// maxWorkers is de bovengrens voor concurrency.
39const maxWorkers = 64
40
41// Config staat in /etc/bluegit-runner/config.yml, of op Windows in
42// %LOCALAPPDATA%\BlueGit-runner\config.yml.
43type Config struct {
44 URL string `yaml:"url"`
45 Token string `yaml:"token"`
46 Name string `yaml:"name"`
47 Docker string `yaml:"docker"`
48 Git string `yaml:"git"`
49 WorkDir string `yaml:"work_dir"`
50 Network string `yaml:"network"`
51 Concurrency int `yaml:"concurrency"`
52 // UIListen is het adres van de webinterface; "off" zet hem uit.
53 UIListen string `yaml:"ui_listen"`
54 // Language is de standaardtaal van de webinterface (en, nl, de, fr).
55 Language string `yaml:"language"`
56}
57
58func (c *Config) defaults() {
59 if c.Docker == "" {
60 c.Docker = "docker"
61 }
62 if c.Git == "" {
63 c.Git = "git"
64 }
65 if c.WorkDir == "" {
66 c.WorkDir = apppaths.DataDir("/var/lib/bluegit-runner", "BlueGit-runner")
67 }
68 if c.Network == "" {
69 c.Network = "bridge"
70 }
71 if c.Concurrency < 1 {
72 c.Concurrency = 1
73 }
74 if c.UIListen == "" {
75 c.UIListen = defaultUIListen
76 }
77 c.URL = strings.TrimRight(c.URL, "/")
78}
79
80func main() {
81 if len(os.Args) < 2 {
82 usage()
83 os.Exit(2)
84 }
85 var err error
86 switch os.Args[1] {
87 case "register":
88 err = cmdRegister(os.Args[2:])
89 case "run":
90 err = cmdRun(os.Args[2:])
91 case "ui-token":
92 err = cmdUIToken(os.Args[2:])
93 case "version", "--version":
94 fmt.Println(version)
95 default:
96 usage()
97 os.Exit(2)
98 }
99 if err != nil {
100 fmt.Fprintln(os.Stderr, "bluegit-runner:", err)
101 os.Exit(1)
102 }
103}
104
105func usage() {
106 fmt.Fprintln(os.Stderr, `usage:
107 bluegit-runner run [--work-dir DIR] [--config PATH]
108 bluegit-runner register --url https://git.example.com --token bgrr_... [--name NAME] [--work-dir DIR] [--config PATH]
109 bluegit-runner ui-token [--work-dir DIR] [--config PATH]
110 bluegit-runner version
111
112Koppelen en instellingen gaan via de webinterface: open http://127.0.0.1:8765
113(of ui_listen), meld je aan met het beheertoken uit "bluegit-runner ui-token",
114en vul onder Koppeling de BlueGit-URL en het registratietoken in.
115De CLI-register is een alternatief. work_dir (standaard /var/lib/bluegit-runner)
116en het eerste beheertoken blijven buiten de UI.`)
117}
118
119func loadConfig(path string) (Config, error) {
120 var c Config
121 b, err := os.ReadFile(path)
122 if err != nil {
123 return c, err
124 }
125 if err := yaml.Unmarshal(b, &c); err != nil {
126 return c, err
127 }
128 c.defaults()
129 if c.URL == "" || c.Token == "" {
130 return c, fmt.Errorf("%s: url and token are required; run bluegit-runner register first", path)
131 }
132 return c, nil
133}
134
135func cmdRegister(args []string) error {
136 fs := flag.NewFlagSet("register", flag.ExitOnError)
137 url := fs.String("url", "", "BlueGit base URL")
138 token := fs.String("token", "", "registration token from the BlueGit UI")
139 name := fs.String("name", "", "runner name (default: hostname)")
140 cfgPath := fs.String("config", defaultConfig, "config file")
141 workDir := fs.String("work-dir", "", "work directory (default: /var/lib/bluegit-runner)")
142 _ = fs.Parse(args)
143 // Niet-interactief (agents): alles mag ook via de omgeving.
144 if *token == "" {
145 *token = os.Getenv("BLUEGIT_RUNNER_REGISTRATION_TOKEN")
146 }
147 if *url == "" {
148 *url = os.Getenv("BLUEGIT_RUNNER_URL")
149 }
150 if *name == "" {
151 *name = os.Getenv("BLUEGIT_RUNNER_NAME")
152 }
153 if *url == "" || *token == "" {
154 return errors.New("--url and --token are required")
155 }
156 if *name == "" {
157 *name, _ = os.Hostname()
158 }
159 var existing Config
160 if b, err := os.ReadFile(*cfgPath); err == nil {
161 _ = yaml.Unmarshal(b, &existing)
162 }
163 body, _ := json.Marshal(map[string]string{"token": *token, "name": *name, "version": version})
164 resp, err := http.Post(strings.TrimRight(*url, "/")+"/api/v1/runners/register", "application/json", bytes.NewReader(body))
165 if err != nil {
166 return err
167 }
168 defer resp.Body.Close()
169 var out struct {
170 ID int64 `json:"id"`
171 Name string `json:"name"`
172 Token string `json:"token"`
173 Message string `json:"message"`
174 }
175 _ = json.NewDecoder(resp.Body).Decode(&out)
176 if resp.StatusCode != http.StatusCreated || out.Token == "" {
177 return fmt.Errorf("registration failed (%d): %s", resp.StatusCode, out.Message)
178 }
179 existing.URL, existing.Token, existing.Name = strings.TrimRight(*url, "/"), out.Token, out.Name
180 b, err := yaml.Marshal(existing)
181 if err != nil {
182 return err
183 }
184 if err := os.MkdirAll(filepath.Dir(*cfgPath), 0o755); err != nil {
185 return err
186 }
187 if err := os.WriteFile(*cfgPath, b, 0o600); err != nil {
188 return err
189 }
190 work := resolveWorkDir(*workDir, *cfgPath, existing)
191 existing.defaults()
192 existing.WorkDir = work
193 if err := saveConnection(work, machineFrom(existing)); err != nil {
194 return err
195 }
196 if os.Geteuid() == 0 {
197 if u, err := user.Lookup("bluegit-runner"); err == nil {
198 uid, _ := strconv.Atoi(u.Uid)
199 gid, _ := strconv.Atoi(u.Gid)
200 _ = os.Chown(*cfgPath, uid, gid)
201 }
202 }
203 fmt.Printf("registered runner %q (id %d); config written to %s\n", out.Name, out.ID, *cfgPath)
204 fmt.Printf("web UI: http://%s (admin token: sudo bluegit-runner ui-token)\n", defaultUIListen)
205 // Met het AUR-pakket: de service is al enabled en wacht op de config.
206 if os.Geteuid() == 0 && *cfgPath == defaultConfig {
207 if _, err := os.Stat("/usr/lib/systemd/system/bluegit-runner.service"); err == nil {
208 if err := exec.Command("systemctl", "enable", "--now", "bluegit-runner.service").Run(); err == nil {
209 _ = exec.Command("systemctl", "restart", "bluegit-runner.service").Run()
210 fmt.Println("bluegit-runner.service started")
211 return nil
212 }
213 }
214 }
215 fmt.Println("start it with: sudo systemctl enable --now bluegit-runner")
216 return nil
217}
218
219type client struct {
220 cfg Config
221 http *http.Client
222 log *slog.Logger
223 // beheer (webinterface)
224 file *runnercfg.File
225 jobs *runnercfg.Tracker
226 stMu sync.Mutex
227 cfgMu sync.Mutex
228 seen time.Time
229 srvName string
230 srvPause bool
231}
232
233func (c *client) snapshot() Config {
234 c.cfgMu.Lock()
235 defer c.cfgMu.Unlock()
236 return c.cfg
237}
238
239func (c *client) setMachine(m machineSettings) error {
240 c.cfgMu.Lock()
241 applyMachine(&c.cfg, m)
242 c.cfg.defaults()
243 work := c.cfg.WorkDir
244 snap := machineFrom(c.cfg)
245 c.cfgMu.Unlock()
246 return saveConnection(work, snap)
247}
248
249func (c *client) settings() runnercfg.Settings {
250 s, err := c.file.Load(c.defaults())
251 if err != nil {
252 return c.defaults()
253 }
254 return s
255}
256
257func (c *client) defaults() runnercfg.Settings {
258 d := runnercfg.Defaults()
259 d.Concurrency = c.cfg.Concurrency
260 return d
261}
262
263func (c *client) status() runnercfg.Status {
264 c.stMu.Lock()
265 defer c.stMu.Unlock()
266 name := c.settings().Name
267 if name == "" {
268 name = c.srvName
269 }
270 if name == "" {
271 name = c.cfg.Name
272 }
273 docker := runnercfg.PingDocker(context.Background(), c.cfg.Docker)
274 online := !c.seen.IsZero() && time.Since(c.seen) < 90*time.Second && docker.Reachable
275 return runnercfg.Status{Kind: "standalone", Name: name, Version: version, ServerURL: c.cfg.URL,
276 Online: online, LastContact: c.seen, ServerPause: c.srvPause, Docker: docker}
277}
278
279// heartbeat meldt pauze en (lokaal ingestelde) naam aan de server.
280func (c *client) heartbeat(ctx context.Context) error {
281 s := c.settings()
282 var out struct {
283 Name string `json:"name"`
284 Paused bool `json:"paused"`
285 }
286 err := c.postJSON(ctx, "/api/v1/runner/heartbeat", map[string]any{"draining": s.Paused, "name": s.Name}, &out)
287 if err == nil {
288 c.stMu.Lock()
289 c.seen, c.srvName, c.srvPause = time.Now(), out.Name, out.Paused
290 c.stMu.Unlock()
291 }
292 return err
293}
294
295func cmdUIToken(args []string) error {
296 fs := flag.NewFlagSet("ui-token", flag.ExitOnError)
297 cfgPath := fs.String("config", defaultConfig, "config file")
298 workDir := fs.String("work-dir", "", "work directory (default: /var/lib/bluegit-runner)")
299 _ = fs.Parse(args)
300 cfg, err := loadRuntime(*cfgPath, *workDir, nil)
301 if err != nil {
302 return err
303 }
304 tok, _, err := ensureUIToken(cfg)
305 if err != nil {
306 return fmt.Errorf("%w (run as root or as bluegit-runner)", err)
307 }
308 fmt.Printf("web UI: http://%s\nadmin token: %s\n", cfg.UIListen, tok)
309 return nil
310}
311
312func (c *client) do(ctx context.Context, method, path string, body io.Reader, ctype string) (*http.Response, error) {
313 cfg := c.snapshot()
314 req, err := http.NewRequestWithContext(ctx, method, cfg.URL+path, body)
315 if err != nil {
316 return nil, err
317 }
318 req.Header.Set("Authorization", "Bearer "+cfg.Token)
319 req.Header.Set("X-Runner-Version", version)
320 if ctype != "" {
321 req.Header.Set("Content-Type", ctype)
322 }
323 return c.http.Do(req)
324}
325
326func (c *client) postJSON(ctx context.Context, path string, in, out any) error {
327 b, _ := json.Marshal(in)
328 resp, err := c.do(ctx, http.MethodPost, path, bytes.NewReader(b), "application/json")
329 if err != nil {
330 return err
331 }
332 defer resp.Body.Close()
333 if resp.StatusCode >= 300 {
334 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
335 return fmt.Errorf("%s: %d %s", path, resp.StatusCode, strings.TrimSpace(string(msg)))
336 }
337 if out != nil {
338 return json.NewDecoder(resp.Body).Decode(out)
339 }
340 return nil
341}
342
343func cmdRun(args []string) error {
344 fs := flag.NewFlagSet("run", flag.ExitOnError)
345 cfgPath := fs.String("config", defaultConfig, "config file")
346 workDir := fs.String("work-dir", "", "work directory (default: /var/lib/bluegit-runner)")
347 once := fs.Bool("once", false, "run at most one job, then exit (for tests)")
348 _ = fs.Parse(args)
349 log := slog.New(slog.NewTextHandler(os.Stderr, nil))
350 cfg, err := loadRuntime(*cfgPath, *workDir, log)
351 if err != nil {
352 return err
353 }
354 ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
355 defer stop()
356 c := &client{cfg: cfg, http: &http.Client{Timeout: 0}, log: log,
357 file: &runnercfg.File{Path: filepath.Join(cfg.WorkDir, "settings.json")}, jobs: &runnercfg.Tracker{}}
358 c.jobs.SetPaused(c.settings().Paused)
359 if registered(cfg) {
360 if err := c.heartbeat(ctx); err != nil {
361 log.Warn("cannot reach BlueGit yet", "err", err)
362 }
363 log.Info("bluegit-runner started", "url", cfg.URL, "name", c.status().Name, "version", version, "concurrency", c.settings().Concurrency)
364 } else {
365 log.Info("bluegit-runner started zonder koppeling; registreer in de webinterface", "work_dir", cfg.WorkDir)
366 }
367 if cfg.UIListen != "off" {
368 tok, created, err := ensureUIToken(cfg)
369 if err != nil {
370 log.Warn("web UI token", "err", err)
371 } else {
372 h := &runnercfg.Handler{File: c.file, Default: c.defaults(), Tracker: c.jobs, WorkDir: cfg.WorkDir,
373 Status: c.status, Apply: func(runnercfg.Settings) error {
374 hctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
375 defer cancel()
376 _ = c.heartbeat(hctx) // naam en pauze meteen naar de server
377 return nil
378 }}
379 ui := newWebUI(cfg, tok, h)
380 relisten := func(addr string) error { return relistenUI(ui, addr, log.Warn) }
381 mountConnect(ui, c, relisten)
382 if err := serveUI(ctx, ui, cfg.UIListen, log.Warn); err != nil {
383 log.Warn("web UI", "listen", cfg.UIListen, "err", err)
384 } else {
385 log.Info("web UI", "url", "http://"+cfg.UIListen, "first_start", created, "token", "see: bluegit-runner ui-token")
386 }
387 }
388 }
389 go func() {
390 t := time.NewTicker(30 * time.Second)
391 defer t.Stop()
392 for {
393 select {
394 case <-ctx.Done():
395 return
396 case <-t.C:
397 if err := c.heartbeat(ctx); err != nil && ctx.Err() == nil {
398 log.Warn("heartbeat", "err", err)
399 }
400 }
401 }
402 }()
403 var wg sync.WaitGroup
404 // Een vaste pool; worker i werkt alleen als i < concurrency en niet gepauzeerd.
405 for i := 0; i < maxWorkers; i++ {
406 wg.Add(1)
407 go func(i int) {
408 defer wg.Done()
409 for ctx.Err() == nil {
410 s := c.settings()
411 if s.Paused || i >= s.Concurrency {
412 select {
413 case <-ctx.Done():
414 case <-time.After(2 * time.Second):
415 }
416 continue
417 }
418 if !registered(c.snapshot()) {
419 select {
420 case <-ctx.Done():
421 case <-time.After(2 * time.Second):
422 }
423 continue
424 }
425 ran, err := c.poll(ctx)
426 if err != nil && ctx.Err() == nil {
427 log.Warn("poll", "err", err)
428 select {
429 case <-ctx.Done():
430 case <-time.After(5 * time.Second):
431 }
432 }
433 if ran && *once {
434 stop()
435 }
436 }
437 }(i)
438 }
439 wg.Wait()
440 return nil
441}
442
443func (c *client) poll(ctx context.Context) (bool, error) {
444 pctx, cancel := context.WithTimeout(ctx, 60*time.Second)
445 defer cancel()
446 resp, err := c.do(pctx, http.MethodPost, "/api/v1/runner/jobs/request", strings.NewReader("{}"), "application/json")
447 if err != nil {
448 return false, err
449 }
450 defer resp.Body.Close()
451 if resp.StatusCode == http.StatusNoContent {
452 return false, nil
453 }
454 if resp.StatusCode != http.StatusOK {
455 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
456 return false, fmt.Errorf("request: %d %s", resp.StatusCode, strings.TrimSpace(string(msg)))
457 }
458 var pl runner.RemotePayload
459 if err := json.NewDecoder(resp.Body).Decode(&pl); err != nil {
460 return false, err
461 }
462 c.runJob(ctx, pl)
463 return true, nil
464}
465
466// logBuffer verzamelt logregels en stuurt ze elke seconde door.
467type logBuffer struct {
468 mu sync.Mutex
469 buf strings.Builder
470}
471
472func (l *logBuffer) add(s string) {
473 l.mu.Lock()
474 l.buf.WriteString(s)
475 l.mu.Unlock()
476}
477
478func (l *logBuffer) take() string {
479 l.mu.Lock()
480 defer l.mu.Unlock()
481 s := l.buf.String()
482 l.buf.Reset()
483 return s
484}
485
486func (c *client) runJob(parent context.Context, pl runner.RemotePayload) {
487 c.log.Info("job", "id", pl.JobID, "name", pl.Job.Name)
488 base := fmt.Sprintf("/api/v1/runner/jobs/%d", pl.JobID)
489 if pl.Job.DoNotInterrupt {
490 // Stoppen van de runner (SIGTERM) breekt deze job niet af; de
491 // workers wachten tot hij klaar is. Annuleren met force werkt wel.
492 parent = context.WithoutCancel(parent)
493 }
494 ctx, cancel := context.WithCancel(parent)
495 defer cancel()
496 runCtx := ctx
497 limitSource := runner.TimeoutFromServer
498 if pl.Job.Timeout > 0 {
499 limitSource = runner.TimeoutFromJob
500 }
501 if m := c.settings().JobTimeoutMin; m > 0 && (pl.Timeout <= 0 || int64(m*60) < pl.Timeout) {
502 pl.Timeout = int64(m * 60)
503 limitSource = runner.TimeoutFromRunner
504 }
505 if pl.Timeout > 0 {
506 var tc context.CancelFunc
507 runCtx, tc = context.WithTimeout(ctx, time.Duration(pl.Timeout)*time.Second)
508 defer tc()
509 }
510 var canceled bool
511 var cmu sync.Mutex
512 logs := &logBuffer{}
513 send := func() {
514 chunk := logs.take()
515 var out struct {
516 Cancel bool `json:"cancel"`
517 }
518 sctx, sc := context.WithTimeout(context.Background(), 30*time.Second)
519 defer sc()
520 err := func() error {
521 resp, err := c.do(sctx, http.MethodPost, base+"/log", strings.NewReader(chunk), "text/plain")
522 if err != nil {
523 return err
524 }
525 defer resp.Body.Close()
526 if resp.StatusCode != http.StatusOK {
527 return fmt.Errorf("log: %d", resp.StatusCode)
528 }
529 return json.NewDecoder(resp.Body).Decode(&out)
530 }()
531 if err != nil {
532 // Bij een fout gaat de chunk terug in de buffer voor de volgende poging.
533 if chunk != "" {
534 logs.mu.Lock()
535 rest := logs.buf.String()
536 logs.buf.Reset()
537 logs.buf.WriteString(chunk + rest)
538 logs.mu.Unlock()
539 }
540 return
541 }
542 if out.Cancel {
543 cmu.Lock()
544 canceled = true
545 cmu.Unlock()
546 cancel()
547 }
548 }
549 done := make(chan struct{})
550 flushed := make(chan struct{})
551 go func() {
552 defer close(flushed)
553 t := time.NewTicker(time.Second)
554 defer t.Stop()
555 for {
556 select {
557 case <-done:
558 return
559 case <-t.C:
560 send()
561 }
562 }
563 }()
564 st := c.settings()
565 r := &runner.Runner{GitBin: c.cfg.Git, Docker: c.cfg.Docker, Storage: c.cfg.WorkDir, Network: c.cfg.Network, Name: c.status().Name}
566 if over, oerr := st.Overrides(c.cfg.WorkDir, nil); oerr == nil {
567 r.Configure(st, over)
568 }
569 c.jobs.Start(runnercfg.JobInfo{ID: pl.JobID, Name: pl.Job.Name, Pipeline: pl.PipelineID, Image: pl.Job.Image,
570 Project: pl.Env["CI_PROJECT_PATH"], URL: pl.Env["CI_JOB_URL"]})
571 work := filepath.Join(c.cfg.WorkDir, "work", strconv.FormatInt(pl.JobID, 10))
572 defer func() {
573 if st.CleanupWork {
574 _ = runner.ClearWorkDir(work)
575 }
576 runnercfg.Cleanup(context.Background(), c.cfg.Docker, c.settings(), c.jobs, filepath.Join(c.cfg.WorkDir, "cache"))
577 }()
578 clone := func(ctx context.Context, dir string) error {
579 cmd := exec.CommandContext(ctx, c.cfg.Git, "clone", "--quiet", pl.CloneURL, dir)
580 // Het runner-token via de omgeving, niet in de proceslijst.
581 cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_CONFIG_COUNT=1",
582 "GIT_CONFIG_KEY_0=http.extraHeader", "GIT_CONFIG_VALUE_0=Authorization: Bearer "+c.cfg.Token)
583 out, err := cmd.CombinedOutput()
584 if err != nil {
585 return fmt.Errorf("%s", strings.ReplaceAll(strings.TrimSpace(string(out)), c.cfg.Token, "[MASKED]"))
586 }
587 return nil
588 }
589 inputs := func(ctx context.Context, dir string) error {
590 resp, err := c.do(ctx, http.MethodGet, base+"/inputs", nil, "")
591 if err != nil {
592 return err
593 }
594 defer resp.Body.Close()
595 if resp.StatusCode != http.StatusOK {
596 return fmt.Errorf("inputs: %d", resp.StatusCode)
597 }
598 return runner.ReadTar(resp.Body, dir, nil, 0)
599 }
600 err := r.RunRemote(runCtx, pl, work, logs.add, clone, inputs)
601 if err == nil && len(pl.Job.ArtifactPaths) > 0 {
602 err = c.upload(runCtx, base, work, pl.Job.ArtifactPaths)
603 }
604 close(done)
605 <-flushed
606 send()
607 status, msg := "success", ""
608 cmu.Lock()
609 wasCanceled := canceled
610 cmu.Unlock()
611 switch {
612 case err == nil:
613 case wasCanceled:
614 status = "canceled"
615 case errors.Is(runCtx.Err(), context.DeadlineExceeded):
616 status, msg = "failed", "job_execution_timeout: "+runner.TimedOutLine(time.Duration(pl.Timeout)*time.Second, limitSource)
617 default:
618 status, msg = "failed", err.Error()
619 }
620 fctx, fc := context.WithTimeout(context.Background(), time.Minute)
621 defer fc()
622 if ferr := c.postJSON(fctx, base+"/finish", map[string]string{"status": status, "message": msg}, nil); ferr != nil {
623 c.log.Error("finish", "job", pl.JobID, "err", ferr)
624 }
625 c.jobs.Finish(pl.JobID, status)
626 c.log.Info("job done", "id", pl.JobID, "status", status)
627}
628
629func (c *client) upload(ctx context.Context, base, work string, paths []string) error {
630 pr, pw := io.Pipe()
631 go func() { pw.CloseWithError(runner.WriteTar(pw, work, paths)) }()
632 resp, err := c.do(ctx, http.MethodPut, base+"/artifacts", pr, "application/gzip")
633 if err != nil {
634 return fmt.Errorf("artifacts upload: %w", err)
635 }
636 defer resp.Body.Close()
637 if resp.StatusCode != http.StatusOK {
638 msg, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
639 return fmt.Errorf("artifacts upload: %d %s", resp.StatusCode, strings.TrimSpace(string(msg)))
640 }
641 return nil
642}