package server import ( "context" "gitlab.com/Timfa/bluegit/internal/store" "html/template" "net/http" "path/filepath" "strconv" "strings" "time" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/runnercfg" "gitlab.com/Timfa/bluegit/internal/update" ) // Beheer van de ingebouwde runner (Steve) door de sitebeheerder: dezelfde // instellingen en hetzelfde scherm als de webinterface van bluegit-runner. // UI op /admin/runner, API op /api/v1/admin/runner/... (beheerder-token). // Pauze is een drain: lopende jobs lopen af, nieuwe blijven queued (of // gaan naar een andere runner). De self-update wacht alleen op running // jobs, dus een gepauzeerde runner houdt een update niet tegen. func (s *Server) runnerSettingsFile() *runnercfg.File { dir := s.StateDir if dir == "" { dir = s.StoragePath() } return &runnercfg.File{Path: filepath.Join(dir, "runner-settings.json")} } func (s *Server) builtinDefaults() runnercfg.Settings { d := runnercfg.Defaults() if s.Cfg.CI.Concurrency > 0 { d.Concurrency = s.Cfg.CI.Concurrency } return d } func (s *Server) runnerWorkDir() string { if p := s.StoragePath(); p != "" { return p } return s.StateDir } // ApplyRunnerSettings laadt de opgeslagen instellingen en zet ze live. // Aan te roepen bij het starten, nadat Runner gezet is. func (s *Server) ApplyRunnerSettings() error { if s.Runner == nil { return nil } if s.Runner.Jobs == nil { s.Runner.Jobs = &runnercfg.Tracker{} } st, err := s.runnerSettingsFile().Load(s.builtinDefaults()) if err != nil { return err } return s.applyBuiltin(st) } func (s *Server) applyBuiltin(st runnercfg.Settings) error { if s.Runner == nil { return nil } over, err := st.Overrides(filepath.Join(s.runnerWorkDir(), "runner"), s.Cfg.CI.ImageOverrides()) if err != nil { return err } s.Runner.Configure(st, over) return nil } // RunnerMaintenance voert elke 10 minuten het opruimbeleid uit. func (s *Server) RunnerMaintenance(ctx context.Context) { t := time.NewTicker(10 * time.Minute) defer t.Stop() for { select { case <-ctx.Done(): return case <-t.C: if s.Runner == nil { continue } st, _ := s.runnerSettingsFile().Load(s.builtinDefaults()) runnercfg.Cleanup(ctx, s.Cfg.CI.Docker, st, s.Runner.Jobs, filepath.Join(s.runnerWorkDir(), "cache")) } } } func (s *Server) builtinStatus() runnercfg.Status { st := runnercfg.Status{Kind: "builtin", ServerURL: s.Cfg.BaseURL, Online: s.Runner != nil, LastContact: time.Now()} if s.Runner != nil { st.Name = s.Runner.BuiltinName() } if s.StateDir != "" { if u, err := update.ReadStatus(s.StateDir); err == nil && u.SHA != "" { st.Version = shortSHA(u.SHA) } } return st } func (s *Server) runnerAdmin() *runnercfg.Handler { return &runnercfg.Handler{ Prefix: "/admin/runner", APIBase: "/api/v1/admin/runner", File: s.runnerSettingsFile(), Default: s.builtinDefaults(), Tracker: s.builtinTracker(), WorkDir: s.runnerWorkDir(), BasePresets: s.Cfg.CI.ImageOverrides(), Apply: s.applyBuiltin, Status: s.builtinStatus, DocsURL: "/help/runners#ingebouwde-runner", Lang: s.langOf, Auth: func(w http.ResponseWriter, r *http.Request, write bool) bool { if strings.HasPrefix(r.URL.Path, "/api/") { if !apiUser(r).InstanceAdmin { writeJSON(w, http.StatusForbidden, map[string]string{"message": "instance admin only"}) return false } } else if ok, _ := s.adminOnly(w, r); !ok { return false } if s.Runner == nil { http.Error(w, s.tr(r, "rui.ciOff"), http.StatusNotFound) return false } return true }, CSRF: func(r *http.Request) (string, string) { return "csrf", s.who(r).Session.CSRF }, CheckCSRF: func(r *http.Request) bool { p := s.who(r) return p.OK && r.FormValue("csrf") != "" && r.FormValue("csrf") == p.Session.CSRF }, Layout: func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML) { v := s.view(w, r, title) v.Page = "adminrunner" v.Wide = true v.RunnerUI = body rs, _ := s.Store.ListRunners(r.Context(), store.RunnerGlobal, 0) v.RunnerList = runnerViews(rs) v.NewRunnerToken = s.takeRunnerOnce(w, r, "/admin") s.render(w, "adminrunner", v) }, } } func (s *Server) builtinTracker() *runnercfg.Tracker { if s.Runner == nil { return &runnercfg.Tracker{} } if s.Runner.Jobs == nil { s.Runner.Jobs = &runnercfg.Tracker{} } return s.Runner.Jobs } func (s *Server) apiAdminRunnerStatus(w http.ResponseWriter, r *http.Request) { s.runnerAdmin().APIStatus(w, r) } func (s *Server) apiAdminRunnerSettings(w http.ResponseWriter, r *http.Request) { s.runnerAdmin().APISettings(w, r) } func (s *Server) apiAdminRunnerJobs(w http.ResponseWriter, r *http.Request) { s.runnerAdmin().APIJobs(w, r) } func (s *Server) apiAdminRunnerPause(w http.ResponseWriter, r *http.Request) { s.runnerAdmin().APIPause(true)(w, r) } func (s *Server) apiAdminRunnerResume(w http.ResponseWriter, r *http.Request) { s.runnerAdmin().APIPause(false)(w, r) } // mountRunnerAdmin hangt de UI-routes op. De API zit in apiCatalog. func (s *Server) mountRunnerAdmin(mux *http.ServeMux) { h := &lazyRunnerAdmin{s: s} for _, p := range []string{"GET /admin/runner", "POST /admin/runner/settings", "POST /admin/runner/recommend", "POST /admin/runner/presets", "POST /admin/runner/presets/delete", "POST /admin/runner/pause", "POST /admin/runner/resume"} { mux.Handle(p, h) } } // lazyRunnerAdmin bouwt de handler per verzoek: s.Runner wordt pas na Handler() gezet. type lazyRunnerAdmin struct{ s *Server } func (l *lazyRunnerAdmin) ServeHTTP(w http.ResponseWriter, r *http.Request) { m := http.NewServeMux() l.s.runnerAdmin().Mount(m, false) m.ServeHTTP(w, r) } // ---- globale runners (beheer) ---- func (s *Server) globalRunnerGuard(w http.ResponseWriter, r *http.Request) bool { if ok, _ := s.adminOnly(w, r); !ok { return false } return s.csrfOK(w, r) } const globalBack = "/admin/runner#global" func (s *Server) globalRunnerToken(w http.ResponseWriter, r *http.Request) { if !s.globalRunnerGuard(w, r) { return } plain, err := s.Store.CreateRunnerRegToken(r.Context(), store.RunnerGlobal, 0, s.who(r).User.ID) if err != nil { s.redirect(w, r, globalBack, "", s.trErr(r, err)) return } s.setRunnerOnce(w, "/admin", plain) s.redirect(w, r, globalBack, s.tr(r, "runner.tokenMade"), "") } func (s *Server) globalRunnerID(r *http.Request) int64 { id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64) return id } func (s *Server) globalRunnerDelete(w http.ResponseWriter, r *http.Request) { if !s.globalRunnerGuard(w, r) { return } if err := s.revokeRunner(r.Context(), store.RunnerGlobal, 0, s.globalRunnerID(r), false); err != nil { s.redirect(w, r, globalBack, "", s.revokeErr(r, err)) return } s.redirect(w, r, globalBack, s.tr(r, "runner.revoked"), "") } func (s *Server) globalRunnerUpdate(w http.ResponseWriter, r *http.Request) { if !s.globalRunnerGuard(w, r) { return } var name *string var paused *bool if n := strings.TrimSpace(r.FormValue("name")); n != "" { name = &n } if p := r.FormValue("paused"); p != "" { b := p == "1" paused = &b } if _, err := s.Store.UpdateRunner(r.Context(), store.RunnerGlobal, 0, s.globalRunnerID(r), name, paused); err != nil { s.redirect(w, r, globalBack, "", s.trErr(r, err)) return } s.redirect(w, r, globalBack, s.tr(r, "flash.saved"), "") }