BlueGit

timfa bluegit

Files

bluegit / internal / server / admin_runner.go

admin_runner.go

admin_runner.go 5.5 KiB Download Raw
1package server
2
3import (
4 "context"
5 "html/template"
6 "net/http"
7 "path/filepath"
8 "strings"
9 "time"
10
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/runnercfg"
13 "gitlab.com/Timfa/bluegit/internal/update"
14)
15
16// Beheer van de ingebouwde runner (Steve) door de sitebeheerder: dezelfde
17// instellingen en hetzelfde scherm als de webinterface van bluegit-runner.
18// UI op /admin/runner, API op /api/v1/admin/runner/... (beheerder-token).
19// Pauze is een drain: lopende jobs lopen af, nieuwe blijven queued (of
20// gaan naar een andere runner). De self-update wacht alleen op running
21// jobs, dus een gepauzeerde runner houdt een update niet tegen.
22
23func (s *Server) runnerSettingsFile() *runnercfg.File {
24 dir := s.StateDir
25 if dir == "" {
26 dir = s.StoragePath()
27 }
28 return &runnercfg.File{Path: filepath.Join(dir, "runner-settings.json")}
29}
30
31func (s *Server) builtinDefaults() runnercfg.Settings {
32 d := runnercfg.Defaults()
33 if s.Cfg.CI.Concurrency > 0 {
34 d.Concurrency = s.Cfg.CI.Concurrency
35 }
36 return d
37}
38
39func (s *Server) runnerWorkDir() string {
40 if p := s.StoragePath(); p != "" {
41 return p
42 }
43 return s.StateDir
44}
45
46// ApplyRunnerSettings laadt de opgeslagen instellingen en zet ze live.
47// Aan te roepen bij het starten, nadat Runner gezet is.
48func (s *Server) ApplyRunnerSettings() error {
49 if s.Runner == nil {
50 return nil
51 }
52 if s.Runner.Jobs == nil {
53 s.Runner.Jobs = &runnercfg.Tracker{}
54 }
55 st, err := s.runnerSettingsFile().Load(s.builtinDefaults())
56 if err != nil {
57 return err
58 }
59 return s.applyBuiltin(st)
60}
61
62func (s *Server) applyBuiltin(st runnercfg.Settings) error {
63 if s.Runner == nil {
64 return nil
65 }
66 over, err := st.Overrides(filepath.Join(s.runnerWorkDir(), "runner"), s.Cfg.CI.ImageOverrides())
67 if err != nil {
68 return err
69 }
70 s.Runner.Configure(st, over)
71 return nil
72}
73
74// RunnerMaintenance voert elke 10 minuten het opruimbeleid uit.
75func (s *Server) RunnerMaintenance(ctx context.Context) {
76 t := time.NewTicker(10 * time.Minute)
77 defer t.Stop()
78 for {
79 select {
80 case <-ctx.Done():
81 return
82 case <-t.C:
83 if s.Runner == nil {
84 continue
85 }
86 st, _ := s.runnerSettingsFile().Load(s.builtinDefaults())
87 runnercfg.Cleanup(ctx, s.Cfg.CI.Docker, st, s.Runner.Jobs, filepath.Join(s.runnerWorkDir(), "cache"))
88 }
89 }
90}
91
92func (s *Server) builtinStatus() runnercfg.Status {
93 st := runnercfg.Status{Kind: "builtin", ServerURL: s.Cfg.BaseURL, Online: s.Runner != nil, LastContact: time.Now()}
94 if s.Runner != nil {
95 st.Name = s.Runner.BuiltinName()
96 }
97 if s.StateDir != "" {
98 if u, err := update.ReadStatus(s.StateDir); err == nil && u.SHA != "" {
99 st.Version = shortSHA(u.SHA)
100 }
101 }
102 return st
103}
104
105func (s *Server) runnerAdmin() *runnercfg.Handler {
106 return &runnercfg.Handler{
107 Prefix: "/admin/runner",
108 APIBase: "/api/v1/admin/runner",
109 File: s.runnerSettingsFile(),
110 Default: s.builtinDefaults(),
111 Tracker: s.builtinTracker(),
112 WorkDir: s.runnerWorkDir(),
113 BasePresets: s.Cfg.CI.ImageOverrides(),
114 Apply: s.applyBuiltin,
115 Status: s.builtinStatus,
116 DocsURL: "/help/runners#ingebouwde-runner",
117 Lang: s.langOf,
118 Auth: func(w http.ResponseWriter, r *http.Request, write bool) bool {
119 if strings.HasPrefix(r.URL.Path, "/api/") {
120 if !apiUser(r).InstanceAdmin {
121 writeJSON(w, http.StatusForbidden, map[string]string{"message": "instance admin only"})
122 return false
123 }
124 } else if ok, _ := s.adminOnly(w, r); !ok {
125 return false
126 }
127 if s.Runner == nil {
128 http.Error(w, s.tr(r, "rui.ciOff"), http.StatusNotFound)
129 return false
130 }
131 return true
132 },
133 CSRF: func(r *http.Request) (string, string) { return "csrf", s.who(r).Session.CSRF },
134 CheckCSRF: func(r *http.Request) bool {
135 p := s.who(r)
136 return p.OK && r.FormValue("csrf") != "" && r.FormValue("csrf") == p.Session.CSRF
137 },
138 Layout: func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML) {
139 v := s.view(w, r, title)
140 v.Page = "adminrunner"
141 v.Wide = true
142 v.RunnerUI = body
143 s.render(w, "adminrunner", v)
144 },
145 }
146}
147
148func (s *Server) builtinTracker() *runnercfg.Tracker {
149 if s.Runner == nil {
150 return &runnercfg.Tracker{}
151 }
152 if s.Runner.Jobs == nil {
153 s.Runner.Jobs = &runnercfg.Tracker{}
154 }
155 return s.Runner.Jobs
156}
157
158func (s *Server) apiAdminRunnerStatus(w http.ResponseWriter, r *http.Request) {
159 s.runnerAdmin().APIStatus(w, r)
160}
161func (s *Server) apiAdminRunnerSettings(w http.ResponseWriter, r *http.Request) {
162 s.runnerAdmin().APISettings(w, r)
163}
164func (s *Server) apiAdminRunnerJobs(w http.ResponseWriter, r *http.Request) {
165 s.runnerAdmin().APIJobs(w, r)
166}
167func (s *Server) apiAdminRunnerPause(w http.ResponseWriter, r *http.Request) {
168 s.runnerAdmin().APIPause(true)(w, r)
169}
170func (s *Server) apiAdminRunnerResume(w http.ResponseWriter, r *http.Request) {
171 s.runnerAdmin().APIPause(false)(w, r)
172}
173
174// mountRunnerAdmin hangt de UI-routes op. De API zit in apiCatalog.
175func (s *Server) mountRunnerAdmin(mux *http.ServeMux) {
176 h := &lazyRunnerAdmin{s: s}
177 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"} {
178 mux.Handle(p, h)
179 }
180}
181
182// lazyRunnerAdmin bouwt de handler per verzoek: s.Runner wordt pas na Handler() gezet.
183type lazyRunnerAdmin struct{ s *Server }
184
185func (l *lazyRunnerAdmin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
186 m := http.NewServeMux()
187 l.s.runnerAdmin().Mount(m, false)
188 m.ServeHTTP(w, r)
189}