BlueGit

timfa bluegit

Files

bluegit / internal / server / runners.go

runners.go

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