BlueGit

timfa bluegit

Files

bluegit / internal / runnercfg / handler.go

handler.go

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