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