| 1 | package runnercfg |
| 2 | |
| 3 | import ( |
| 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. |
| 18 | type 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. |
| 31 | type 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. |
| 53 | func (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 | |
| 61 | func (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. |
| 78 | func (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 | |
| 106 | func (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 | |
| 113 | func (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. |
| 128 | func 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 | |
| 140 | func 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 | |
| 150 | func (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 | |
| 173 | func 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 | |
| 185 | func (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 | |
| 209 | func (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 | |
| 216 | func (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 | |
| 233 | func (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. |
| 246 | type 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 | |
| 267 | func (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 | |
| 303 | func (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. |
| 312 | func 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 | |
| 320 | func (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 | |
| 336 | func (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 | |
| 343 | func nonNil(j []JobInfo) []JobInfo { |
| 344 | if j == nil { |
| 345 | return []JobInfo{} |
| 346 | } |
| 347 | return j |
| 348 | } |
| 349 | |
| 350 | func (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 | |
| 374 | func (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 | |
| 389 | func 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 | } |