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