package server
import (
"context"
"html/template"
"net/http"
"path/filepath"
"strings"
"time"
"gitlab.com/Timfa/bluegit/internal/i18n"
"gitlab.com/Timfa/bluegit/internal/runnercfg"
"gitlab.com/Timfa/bluegit/internal/update"
)
// Beheer van de ingebouwde runner (Steve) door de sitebeheerder: dezelfde
// instellingen en hetzelfde scherm als de webinterface van bluegit-runner.
// UI op /admin/runner, API op /api/v1/admin/runner/... (beheerder-token).
// Pauze is een drain: lopende jobs lopen af, nieuwe blijven queued (of
// gaan naar een andere runner). De self-update wacht alleen op running
// jobs, dus een gepauzeerde runner houdt een update niet tegen.
func (s *Server) runnerSettingsFile() *runnercfg.File {
dir := s.StateDir
if dir == "" {
dir = s.StoragePath()
}
return &runnercfg.File{Path: filepath.Join(dir, "runner-settings.json")}
}
func (s *Server) builtinDefaults() runnercfg.Settings {
d := runnercfg.Defaults()
if s.Cfg.CI.Concurrency > 0 {
d.Concurrency = s.Cfg.CI.Concurrency
}
return d
}
func (s *Server) runnerWorkDir() string {
if p := s.StoragePath(); p != "" {
return p
}
return s.StateDir
}
// ApplyRunnerSettings laadt de opgeslagen instellingen en zet ze live.
// Aan te roepen bij het starten, nadat Runner gezet is.
func (s *Server) ApplyRunnerSettings() error {
if s.Runner == nil {
return nil
}
if s.Runner.Jobs == nil {
s.Runner.Jobs = &runnercfg.Tracker{}
}
st, err := s.runnerSettingsFile().Load(s.builtinDefaults())
if err != nil {
return err
}
return s.applyBuiltin(st)
}
func (s *Server) applyBuiltin(st runnercfg.Settings) error {
if s.Runner == nil {
return nil
}
over, err := st.Overrides(filepath.Join(s.runnerWorkDir(), "runner"), s.Cfg.CI.ImageOverrides())
if err != nil {
return err
}
s.Runner.Configure(st, over)
return nil
}
// RunnerMaintenance voert elke 10 minuten het opruimbeleid uit.
func (s *Server) RunnerMaintenance(ctx context.Context) {
t := time.NewTicker(10 * time.Minute)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
if s.Runner == nil {
continue
}
st, _ := s.runnerSettingsFile().Load(s.builtinDefaults())
runnercfg.Cleanup(ctx, s.Cfg.CI.Docker, st, s.Runner.Jobs, filepath.Join(s.runnerWorkDir(), "cache"))
}
}
}
func (s *Server) builtinStatus() runnercfg.Status {
st := runnercfg.Status{Kind: "builtin", ServerURL: s.Cfg.BaseURL, Online: s.Runner != nil, LastContact: time.Now()}
if s.Runner != nil {
st.Name = s.Runner.BuiltinName()
}
if s.StateDir != "" {
if u, err := update.ReadStatus(s.StateDir); err == nil && u.SHA != "" {
st.Version = shortSHA(u.SHA)
}
}
return st
}
func (s *Server) runnerAdmin() *runnercfg.Handler {
return &runnercfg.Handler{
Prefix: "/admin/runner",
APIBase: "/api/v1/admin/runner",
File: s.runnerSettingsFile(),
Default: s.builtinDefaults(),
Tracker: s.builtinTracker(),
WorkDir: s.runnerWorkDir(),
BasePresets: s.Cfg.CI.ImageOverrides(),
Apply: s.applyBuiltin,
Status: s.builtinStatus,
DocsURL: "/help/runners#ingebouwde-runner",
Lang: s.langOf,
Auth: func(w http.ResponseWriter, r *http.Request, write bool) bool {
if strings.HasPrefix(r.URL.Path, "/api/") {
if !apiUser(r).InstanceAdmin {
writeJSON(w, http.StatusForbidden, map[string]string{"message": "instance admin only"})
return false
}
} else if ok, _ := s.adminOnly(w, r); !ok {
return false
}
if s.Runner == nil {
http.Error(w, s.tr(r, "rui.ciOff"), http.StatusNotFound)
return false
}
return true
},
CSRF: func(r *http.Request) (string, string) { return "csrf", s.who(r).Session.CSRF },
CheckCSRF: func(r *http.Request) bool {
p := s.who(r)
return p.OK && r.FormValue("csrf") != "" && r.FormValue("csrf") == p.Session.CSRF
},
Layout: func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML) {
v := s.view(w, r, title)
v.Page = "adminrunner"
v.Wide = true
v.RunnerUI = body
s.render(w, "adminrunner", v)
},
}
}
func (s *Server) builtinTracker() *runnercfg.Tracker {
if s.Runner == nil {
return &runnercfg.Tracker{}
}
if s.Runner.Jobs == nil {
s.Runner.Jobs = &runnercfg.Tracker{}
}
return s.Runner.Jobs
}
func (s *Server) apiAdminRunnerStatus(w http.ResponseWriter, r *http.Request) {
s.runnerAdmin().APIStatus(w, r)
}
func (s *Server) apiAdminRunnerSettings(w http.ResponseWriter, r *http.Request) {
s.runnerAdmin().APISettings(w, r)
}
func (s *Server) apiAdminRunnerJobs(w http.ResponseWriter, r *http.Request) {
s.runnerAdmin().APIJobs(w, r)
}
func (s *Server) apiAdminRunnerPause(w http.ResponseWriter, r *http.Request) {
s.runnerAdmin().APIPause(true)(w, r)
}
func (s *Server) apiAdminRunnerResume(w http.ResponseWriter, r *http.Request) {
s.runnerAdmin().APIPause(false)(w, r)
}
// mountRunnerAdmin hangt de UI-routes op. De API zit in apiCatalog.
func (s *Server) mountRunnerAdmin(mux *http.ServeMux) {
h := &lazyRunnerAdmin{s: s}
for _, p := range []string{"GET /admin/runner", "POST /admin/runner/settings", "POST /admin/runner/recommend", "POST /admin/runner/presets", "POST /admin/runner/presets/delete", "POST /admin/runner/pause", "POST /admin/runner/resume"} {
mux.Handle(p, h)
}
}
// lazyRunnerAdmin bouwt de handler per verzoek: s.Runner wordt pas na Handler() gezet.
type lazyRunnerAdmin struct{ s *Server }
func (l *lazyRunnerAdmin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
m := http.NewServeMux()
l.s.runnerAdmin().Mount(m, false)
m.ServeHTTP(w, r)
}