BlueGit

timfa bluegit

Files

bluegit / internal / server / runners.go

runners.go

runners.go 12.4 KiB Download Raw
1package server
2
3import (
4 "encoding/json"
5 "errors"
6 "io"
7 "net/http"
8 "os"
9 "strconv"
10 "strings"
11 "time"
12
13 "gitlab.com/Timfa/bluegit/internal/access"
14 "gitlab.com/Timfa/bluegit/internal/runner"
15 "gitlab.com/Timfa/bluegit/internal/store"
16)
17
18// RunnerView is één aparte runner in de beheer-UI.
19type RunnerView struct {
20 ID int64
21 Name string
22 Online bool
23 LastSeen time.Time
24 Created time.Time
25 Version string
26 Paused bool
27 Draining bool
28}
29
30func runnerViews(rs []store.Runner) []RunnerView {
31 now := time.Now()
32 out := make([]RunnerView, 0, len(rs))
33 for _, r := range rs {
34 out = append(out, RunnerView{ID: r.ID, Name: r.Name, Online: r.Online(now), LastSeen: r.LastSeen, Created: r.CreatedAt, Version: r.Version, Paused: r.Paused, Draining: r.Draining})
35 }
36 return out
37}
38
39// Long-poll-duur voor runner-jobaanvragen.
40var runnerPollWait = 25 * time.Second
41
42func (s *Server) routeRunners(mux *http.ServeMux) {
43 mux.HandleFunc("POST /settings/runners/token", s.userRunnerToken)
44 mux.HandleFunc("POST /settings/runners/delete", s.userRunnerDelete)
45 mux.HandleFunc("POST /settings/runners/pref", s.userRunnerPref)
46 mux.HandleFunc("POST /groups/{path}/runners/token", s.groupRunnerToken)
47 mux.HandleFunc("POST /groups/{path}/runners/delete", s.groupRunnerDelete)
48 mux.HandleFunc("POST /groups/{path}/runners/options", s.groupRunnerOptions)
49 mux.HandleFunc("POST /groups/{path}/runners/optin", s.groupRunnerOptIn)
50 mux.HandleFunc("POST /admin/runners/token", s.globalRunnerToken)
51 mux.HandleFunc("POST /admin/runners/delete", s.globalRunnerDelete)
52 mux.HandleFunc("POST /admin/runners/update", s.globalRunnerUpdate)
53
54 mux.HandleFunc("POST /api/v1/runners/register", s.runnerRegister)
55 mux.HandleFunc("POST /api/v1/runner/heartbeat", s.runnerHeartbeat)
56 mux.HandleFunc("POST /api/v1/runner/jobs/request", s.runnerRequest)
57 mux.HandleFunc("POST /api/v1/runner/jobs/{id}/log", s.runnerLog)
58 mux.HandleFunc("GET /api/v1/runner/jobs/{id}/inputs", s.runnerInputs)
59 mux.HandleFunc("PUT /api/v1/runner/jobs/{id}/artifacts", s.runnerArtifacts)
60 mux.HandleFunc("POST /api/v1/runner/jobs/{id}/finish", s.runnerFinish)
61}
62
63// ---- beheer-UI ----
64
65func (s *Server) setRunnerOnce(w http.ResponseWriter, path, plain string) {
66 secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
67 http.SetCookie(w, &http.Cookie{Name: "bluegit_runner_once", Value: plain, Path: path, MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode})
68}
69
70func (s *Server) takeRunnerOnce(w http.ResponseWriter, r *http.Request, path string) string {
71 v := cookieVal(r, "bluegit_runner_once")
72 if v != "" {
73 http.SetCookie(w, &http.Cookie{Name: "bluegit_runner_once", Value: "", Path: path, MaxAge: -1})
74 }
75 return v
76}
77
78func (s *Server) fillUserRunners(w http.ResponseWriter, r *http.Request, v *View, u store.User) {
79 rs, _ := s.Store.ListRunners(r.Context(), "user", u.ID)
80 v.RunnerList = runnerViews(rs)
81 v.RunnerPref = s.Store.UserRunnerPref(r.Context(), u.ID)
82 v.NewRunnerToken = s.takeRunnerOnce(w, r, "/settings")
83}
84
85func (s *Server) userRunnerToken(w http.ResponseWriter, r *http.Request) {
86 u, ok := s.loginRequired(w, r)
87 if !ok || !s.csrfOK(w, r) {
88 return
89 }
90 plain, err := s.Store.CreateRunnerRegToken(r.Context(), "user", u.ID, u.ID)
91 if err != nil {
92 s.redirect(w, r, "/settings#runners", "", s.trErr(r, err))
93 return
94 }
95 s.setRunnerOnce(w, "/settings", plain)
96 s.redirect(w, r, "/settings#runners", s.tr(r, "runner.tokenMade"), "")
97}
98
99func (s *Server) userRunnerDelete(w http.ResponseWriter, r *http.Request) {
100 u, ok := s.loginRequired(w, r)
101 if !ok || !s.csrfOK(w, r) {
102 return
103 }
104 id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
105 if err := s.revokeRunner(r.Context(), "user", u.ID, id, false); err != nil {
106 s.redirect(w, r, "/settings#runners", "", s.revokeErr(r, err))
107 return
108 }
109 s.redirect(w, r, "/settings#runners", s.tr(r, "runner.revoked"), "")
110}
111
112func (s *Server) userRunnerPref(w http.ResponseWriter, r *http.Request) {
113 u, ok := s.loginRequired(w, r)
114 if !ok || !s.csrfOK(w, r) {
115 return
116 }
117 _ = s.Store.SetUserRunnerPref(r.Context(), u.ID, r.FormValue("pref"))
118 s.redirect(w, r, "/settings#runners", s.tr(r, "flash.saved"), "")
119}
120
121func (s *Server) fillGroupRunners(w http.ResponseWriter, r *http.Request, v *View, g store.Group) {
122 rs, _ := s.Store.ListRunners(r.Context(), "group", g.ID)
123 v.RunnerList = runnerViews(rs)
124 v.BuiltinFirst = s.Store.GroupBuiltinFirst(r.Context(), g.ID)
125 ids, _ := s.Store.RunnerOptIns(r.Context(), g.ID)
126 for _, id := range ids {
127 if v.User != nil && id == v.User.ID {
128 v.RunnerOptIn = true
129 }
130 if u, err := s.Store.UserByID(r.Context(), id); err == nil {
131 v.OptInNames = append(v.OptInNames, u.Username)
132 }
133 }
134 v.NewRunnerToken = s.takeRunnerOnce(w, r, "/groups/"+g.Path)
135}
136
137func (s *Server) groupRunnerToken(w http.ResponseWriter, r *http.Request) {
138 g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
139 if !ok || !s.csrfOK(w, r) {
140 return
141 }
142 back := "/groups/" + g.Path + "?tab=settings#runners"
143 plain, err := s.Store.CreateRunnerRegToken(r.Context(), "group", g.ID, s.who(r).User.ID)
144 if err != nil {
145 s.redirect(w, r, back, "", s.trErr(r, err))
146 return
147 }
148 s.setRunnerOnce(w, "/groups/"+g.Path, plain)
149 s.redirect(w, r, back, s.tr(r, "runner.tokenMade"), "")
150}
151
152func (s *Server) groupRunnerDelete(w http.ResponseWriter, r *http.Request) {
153 g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
154 if !ok || !s.csrfOK(w, r) {
155 return
156 }
157 back := "/groups/" + g.Path + "?tab=settings#runners"
158 id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
159 if err := s.revokeRunner(r.Context(), "group", g.ID, id, false); err != nil {
160 s.redirect(w, r, back, "", s.revokeErr(r, err))
161 return
162 }
163 s.redirect(w, r, back, s.tr(r, "runner.revoked"), "")
164}
165
166func (s *Server) groupRunnerOptions(w http.ResponseWriter, r *http.Request) {
167 g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
168 if !ok || !s.csrfOK(w, r) {
169 return
170 }
171 _ = s.Store.SetGroupBuiltinFirst(r.Context(), g.ID, r.FormValue("builtin_first") == "1")
172 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings#runners", s.tr(r, "flash.saved"), "")
173}
174
175// groupRunnerOptIn: een maintainer staat zijn eigen account-runners toe
176// voor de groep (of trekt dat in). Alleen voor zichzelf.
177func (s *Server) groupRunnerOptIn(w http.ResponseWriter, r *http.Request) {
178 g, _, ok := s.guardGroup(w, r, access.RoleReadonly)
179 if !ok || !s.csrfOK(w, r) {
180 return
181 }
182 _ = s.Store.SetRunnerOptIn(r.Context(), g.ID, s.who(r).User.ID, r.FormValue("on") == "1")
183 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings#runners", s.tr(r, "flash.saved"), "")
184}
185
186// ---- runner-protocol ----
187
188func runnerJSONErr(w http.ResponseWriter, code int, msg string) {
189 writeJSON(w, code, map[string]any{"message": msg})
190}
191
192func (s *Server) runnerAuth(w http.ResponseWriter, r *http.Request) (store.Runner, bool) {
193 h := r.Header.Get("Authorization")
194 tok := ""
195 if strings.HasPrefix(strings.ToLower(h), "bearer ") {
196 tok = strings.TrimSpace(h[7:])
197 }
198 rn, err := s.Store.RunnerByToken(r.Context(), tok)
199 if err != nil {
200 runnerJSONErr(w, http.StatusUnauthorized, "invalid runner token")
201 return store.Runner{}, false
202 }
203 if s.Runner == nil || s.StoragePath() == "" {
204 runnerJSONErr(w, http.StatusServiceUnavailable, "CI is disabled on this server")
205 return store.Runner{}, false
206 }
207 _ = s.Store.TouchRunner(r.Context(), rn.ID, r.Header.Get("X-Runner-Version"))
208 return rn, true
209}
210
211func (s *Server) runnerJob(w http.ResponseWriter, r *http.Request, rn store.Runner) (store.Job, bool) {
212 id, _ := strconv.ParseInt(r.PathValue("id"), 10, 64)
213 job, err := s.Store.JobForRunner(r.Context(), rn.ID, id)
214 if err != nil {
215 runnerJSONErr(w, http.StatusNotFound, "job not found")
216 return store.Job{}, false
217 }
218 return job, true
219}
220
221func (s *Server) runnerRegister(w http.ResponseWriter, r *http.Request) {
222 var body struct {
223 Token string `json:"token"`
224 Name string `json:"name"`
225 Version string `json:"version"`
226 }
227 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&body); err != nil {
228 runnerJSONErr(w, http.StatusBadRequest, "invalid JSON")
229 return
230 }
231 rn, plain, err := s.Store.RegisterRunner(r.Context(), strings.TrimSpace(body.Token), body.Name, body.Version)
232 if err != nil {
233 if errors.Is(err, store.ErrRegToken) {
234 runnerJSONErr(w, http.StatusForbidden, err.Error())
235 return
236 }
237 runnerJSONErr(w, http.StatusInternalServerError, "registration failed")
238 return
239 }
240 writeJSON(w, http.StatusCreated, map[string]any{"id": rn.ID, "name": rn.Name, "token": plain})
241}
242
243func (s *Server) runnerHeartbeat(w http.ResponseWriter, r *http.Request) {
244 rn, ok := s.runnerAuth(w, r)
245 if !ok {
246 return
247 }
248 // Optioneel: {"draining": true} als de runner lokaal gepauzeerd is.
249 // {"name": "..."} als de naam op de runner zelf is ingesteld (die wint).
250 var body struct {
251 Draining *bool `json:"draining"`
252 Name string `json:"name"`
253 }
254 _ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&body)
255 if body.Draining != nil && *body.Draining != rn.Draining {
256 _ = s.Store.SetRunnerDraining(r.Context(), rn.ID, *body.Draining)
257 }
258 if n := strings.TrimSpace(body.Name); n != "" && n != rn.Name && len(n) <= 63 {
259 if upd, err := s.Store.UpdateRunner(r.Context(), rn.OwnerKind, rn.OwnerID, rn.ID, &n, nil); err == nil {
260 rn = upd
261 }
262 }
263 writeJSON(w, http.StatusOK, map[string]any{"id": rn.ID, "name": rn.Name, "paused": rn.Paused})
264}
265
266func (s *Server) runnerRequest(w http.ResponseWriter, r *http.Request) {
267 rn, ok := s.runnerAuth(w, r)
268 if !ok {
269 return
270 }
271 deadline := time.Now().Add(runnerPollWait)
272 for {
273 pl, err := s.Runner.Claim(r.Context(), rn)
274 if err != nil {
275 runnerJSONErr(w, http.StatusInternalServerError, "claim failed")
276 return
277 }
278 if pl != nil {
279 writeJSON(w, http.StatusOK, pl)
280 return
281 }
282 if time.Now().After(deadline) {
283 w.WriteHeader(http.StatusNoContent)
284 return
285 }
286 select {
287 case <-r.Context().Done():
288 return
289 case <-time.After(time.Second):
290 }
291 _ = s.Store.TouchRunner(r.Context(), rn.ID, "")
292 }
293}
294
295func (s *Server) runnerLog(w http.ResponseWriter, r *http.Request) {
296 rn, ok := s.runnerAuth(w, r)
297 if !ok {
298 return
299 }
300 job, ok := s.runnerJob(w, r, rn)
301 if !ok {
302 return
303 }
304 chunk, _ := io.ReadAll(io.LimitReader(r.Body, 4<<20))
305 cancel, err := s.Runner.RemoteLog(r.Context(), job, string(chunk))
306 if err != nil {
307 runnerJSONErr(w, http.StatusInternalServerError, "log failed")
308 return
309 }
310 writeJSON(w, http.StatusOK, map[string]any{"cancel": cancel})
311}
312
313func (s *Server) runnerInputs(w http.ResponseWriter, r *http.Request) {
314 rn, ok := s.runnerAuth(w, r)
315 if !ok {
316 return
317 }
318 job, ok := s.runnerJob(w, r, rn)
319 if !ok || job.Status != "running" {
320 if ok {
321 runnerJSONErr(w, http.StatusConflict, "job is not running")
322 }
323 return
324 }
325 dir, err := os.MkdirTemp("", "bluegit-inputs-")
326 if err != nil {
327 runnerJSONErr(w, http.StatusInternalServerError, "temp dir")
328 return
329 }
330 defer os.RemoveAll(dir)
331 if err := s.Runner.RemoteInputs(r.Context(), job, dir); err != nil {
332 runnerJSONErr(w, http.StatusInternalServerError, "inputs failed")
333 return
334 }
335 w.Header().Set("Content-Type", "application/gzip")
336 _ = runner.WriteTar(w, dir, nil)
337}
338
339func (s *Server) runnerArtifacts(w http.ResponseWriter, r *http.Request) {
340 rn, ok := s.runnerAuth(w, r)
341 if !ok {
342 return
343 }
344 job, ok := s.runnerJob(w, r, rn)
345 if !ok || job.Status != "running" {
346 if ok {
347 runnerJSONErr(w, http.StatusConflict, "job is not running")
348 }
349 return
350 }
351 dir, err := os.MkdirTemp("", "bluegit-artifacts-")
352 if err != nil {
353 runnerJSONErr(w, http.StatusInternalServerError, "temp dir")
354 return
355 }
356 defer os.RemoveAll(dir)
357 paths := job.ArtifactPaths
358 if paths == nil {
359 paths = []string{}
360 }
361 if err := runner.ReadTar(r.Body, dir, paths, 4<<30); err != nil {
362 runnerJSONErr(w, http.StatusBadRequest, "bad archive: "+err.Error())
363 return
364 }
365 if err := s.Runner.RemoteArtifacts(r.Context(), job, dir); err != nil {
366 runnerJSONErr(w, http.StatusBadRequest, err.Error())
367 return
368 }
369 writeJSON(w, http.StatusOK, map[string]any{"ok": true})
370}
371
372func (s *Server) runnerFinish(w http.ResponseWriter, r *http.Request) {
373 rn, ok := s.runnerAuth(w, r)
374 if !ok {
375 return
376 }
377 job, ok := s.runnerJob(w, r, rn)
378 if !ok {
379 return
380 }
381 var body struct {
382 Status string `json:"status"`
383 Message string `json:"message"`
384 }
385 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body); err != nil {
386 runnerJSONErr(w, http.StatusBadRequest, "invalid JSON")
387 return
388 }
389 if err := s.Runner.RemoteFinish(r.Context(), rn, job.ID, body.Status, body.Message); err != nil {
390 runnerJSONErr(w, http.StatusInternalServerError, "finish failed")
391 return
392 }
393 writeJSON(w, http.StatusOK, map[string]any{"ok": true})
394}