BlueGit

timfa bluegit

Files

bluegit / internal / runnercfg / handler.go

handler.go

handler.go 10.8 KiB Download Raw
1package runnercfg
2
3import (
4 "bytes"
5 "encoding/json"
6 "errors"
7 "html/template"
8 "net/http"
9 "strconv"
10 "strings"
11 "time"
12
13 "gitlab.com/Timfa/bluegit/internal/i18n"
14 "gitlab.com/Timfa/bluegit/internal/images"
15)
16
17// Status is de kop van het scherm.
18type Status struct {
19 Kind string `json:"kind"` // "standalone" of "builtin"
20 Name string `json:"name"`
21 Version string `json:"version"`
22 ServerURL string `json:"server_url"`
23 Online bool `json:"online"`
24 LastContact time.Time `json:"last_contact,omitempty"`
25 ServerPause bool `json:"server_paused"`
26 Docker DockerStatus `json:"docker"`
27}
28
29// Handler is de gedeelde webinterface en JSON-API voor runnerbeheer.
30// Hij zit onder Prefix (bv. "" op de runner, "/admin/runner" in BlueGit).
31// Auth en CSRF komen van de host.
32type Handler struct {
33 Prefix string
34 File *File
35 Default Settings
36 Tracker *Tracker
37 WorkDir string
38 // BasePresets zijn presets uit de configuratie (alleen-lezen in de UI).
39 BasePresets map[string]images.Override
40 // Apply zet nieuwe instellingen live (na Save).
41 Apply func(Settings) error
42 Status func() Status
43 // Lang, Auth, CSRF en Layout komen van de host.
44 Lang func(r *http.Request) i18n.Lang
45 Auth func(w http.ResponseWriter, r *http.Request, write bool) bool
46 CSRF func(r *http.Request) (field, value string)
47 CheckCSRF func(r *http.Request) bool
48 Layout func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML)
49 DocsURL string
50 APIBase string
51 // ExtraTop levert optionele HTML boven de statuskaarten (alleen standalone).
52 ExtraTop func(*http.Request) template.HTML
53}
54
55// Current leest de opgeslagen instellingen.
56func (h *Handler) Current() Settings {
57 s, err := h.File.Load(h.Default)
58 if err != nil {
59 return h.Default
60 }
61 return s
62}
63
64func (h *Handler) save(s Settings) error {
65 if err := s.Validate(); err != nil {
66 return err
67 }
68 if err := h.File.Save(s); err != nil {
69 return err
70 }
71 if h.Tracker != nil {
72 h.Tracker.SetPaused(s.Paused)
73 }
74 if h.Apply != nil {
75 return h.Apply(s)
76 }
77 return nil
78}
79
80// Mount hangt de routes aan mux.
81func (h *Handler) Mount(mux *http.ServeMux, withAPI bool) {
82 p := h.Prefix
83 page := p
84 if page == "" {
85 page = "/{$}"
86 }
87 mux.HandleFunc("GET "+page, h.page)
88 mux.HandleFunc("POST "+p+"/settings", h.form(h.postSettings))
89 mux.HandleFunc("POST "+p+"/recommend", h.form(h.postRecommend))
90 mux.HandleFunc("POST "+p+"/presets", h.form(h.postPreset))
91 mux.HandleFunc("POST "+p+"/presets/delete", h.form(h.postPresetDelete))
92 mux.HandleFunc("POST "+p+"/pause", h.form(func(r *http.Request, s *Settings) (string, error) { s.Paused = true; return "rui.ok.paused", nil }))
93 mux.HandleFunc("POST "+p+"/resume", h.form(func(r *http.Request, s *Settings) (string, error) { s.Paused = false; return "rui.ok.resumed", nil }))
94 if !withAPI {
95 return
96 }
97 api := h.APIBase
98 if api == "" {
99 api = p + "/api"
100 }
101 mux.HandleFunc("GET "+api+"/status", h.APIStatus)
102 mux.HandleFunc("GET "+api+"/settings", h.APISettings)
103 mux.HandleFunc("PUT "+api+"/settings", h.APISettings)
104 mux.HandleFunc("POST "+api+"/pause", h.APIPause(true))
105 mux.HandleFunc("POST "+api+"/resume", h.APIPause(false))
106 mux.HandleFunc("GET "+api+"/jobs", h.APIJobs)
107}
108
109func (h *Handler) lang(r *http.Request) i18n.Lang {
110 if h.Lang != nil {
111 return h.Lang(r)
112 }
113 return i18n.EN
114}
115
116func (h *Handler) back(w http.ResponseWriter, r *http.Request, ok, problem string) {
117 q := ""
118 if ok != "" {
119 q = "?ok=" + ok
120 } else if problem != "" {
121 q = "?err=" + problem
122 }
123 target := h.Prefix
124 if target == "" {
125 target = "/"
126 }
127 http.Redirect(w, r, target+q, http.StatusSeeOther)
128}
129
130// errKey maakt van een fout een catalogussleutel plus argumenten in de URL.
131func errKey(err error) string {
132 var e Error
133 if errors.As(err, &e) {
134 parts := []string{e.Key}
135 for _, a := range e.Args {
136 parts = append(parts, strings.ReplaceAll(toString(a), "|", "/"))
137 }
138 return template.URLQueryEscaper(strings.Join(parts, "|"))
139 }
140 return "rui.err.save"
141}
142
143func toString(a any) string {
144 switch v := a.(type) {
145 case string:
146 return v
147 default:
148 b, _ := json.Marshal(v)
149 return string(b)
150 }
151}
152
153func (h *Handler) form(fn func(r *http.Request, s *Settings) (string, error)) http.HandlerFunc {
154 return func(w http.ResponseWriter, r *http.Request) {
155 if !h.Auth(w, r, true) {
156 return
157 }
158 if h.CheckCSRF != nil && !h.CheckCSRF(r) {
159 http.Error(w, "csrf", http.StatusForbidden)
160 return
161 }
162 _ = r.ParseForm()
163 s := h.Current()
164 ok, err := fn(r, &s)
165 if err == nil {
166 err = h.save(s)
167 }
168 if err != nil {
169 h.back(w, r, "", errKey(err))
170 return
171 }
172 h.back(w, r, ok, "")
173 }
174}
175
176func atoi(r *http.Request, k string, def int) int {
177 v := strings.TrimSpace(r.FormValue(k))
178 if v == "" {
179 return def
180 }
181 n, err := strconv.Atoi(v)
182 if err != nil {
183 return -1
184 }
185 return n
186}
187
188func (h *Handler) postSettings(r *http.Request, s *Settings) (string, error) {
189 s.Name = r.FormValue("name")
190 s.Concurrency = atoi(r, "concurrency", 1)
191 s.MaxImages = atoi(r, "max_images", 20)
192 cpus := strings.TrimSpace(strings.ReplaceAll(r.FormValue("cpus"), ",", "."))
193 if cpus == "" {
194 s.CPUs = 0
195 } else if f, err := strconv.ParseFloat(cpus, 64); err == nil {
196 s.CPUs = f
197 } else {
198 s.CPUs = -1
199 }
200 s.MemoryMB = atoi(r, "memory_mb", 0)
201 s.PidsLimit = atoi(r, "pids_limit", 0)
202 s.MaxDiskGB = atoi(r, "max_disk_gb", 0)
203 s.PruneCacheGB = atoi(r, "prune_cache_gb", 0)
204 s.JobTimeoutMin = atoi(r, "job_timeout_min", 0)
205 s.PullPolicy = r.FormValue("pull_policy")
206 s.CleanupWork = r.FormValue("cleanup_work") != ""
207 s.PruneDangling = r.FormValue("prune_dangling") != ""
208 s.Labels = strings.FieldsFunc(r.FormValue("labels"), func(c rune) bool { return c == ',' || c == ' ' || c == '\n' })
209 return "rui.ok.saved", nil
210}
211
212func (h *Handler) postRecommend(r *http.Request, s *Settings) (string, error) {
213 rec := Recommend(Detect(h.WorkDir))
214 s.Concurrency, s.MaxImages, s.CPUs, s.MemoryMB, s.PidsLimit = rec.Concurrency, rec.MaxImages, rec.CPUs, rec.MemoryMB, rec.PidsLimit
215 s.MaxDiskGB, s.PruneCacheGB = rec.MaxDiskGB, rec.PruneCacheGB
216 return "rui.ok.recommended", nil
217}
218
219func (h *Handler) postPreset(r *http.Request, s *Settings) (string, error) {
220 p := Preset{Name: r.FormValue("name"), Image: r.FormValue("image"), From: r.FormValue("from"), Dockerfile: r.FormValue("dockerfile"), Note: strings.TrimSpace(r.FormValue("note"))}
221 if err := p.Validate(); err != nil {
222 return "", err
223 }
224 replaced := false
225 for i := range s.Presets {
226 if s.Presets[i].Name == p.Name {
227 s.Presets[i], replaced = p, true
228 }
229 }
230 if !replaced {
231 s.Presets = append(s.Presets, p)
232 }
233 return "rui.ok.preset", nil
234}
235
236func (h *Handler) postPresetDelete(r *http.Request, s *Settings) (string, error) {
237 name := r.FormValue("name")
238 out := s.Presets[:0]
239 for _, p := range s.Presets {
240 if p.Name != name {
241 out = append(out, p)
242 }
243 }
244 s.Presets = out
245 return "rui.ok.presetDeleted", nil
246}
247
248// View is alles wat het fragment toont.
249type View struct {
250 Lang i18n.Lang
251 Prefix string
252 CSRFField string
253 CSRF string
254 Status Status
255 S Settings
256 Rec Settings
257 HW Hardware
258 WorkGB int
259 Builtin []images.Preset
260 Config []string
261 Active []JobInfo
262 Recent []JobInfo
263 Safe bool
264 Notice string
265 Problem string
266 DocsURL string
267 APIBase string
268 ExtraTop template.HTML
269}
270
271func (h *Handler) view(r *http.Request) View {
272 lang := h.lang(r)
273 v := View{Lang: lang, Prefix: h.Prefix, S: h.Current(), DocsURL: h.DocsURL}
274 if h.ExtraTop != nil {
275 v.ExtraTop = h.ExtraTop(r)
276 }
277 v.APIBase = h.APIBase
278 if v.APIBase == "" {
279 v.APIBase = h.Prefix + "/api"
280 }
281 if h.CSRF != nil {
282 v.CSRFField, v.CSRF = h.CSRF(r)
283 }
284 if h.Status != nil {
285 v.Status = h.Status()
286 }
287 v.HW = Detect(h.WorkDir)
288 v.Rec = Recommend(v.HW)
289 v.Builtin = images.Builtin()
290 for k := range h.BasePresets {
291 v.Config = append(v.Config, k)
292 }
293 if h.Tracker != nil {
294 v.Active, v.Recent, v.Safe = h.Tracker.Active(), h.Tracker.Recent(), h.Tracker.SafeToUpgrade()
295 }
296 if k := r.URL.Query().Get("ok"); strings.HasPrefix(k, "rui.ok.") {
297 v.Notice = i18n.T(lang, k)
298 }
299 if k := r.URL.Query().Get("err"); strings.HasPrefix(k, "rui.err.") {
300 parts := strings.Split(k, "|")
301 args := make([]any, 0, len(parts)-1)
302 for _, a := range parts[1:] {
303 args = append(args, a)
304 }
305 v.Problem = i18n.T(lang, parts[0], args...)
306 }
307 return v
308}
309
310func (h *Handler) page(w http.ResponseWriter, r *http.Request) {
311 if !h.Auth(w, r, false) {
312 return
313 }
314 v := h.view(r)
315 h.Layout(w, r, v.Lang, i18n.T(v.Lang, "rui.title"), Render(v))
316}
317
318// Render maakt het HTML-fragment.
319func Render(v View) template.HTML {
320 var b bytes.Buffer
321 if err := uiTmpl(v.Lang).ExecuteTemplate(&b, "runnerui", v); err != nil {
322 return template.HTML(template.HTMLEscapeString(err.Error()))
323 }
324 return template.HTML(b.String())
325}
326
327func (h *Handler) APIStatus(w http.ResponseWriter, r *http.Request) {
328 if !h.Auth(w, r, false) {
329 return
330 }
331 st := Status{}
332 if h.Status != nil {
333 st = h.Status()
334 }
335 s := h.Current()
336 hw := Detect(h.WorkDir)
337 writeJSON(w, http.StatusOK, map[string]any{
338 "status": st, "paused": s.Paused, "active_jobs": len(h.Tracker.Active()),
339 "safe_to_upgrade": h.Tracker.SafeToUpgrade(), "hardware": hw, "recommended": Recommend(hw),
340 })
341}
342
343func (h *Handler) APIJobs(w http.ResponseWriter, r *http.Request) {
344 if !h.Auth(w, r, false) {
345 return
346 }
347 writeJSON(w, http.StatusOK, map[string]any{"active": nonNil(h.Tracker.Active()), "recent": nonNil(h.Tracker.Recent()), "safe_to_upgrade": h.Tracker.SafeToUpgrade()})
348}
349
350func nonNil(j []JobInfo) []JobInfo {
351 if j == nil {
352 return []JobInfo{}
353 }
354 return j
355}
356
357func (h *Handler) APISettings(w http.ResponseWriter, r *http.Request) {
358 if !h.Auth(w, r, r.Method != http.MethodGet) {
359 return
360 }
361 if r.Method == http.MethodPut {
362 s := h.Current()
363 dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20))
364 if err := dec.Decode(&s); err != nil {
365 writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON"})
366 return
367 }
368 if err := h.save(s); err != nil {
369 msg := err.Error()
370 var e Error
371 if errors.As(err, &e) {
372 msg = i18n.T(i18n.EN, e.Key, e.Args...)
373 }
374 writeJSON(w, http.StatusUnprocessableEntity, map[string]string{"error": msg})
375 return
376 }
377 }
378 writeJSON(w, http.StatusOK, h.Current())
379}
380
381func (h *Handler) APIPause(on bool) http.HandlerFunc {
382 return func(w http.ResponseWriter, r *http.Request) {
383 if !h.Auth(w, r, true) {
384 return
385 }
386 s := h.Current()
387 s.Paused = on
388 if err := h.save(s); err != nil {
389 writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
390 return
391 }
392 writeJSON(w, http.StatusOK, map[string]any{"paused": on, "active_jobs": len(h.Tracker.Active()), "safe_to_upgrade": h.Tracker.SafeToUpgrade()})
393 }
394}
395
396func writeJSON(w http.ResponseWriter, code int, v any) {
397 w.Header().Set("Content-Type", "application/json; charset=utf-8")
398 w.Header().Set("Cache-Control", "no-store")
399 w.WriteHeader(code)
400 _ = json.NewEncoder(w).Encode(v)
401}