BlueGit

timfa bluegit

Files

bluegit / internal / server / runners.go

runners.go

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