| 1 | package server |
| 2 | |
| 3 | import ( |
| 4 | "context" |
| 5 | "gitlab.com/Timfa/bluegit/internal/store" |
| 6 | "html/template" |
| 7 | "net/http" |
| 8 | "path/filepath" |
| 9 | "strconv" |
| 10 | "strings" |
| 11 | "time" |
| 12 | |
| 13 | "gitlab.com/Timfa/bluegit/internal/i18n" |
| 14 | "gitlab.com/Timfa/bluegit/internal/runnercfg" |
| 15 | "gitlab.com/Timfa/bluegit/internal/update" |
| 16 | ) |
| 17 | |
| 18 | // Beheer van de ingebouwde runner (Steve) door de sitebeheerder: dezelfde |
| 19 | // instellingen en hetzelfde scherm als de webinterface van bluegit-runner. |
| 20 | // UI op /admin/runner, API op /api/v1/admin/runner/... (beheerder-token). |
| 21 | // Pauze is een drain: lopende jobs lopen af, nieuwe blijven queued (of |
| 22 | // gaan naar een andere runner). De self-update wacht alleen op running |
| 23 | // jobs, dus een gepauzeerde runner houdt een update niet tegen. |
| 24 | |
| 25 | func (s *Server) runnerSettingsFile() *runnercfg.File { |
| 26 | dir := s.StateDir |
| 27 | if dir == "" { |
| 28 | dir = s.StoragePath() |
| 29 | } |
| 30 | return &runnercfg.File{Path: filepath.Join(dir, "runner-settings.json")} |
| 31 | } |
| 32 | |
| 33 | func (s *Server) builtinDefaults() runnercfg.Settings { |
| 34 | d := runnercfg.Defaults() |
| 35 | if s.Cfg.CI.Concurrency > 0 { |
| 36 | d.Concurrency = s.Cfg.CI.Concurrency |
| 37 | } |
| 38 | return d |
| 39 | } |
| 40 | |
| 41 | func (s *Server) runnerWorkDir() string { |
| 42 | if p := s.StoragePath(); p != "" { |
| 43 | return p |
| 44 | } |
| 45 | return s.StateDir |
| 46 | } |
| 47 | |
| 48 | // ApplyRunnerSettings laadt de opgeslagen instellingen en zet ze live. |
| 49 | // Aan te roepen bij het starten, nadat Runner gezet is. |
| 50 | func (s *Server) ApplyRunnerSettings() error { |
| 51 | if s.Runner == nil { |
| 52 | return nil |
| 53 | } |
| 54 | if s.Runner.Jobs == nil { |
| 55 | s.Runner.Jobs = &runnercfg.Tracker{} |
| 56 | } |
| 57 | st, err := s.runnerSettingsFile().Load(s.builtinDefaults()) |
| 58 | if err != nil { |
| 59 | return err |
| 60 | } |
| 61 | return s.applyBuiltin(st) |
| 62 | } |
| 63 | |
| 64 | func (s *Server) applyBuiltin(st runnercfg.Settings) error { |
| 65 | if s.Runner == nil { |
| 66 | return nil |
| 67 | } |
| 68 | over, err := st.Overrides(filepath.Join(s.runnerWorkDir(), "runner"), s.Cfg.CI.ImageOverrides()) |
| 69 | if err != nil { |
| 70 | return err |
| 71 | } |
| 72 | s.Runner.Configure(st, over) |
| 73 | return nil |
| 74 | } |
| 75 | |
| 76 | // RunnerMaintenance voert elke 10 minuten het opruimbeleid uit. |
| 77 | func (s *Server) RunnerMaintenance(ctx context.Context) { |
| 78 | t := time.NewTicker(10 * time.Minute) |
| 79 | defer t.Stop() |
| 80 | for { |
| 81 | select { |
| 82 | case <-ctx.Done(): |
| 83 | return |
| 84 | case <-t.C: |
| 85 | if s.Runner == nil { |
| 86 | continue |
| 87 | } |
| 88 | st, _ := s.runnerSettingsFile().Load(s.builtinDefaults()) |
| 89 | runnercfg.Cleanup(ctx, s.Cfg.CI.Docker, st, s.Runner.Jobs, filepath.Join(s.runnerWorkDir(), "cache")) |
| 90 | } |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | func (s *Server) builtinStatus() runnercfg.Status { |
| 95 | st := runnercfg.Status{Kind: "builtin", ServerURL: s.Cfg.BaseURL, Online: s.Runner != nil, LastContact: time.Now()} |
| 96 | if s.Runner != nil { |
| 97 | st.Name = s.Runner.BuiltinName() |
| 98 | } |
| 99 | if s.StateDir != "" { |
| 100 | if u, err := update.ReadStatus(s.StateDir); err == nil && u.SHA != "" { |
| 101 | st.Version = shortSHA(u.SHA) |
| 102 | } |
| 103 | } |
| 104 | return st |
| 105 | } |
| 106 | |
| 107 | func (s *Server) runnerAdmin() *runnercfg.Handler { |
| 108 | return &runnercfg.Handler{ |
| 109 | Prefix: "/admin/runner", |
| 110 | APIBase: "/api/v1/admin/runner", |
| 111 | File: s.runnerSettingsFile(), |
| 112 | Default: s.builtinDefaults(), |
| 113 | Tracker: s.builtinTracker(), |
| 114 | WorkDir: s.runnerWorkDir(), |
| 115 | BasePresets: s.Cfg.CI.ImageOverrides(), |
| 116 | Apply: s.applyBuiltin, |
| 117 | Status: s.builtinStatus, |
| 118 | DocsURL: "/help/runners#ingebouwde-runner", |
| 119 | Lang: s.langOf, |
| 120 | Auth: func(w http.ResponseWriter, r *http.Request, write bool) bool { |
| 121 | if strings.HasPrefix(r.URL.Path, "/api/") { |
| 122 | if !apiUser(r).InstanceAdmin { |
| 123 | writeJSON(w, http.StatusForbidden, map[string]string{"message": "instance admin only"}) |
| 124 | return false |
| 125 | } |
| 126 | } else if ok, _ := s.adminOnly(w, r); !ok { |
| 127 | return false |
| 128 | } |
| 129 | if s.Runner == nil { |
| 130 | http.Error(w, s.tr(r, "rui.ciOff"), http.StatusNotFound) |
| 131 | return false |
| 132 | } |
| 133 | return true |
| 134 | }, |
| 135 | CSRF: func(r *http.Request) (string, string) { return "csrf", s.who(r).Session.CSRF }, |
| 136 | CheckCSRF: func(r *http.Request) bool { |
| 137 | p := s.who(r) |
| 138 | return p.OK && r.FormValue("csrf") != "" && r.FormValue("csrf") == p.Session.CSRF |
| 139 | }, |
| 140 | Layout: func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML) { |
| 141 | v := s.view(w, r, title) |
| 142 | v.Page = "adminrunner" |
| 143 | v.Wide = true |
| 144 | v.RunnerUI = body |
| 145 | rs, _ := s.Store.ListRunners(r.Context(), store.RunnerGlobal, 0) |
| 146 | v.RunnerList = runnerViews(rs) |
| 147 | v.NewRunnerToken = s.takeRunnerOnce(w, r, "/admin") |
| 148 | s.render(w, "adminrunner", v) |
| 149 | }, |
| 150 | } |
| 151 | } |
| 152 | |
| 153 | func (s *Server) builtinTracker() *runnercfg.Tracker { |
| 154 | if s.Runner == nil { |
| 155 | return &runnercfg.Tracker{} |
| 156 | } |
| 157 | if s.Runner.Jobs == nil { |
| 158 | s.Runner.Jobs = &runnercfg.Tracker{} |
| 159 | } |
| 160 | return s.Runner.Jobs |
| 161 | } |
| 162 | |
| 163 | func (s *Server) apiAdminRunnerStatus(w http.ResponseWriter, r *http.Request) { |
| 164 | s.runnerAdmin().APIStatus(w, r) |
| 165 | } |
| 166 | func (s *Server) apiAdminRunnerSettings(w http.ResponseWriter, r *http.Request) { |
| 167 | s.runnerAdmin().APISettings(w, r) |
| 168 | } |
| 169 | func (s *Server) apiAdminRunnerJobs(w http.ResponseWriter, r *http.Request) { |
| 170 | s.runnerAdmin().APIJobs(w, r) |
| 171 | } |
| 172 | func (s *Server) apiAdminRunnerPause(w http.ResponseWriter, r *http.Request) { |
| 173 | s.runnerAdmin().APIPause(true)(w, r) |
| 174 | } |
| 175 | func (s *Server) apiAdminRunnerResume(w http.ResponseWriter, r *http.Request) { |
| 176 | s.runnerAdmin().APIPause(false)(w, r) |
| 177 | } |
| 178 | |
| 179 | // mountRunnerAdmin hangt de UI-routes op. De API zit in apiCatalog. |
| 180 | func (s *Server) mountRunnerAdmin(mux *http.ServeMux) { |
| 181 | h := &lazyRunnerAdmin{s: s} |
| 182 | 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"} { |
| 183 | mux.Handle(p, h) |
| 184 | } |
| 185 | } |
| 186 | |
| 187 | // lazyRunnerAdmin bouwt de handler per verzoek: s.Runner wordt pas na Handler() gezet. |
| 188 | type lazyRunnerAdmin struct{ s *Server } |
| 189 | |
| 190 | func (l *lazyRunnerAdmin) ServeHTTP(w http.ResponseWriter, r *http.Request) { |
| 191 | m := http.NewServeMux() |
| 192 | l.s.runnerAdmin().Mount(m, false) |
| 193 | m.ServeHTTP(w, r) |
| 194 | } |
| 195 | |
| 196 | // ---- globale runners (beheer) ---- |
| 197 | |
| 198 | func (s *Server) globalRunnerGuard(w http.ResponseWriter, r *http.Request) bool { |
| 199 | if ok, _ := s.adminOnly(w, r); !ok { |
| 200 | return false |
| 201 | } |
| 202 | return s.csrfOK(w, r) |
| 203 | } |
| 204 | |
| 205 | const globalBack = "/admin/runner#global" |
| 206 | |
| 207 | func (s *Server) globalRunnerToken(w http.ResponseWriter, r *http.Request) { |
| 208 | if !s.globalRunnerGuard(w, r) { |
| 209 | return |
| 210 | } |
| 211 | plain, err := s.Store.CreateRunnerRegToken(r.Context(), store.RunnerGlobal, 0, s.who(r).User.ID) |
| 212 | if err != nil { |
| 213 | s.redirect(w, r, globalBack, "", s.trErr(r, err)) |
| 214 | return |
| 215 | } |
| 216 | s.setRunnerOnce(w, "/admin", plain) |
| 217 | s.redirect(w, r, globalBack, s.tr(r, "runner.tokenMade"), "") |
| 218 | } |
| 219 | |
| 220 | func (s *Server) globalRunnerID(r *http.Request) int64 { |
| 221 | id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64) |
| 222 | return id |
| 223 | } |
| 224 | |
| 225 | func (s *Server) globalRunnerDelete(w http.ResponseWriter, r *http.Request) { |
| 226 | if !s.globalRunnerGuard(w, r) { |
| 227 | return |
| 228 | } |
| 229 | if err := s.revokeRunner(r.Context(), store.RunnerGlobal, 0, s.globalRunnerID(r), false); err != nil { |
| 230 | s.redirect(w, r, globalBack, "", s.revokeErr(r, err)) |
| 231 | return |
| 232 | } |
| 233 | s.redirect(w, r, globalBack, s.tr(r, "runner.revoked"), "") |
| 234 | } |
| 235 | |
| 236 | func (s *Server) globalRunnerUpdate(w http.ResponseWriter, r *http.Request) { |
| 237 | if !s.globalRunnerGuard(w, r) { |
| 238 | return |
| 239 | } |
| 240 | var name *string |
| 241 | var paused *bool |
| 242 | if n := strings.TrimSpace(r.FormValue("name")); n != "" { |
| 243 | name = &n |
| 244 | } |
| 245 | if p := r.FormValue("paused"); p != "" { |
| 246 | b := p == "1" |
| 247 | paused = &b |
| 248 | } |
| 249 | if _, err := s.Store.UpdateRunner(r.Context(), store.RunnerGlobal, 0, s.globalRunnerID(r), name, paused); err != nil { |
| 250 | s.redirect(w, r, globalBack, "", s.trErr(r, err)) |
| 251 | return |
| 252 | } |
| 253 | s.redirect(w, r, globalBack, s.tr(r, "flash.saved"), "") |
| 254 | } |