package runnercfg import ( "bytes" "encoding/json" "errors" "html/template" "net/http" "strconv" "strings" "time" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/images" ) // Status is de kop van het scherm. type Status struct { Kind string `json:"kind"` // "standalone" of "builtin" Name string `json:"name"` Version string `json:"version"` ServerURL string `json:"server_url"` Online bool `json:"online"` LastContact time.Time `json:"last_contact,omitempty"` ServerPause bool `json:"server_paused"` Docker DockerStatus `json:"docker"` } // Handler is de gedeelde webinterface en JSON-API voor runnerbeheer. // Hij zit onder Prefix (bv. "" op de runner, "/admin/runner" in BlueGit). // Auth en CSRF komen van de host. type Handler struct { Prefix string File *File Default Settings Tracker *Tracker WorkDir string // BasePresets zijn presets uit de configuratie (alleen-lezen in de UI). BasePresets map[string]images.Override // Apply zet nieuwe instellingen live (na Save). Apply func(Settings) error Status func() Status // Lang, Auth, CSRF en Layout komen van de host. Lang func(r *http.Request) i18n.Lang Auth func(w http.ResponseWriter, r *http.Request, write bool) bool CSRF func(r *http.Request) (field, value string) CheckCSRF func(r *http.Request) bool Layout func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML) DocsURL string APIBase string } // Current leest de opgeslagen instellingen. func (h *Handler) Current() Settings { s, err := h.File.Load(h.Default) if err != nil { return h.Default } return s } func (h *Handler) save(s Settings) error { if err := s.Validate(); err != nil { return err } if err := h.File.Save(s); err != nil { return err } if h.Tracker != nil { h.Tracker.SetPaused(s.Paused) } if h.Apply != nil { return h.Apply(s) } return nil } // Mount hangt de routes aan mux. func (h *Handler) Mount(mux *http.ServeMux, withAPI bool) { p := h.Prefix page := p if page == "" { page = "/{$}" } mux.HandleFunc("GET "+page, h.page) mux.HandleFunc("POST "+p+"/settings", h.form(h.postSettings)) mux.HandleFunc("POST "+p+"/recommend", h.form(h.postRecommend)) mux.HandleFunc("POST "+p+"/presets", h.form(h.postPreset)) mux.HandleFunc("POST "+p+"/presets/delete", h.form(h.postPresetDelete)) mux.HandleFunc("POST "+p+"/pause", h.form(func(r *http.Request, s *Settings) (string, error) { s.Paused = true; return "rui.ok.paused", nil })) mux.HandleFunc("POST "+p+"/resume", h.form(func(r *http.Request, s *Settings) (string, error) { s.Paused = false; return "rui.ok.resumed", nil })) if !withAPI { return } api := h.APIBase if api == "" { api = p + "/api" } mux.HandleFunc("GET "+api+"/status", h.APIStatus) mux.HandleFunc("GET "+api+"/settings", h.APISettings) mux.HandleFunc("PUT "+api+"/settings", h.APISettings) mux.HandleFunc("POST "+api+"/pause", h.APIPause(true)) mux.HandleFunc("POST "+api+"/resume", h.APIPause(false)) mux.HandleFunc("GET "+api+"/jobs", h.APIJobs) } func (h *Handler) lang(r *http.Request) i18n.Lang { if h.Lang != nil { return h.Lang(r) } return i18n.EN } func (h *Handler) back(w http.ResponseWriter, r *http.Request, ok, problem string) { q := "" if ok != "" { q = "?ok=" + ok } else if problem != "" { q = "?err=" + problem } target := h.Prefix if target == "" { target = "/" } http.Redirect(w, r, target+q, http.StatusSeeOther) } // errKey maakt van een fout een catalogussleutel plus argumenten in de URL. func errKey(err error) string { var e Error if errors.As(err, &e) { parts := []string{e.Key} for _, a := range e.Args { parts = append(parts, strings.ReplaceAll(toString(a), "|", "/")) } return template.URLQueryEscaper(strings.Join(parts, "|")) } return "rui.err.save" } func toString(a any) string { switch v := a.(type) { case string: return v default: b, _ := json.Marshal(v) return string(b) } } func (h *Handler) form(fn func(r *http.Request, s *Settings) (string, error)) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if !h.Auth(w, r, true) { return } if h.CheckCSRF != nil && !h.CheckCSRF(r) { http.Error(w, "csrf", http.StatusForbidden) return } _ = r.ParseForm() s := h.Current() ok, err := fn(r, &s) if err == nil { err = h.save(s) } if err != nil { h.back(w, r, "", errKey(err)) return } h.back(w, r, ok, "") } } func atoi(r *http.Request, k string, def int) int { v := strings.TrimSpace(r.FormValue(k)) if v == "" { return def } n, err := strconv.Atoi(v) if err != nil { return -1 } return n } func (h *Handler) postSettings(r *http.Request, s *Settings) (string, error) { s.Name = r.FormValue("name") s.Concurrency = atoi(r, "concurrency", 1) s.MaxImages = atoi(r, "max_images", 20) cpus := strings.TrimSpace(strings.ReplaceAll(r.FormValue("cpus"), ",", ".")) if cpus == "" { s.CPUs = 0 } else if f, err := strconv.ParseFloat(cpus, 64); err == nil { s.CPUs = f } else { s.CPUs = -1 } s.MemoryMB = atoi(r, "memory_mb", 0) s.PidsLimit = atoi(r, "pids_limit", 0) s.MaxDiskGB = atoi(r, "max_disk_gb", 0) s.PruneCacheGB = atoi(r, "prune_cache_gb", 0) s.JobTimeoutMin = atoi(r, "job_timeout_min", 0) s.PullPolicy = r.FormValue("pull_policy") s.CleanupWork = r.FormValue("cleanup_work") != "" s.PruneDangling = r.FormValue("prune_dangling") != "" s.Labels = strings.FieldsFunc(r.FormValue("labels"), func(c rune) bool { return c == ',' || c == ' ' || c == '\n' }) return "rui.ok.saved", nil } func (h *Handler) postRecommend(r *http.Request, s *Settings) (string, error) { rec := Recommend(Detect(h.WorkDir)) s.Concurrency, s.MaxImages, s.CPUs, s.MemoryMB, s.PidsLimit = rec.Concurrency, rec.MaxImages, rec.CPUs, rec.MemoryMB, rec.PidsLimit s.MaxDiskGB, s.PruneCacheGB = rec.MaxDiskGB, rec.PruneCacheGB return "rui.ok.recommended", nil } func (h *Handler) postPreset(r *http.Request, s *Settings) (string, error) { p := Preset{Name: r.FormValue("name"), Image: r.FormValue("image"), From: r.FormValue("from"), Dockerfile: r.FormValue("dockerfile"), Note: strings.TrimSpace(r.FormValue("note"))} if err := p.Validate(); err != nil { return "", err } replaced := false for i := range s.Presets { if s.Presets[i].Name == p.Name { s.Presets[i], replaced = p, true } } if !replaced { s.Presets = append(s.Presets, p) } return "rui.ok.preset", nil } func (h *Handler) postPresetDelete(r *http.Request, s *Settings) (string, error) { name := r.FormValue("name") out := s.Presets[:0] for _, p := range s.Presets { if p.Name != name { out = append(out, p) } } s.Presets = out return "rui.ok.presetDeleted", nil } // View is alles wat het fragment toont. type View struct { Lang i18n.Lang Prefix string CSRFField string CSRF string Status Status S Settings Rec Settings HW Hardware WorkGB int Builtin []images.Preset Config []string Active []JobInfo Recent []JobInfo Safe bool Notice string Problem string DocsURL string APIBase string } func (h *Handler) view(r *http.Request) View { lang := h.lang(r) v := View{Lang: lang, Prefix: h.Prefix, S: h.Current(), DocsURL: h.DocsURL} v.APIBase = h.APIBase if v.APIBase == "" { v.APIBase = h.Prefix + "/api" } if h.CSRF != nil { v.CSRFField, v.CSRF = h.CSRF(r) } if h.Status != nil { v.Status = h.Status() } v.HW = Detect(h.WorkDir) v.Rec = Recommend(v.HW) v.Builtin = images.Builtin() for k := range h.BasePresets { v.Config = append(v.Config, k) } if h.Tracker != nil { v.Active, v.Recent, v.Safe = h.Tracker.Active(), h.Tracker.Recent(), h.Tracker.SafeToUpgrade() } if k := r.URL.Query().Get("ok"); strings.HasPrefix(k, "rui.ok.") { v.Notice = i18n.T(lang, k) } if k := r.URL.Query().Get("err"); strings.HasPrefix(k, "rui.err.") { parts := strings.Split(k, "|") args := make([]any, 0, len(parts)-1) for _, a := range parts[1:] { args = append(args, a) } v.Problem = i18n.T(lang, parts[0], args...) } return v } func (h *Handler) page(w http.ResponseWriter, r *http.Request) { if !h.Auth(w, r, false) { return } v := h.view(r) h.Layout(w, r, v.Lang, i18n.T(v.Lang, "rui.title"), Render(v)) } // Render maakt het HTML-fragment. func Render(v View) template.HTML { var b bytes.Buffer if err := uiTmpl(v.Lang).ExecuteTemplate(&b, "runnerui", v); err != nil { return template.HTML(template.HTMLEscapeString(err.Error())) } return template.HTML(b.String()) } func (h *Handler) APIStatus(w http.ResponseWriter, r *http.Request) { if !h.Auth(w, r, false) { return } st := Status{} if h.Status != nil { st = h.Status() } s := h.Current() hw := Detect(h.WorkDir) writeJSON(w, http.StatusOK, map[string]any{ "status": st, "paused": s.Paused, "active_jobs": len(h.Tracker.Active()), "safe_to_upgrade": h.Tracker.SafeToUpgrade(), "hardware": hw, "recommended": Recommend(hw), }) } func (h *Handler) APIJobs(w http.ResponseWriter, r *http.Request) { if !h.Auth(w, r, false) { return } writeJSON(w, http.StatusOK, map[string]any{"active": nonNil(h.Tracker.Active()), "recent": nonNil(h.Tracker.Recent()), "safe_to_upgrade": h.Tracker.SafeToUpgrade()}) } func nonNil(j []JobInfo) []JobInfo { if j == nil { return []JobInfo{} } return j } func (h *Handler) APISettings(w http.ResponseWriter, r *http.Request) { if !h.Auth(w, r, r.Method != http.MethodGet) { return } if r.Method == http.MethodPut { s := h.Current() dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)) if err := dec.Decode(&s); err != nil { writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON"}) return } if err := h.save(s); err != nil { msg := err.Error() var e Error if errors.As(err, &e) { msg = i18n.T(i18n.EN, e.Key, e.Args...) } writeJSON(w, http.StatusUnprocessableEntity, map[string]string{"error": msg}) return } } writeJSON(w, http.StatusOK, h.Current()) } func (h *Handler) APIPause(on bool) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if !h.Auth(w, r, true) { return } s := h.Current() s.Paused = on if err := h.save(s); err != nil { writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()}) return } writeJSON(w, http.StatusOK, map[string]any{"paused": on, "active_jobs": len(h.Tracker.Active()), "safe_to_upgrade": h.Tracker.SafeToUpgrade()}) } } func writeJSON(w http.ResponseWriter, code int, v any) { w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Cache-Control", "no-store") w.WriteHeader(code) _ = json.NewEncoder(w).Encode(v) }