BlueGit

timfa bluegit

Files

bluegit / internal / runnercfg / handler.go

handler.go

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