BlueGit

timfa bluegit

Files

bluegit / internal / store / runners.go

runners.go

runners.go 13.7 KiB Download Raw
1package store
2
3import (
4 "context"
5 "database/sql"
6 "errors"
7 "strings"
8 "time"
9)
10
11// Runner is een aparte bluegit-runner op een eigen machine, gekoppeld aan
12// een account (owner_kind user) of een groep (owner_kind group).
13type Runner struct {
14 ID int64
15 OwnerKind string
16 OwnerID int64
17 Name string
18 CreatedAt time.Time
19 LastSeen time.Time
20 Version string
21 Revoked bool
22 Paused bool
23}
24
25// RunnerOnlineWindow: zo lang na de laatste heartbeat telt een runner als online.
26const RunnerOnlineWindow = 90 * time.Second
27
28// Online zegt of de runner recent contact had.
29func (r Runner) Online(now time.Time) bool {
30 return !r.Revoked && !r.LastSeen.IsZero() && now.Sub(r.LastSeen) < RunnerOnlineWindow
31}
32
33// Runner-voorkeuren van een account.
34const (
35 RunnerPrefOwnFirst = "own_first"
36 RunnerPrefBuiltinFirst = "builtin_first"
37)
38
39// ErrRegToken is een onbekend, gebruikt of verlopen registratietoken.
40var ErrRegToken = errors.New("registration token invalid or expired")
41
42// CreateRunnerRegToken maakt een eenmalig registratietoken (24 uur geldig).
43func (s *Store) CreateRunnerRegToken(ctx context.Context, ownerKind string, ownerID, by int64) (string, error) {
44 plain, err := newToken("bgrr_")
45 if err != nil {
46 return "", err
47 }
48 exp := time.Now().Add(24 * time.Hour).UTC().Format(time.RFC3339)
49 _, err = s.db.ExecContext(ctx, `INSERT INTO runner_reg_tokens (owner_kind, owner_id, token_hash, created_by, expires_at) VALUES (?, ?, ?, ?, ?)`,
50 ownerKind, ownerID, hashToken(plain), by, exp)
51 return plain, err
52}
53
54// RegisterRunner wisselt een registratietoken in voor een runner en zijn
55// eigen runner-token (bgr_). Alleen de hash wordt bewaard.
56func (s *Store) RegisterRunner(ctx context.Context, regToken, name, version string) (Runner, string, error) {
57 tx, err := s.db.BeginTx(ctx, nil)
58 if err != nil {
59 return Runner{}, "", err
60 }
61 defer func() { _ = tx.Rollback() }()
62 var id, ownerID, by int64
63 var kind, exp string
64 err = tx.QueryRowContext(ctx, `SELECT id, owner_kind, owner_id, created_by, expires_at FROM runner_reg_tokens WHERE token_hash = ? AND used = 0`, hashToken(regToken)).Scan(&id, &kind, &ownerID, &by, &exp)
65 if err != nil || parseTime(exp).Before(time.Now()) {
66 return Runner{}, "", ErrRegToken
67 }
68 if _, err := tx.ExecContext(ctx, `UPDATE runner_reg_tokens SET used = 1 WHERE id = ?`, id); err != nil {
69 return Runner{}, "", err
70 }
71 plain, err := newToken("bgr_")
72 if err != nil {
73 return Runner{}, "", err
74 }
75 name = strings.TrimSpace(name)
76 if name == "" {
77 name = "runner"
78 }
79 if len(name) > 80 {
80 name = name[:80]
81 }
82 at := now()
83 res, err := tx.ExecContext(ctx, `INSERT INTO runners (owner_kind, owner_id, name, token_hash, created_by, created_at, last_seen, version) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
84 kind, ownerID, name, hashToken(plain), by, at, at, version)
85 if err != nil {
86 return Runner{}, "", err
87 }
88 rid, _ := res.LastInsertId()
89 if err := tx.Commit(); err != nil {
90 return Runner{}, "", err
91 }
92 return Runner{ID: rid, OwnerKind: kind, OwnerID: ownerID, Name: name, CreatedAt: parseTime(at), LastSeen: parseTime(at), Version: version}, plain, nil
93}
94
95const runnerCols = `id, owner_kind, owner_id, name, created_at, last_seen, version, revoked, paused`
96
97func scanRunner(sc interface{ Scan(...any) error }) (Runner, error) {
98 var r Runner
99 var created, seen string
100 var revoked, paused int
101 if err := sc.Scan(&r.ID, &r.OwnerKind, &r.OwnerID, &r.Name, &created, &seen, &r.Version, &revoked, &paused); err != nil {
102 return Runner{}, err
103 }
104 r.CreatedAt, r.LastSeen, r.Revoked, r.Paused = parseTime(created), parseTime(seen), revoked == 1, paused == 1
105 return r, nil
106}
107
108// RunnerByToken geeft de runner bij een bgr_-token. Ingetrokken telt niet.
109func (s *Store) RunnerByToken(ctx context.Context, token string) (Runner, error) {
110 if !strings.HasPrefix(token, "bgr_") {
111 return Runner{}, errNotFound
112 }
113 r, err := scanRunner(s.db.QueryRowContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE token_hash = ? AND revoked = 0`, hashToken(token)))
114 if errors.Is(err, sql.ErrNoRows) {
115 return Runner{}, errNotFound
116 }
117 return r, err
118}
119
120// RunnerByID geeft één runner.
121func (s *Store) RunnerByID(ctx context.Context, id int64) (Runner, error) {
122 r, err := scanRunner(s.db.QueryRowContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE id = ?`, id))
123 if errors.Is(err, sql.ErrNoRows) {
124 return Runner{}, errNotFound
125 }
126 return r, err
127}
128
129// TouchRunner is de heartbeat.
130func (s *Store) TouchRunner(ctx context.Context, id int64, version string) error {
131 _, err := s.db.ExecContext(ctx, `UPDATE runners SET last_seen = ?, version = CASE WHEN ? = '' THEN version ELSE ? END WHERE id = ?`, now(), version, version, id)
132 return err
133}
134
135// ListRunners geeft de niet-ingetrokken runners van een eigenaar.
136func (s *Store) ListRunners(ctx context.Context, ownerKind string, ownerID int64) ([]Runner, error) {
137 rows, err := s.db.QueryContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE owner_kind = ? AND owner_id = ? AND revoked = 0 ORDER BY id`, ownerKind, ownerID)
138 if err != nil {
139 return nil, err
140 }
141 defer rows.Close()
142 var out []Runner
143 for rows.Next() {
144 r, err := scanRunner(rows)
145 if err != nil {
146 return nil, err
147 }
148 out = append(out, r)
149 }
150 return out, rows.Err()
151}
152
153// RevokeRunner trekt een runner in; zijn token werkt daarna niet meer.
154func (s *Store) RevokeRunner(ctx context.Context, ownerKind string, ownerID, id int64) error {
155 res, err := s.db.ExecContext(ctx, `UPDATE runners SET revoked = 1 WHERE id = ? AND owner_kind = ? AND owner_id = ?`, id, ownerKind, ownerID)
156 if err != nil {
157 return err
158 }
159 if n, _ := res.RowsAffected(); n == 0 {
160 return errNotFound
161 }
162 return nil
163}
164
165// UserRunnerPref is own_first of builtin_first.
166func (s *Store) UserRunnerPref(ctx context.Context, userID int64) string {
167 var p string
168 if err := s.db.QueryRowContext(ctx, `SELECT runner_pref FROM users WHERE id = ?`, userID).Scan(&p); err != nil || p != RunnerPrefOwnFirst {
169 return RunnerPrefBuiltinFirst
170 }
171 return p
172}
173
174// SetUserRunnerPref bewaart de voorkeur.
175func (s *Store) SetUserRunnerPref(ctx context.Context, userID int64, pref string) error {
176 if pref != RunnerPrefOwnFirst {
177 pref = RunnerPrefBuiltinFirst
178 }
179 _, err := s.db.ExecContext(ctx, `UPDATE users SET runner_pref = ? WHERE id = ?`, pref, userID)
180 return err
181}
182
183// GroupBuiltinFirst: "Probeer BlueGit runner eerst".
184func (s *Store) GroupBuiltinFirst(ctx context.Context, groupID int64) bool {
185 var v int
186 _ = s.db.QueryRowContext(ctx, `SELECT builtin_first FROM groups WHERE id = ?`, groupID).Scan(&v)
187 return v == 1
188}
189
190// SetGroupBuiltinFirst zet de groepsinstelling.
191func (s *Store) SetGroupBuiltinFirst(ctx context.Context, groupID int64, on bool) error {
192 v := 0
193 if on {
194 v = 1
195 }
196 _, err := s.db.ExecContext(ctx, `UPDATE groups SET builtin_first = ? WHERE id = ?`, v, groupID)
197 return err
198}
199
200// SetRunnerOptIn: maintainer userID staat zijn account-runners toe voor de groep.
201func (s *Store) SetRunnerOptIn(ctx context.Context, groupID, userID int64, on bool) error {
202 if on {
203 _, err := s.db.ExecContext(ctx, `INSERT OR IGNORE INTO group_runner_optin (group_id, user_id) VALUES (?, ?)`, groupID, userID)
204 return err
205 }
206 _, err := s.db.ExecContext(ctx, `DELETE FROM group_runner_optin WHERE group_id = ? AND user_id = ?`, groupID, userID)
207 return err
208}
209
210// RunnerOptIns zijn de gebruikers die hun runners voor de groep toestaan.
211func (s *Store) RunnerOptIns(ctx context.Context, groupID int64) ([]int64, error) {
212 rows, err := s.db.QueryContext(ctx, `SELECT user_id FROM group_runner_optin WHERE group_id = ? ORDER BY user_id`, groupID)
213 if err != nil {
214 return nil, err
215 }
216 defer rows.Close()
217 var out []int64
218 for rows.Next() {
219 var id int64
220 if err := rows.Scan(&id); err != nil {
221 return nil, err
222 }
223 out = append(out, id)
224 }
225 return out, rows.Err()
226}
227
228// JobRun is de runner-administratie van één job.
229type JobRun struct {
230 RunnerID int64
231 RunnerName string
232 OfferTier int
233 OfferAt time.Time
234}
235
236// JobRun leest de administratie; een lege JobRun als er niets is.
237func (s *Store) JobRun(ctx context.Context, jobID int64) JobRun {
238 var jr JobRun
239 var at string
240 if err := s.db.QueryRowContext(ctx, `SELECT runner_id, runner_name, offer_tier, offer_at FROM job_runs WHERE job_id = ?`, jobID).Scan(&jr.RunnerID, &jr.RunnerName, &jr.OfferTier, &at); err != nil {
241 return JobRun{}
242 }
243 jr.OfferAt = parseTime(at)
244 return jr
245}
246
247// SetJobOffer zet de huidige trede in de runnervolgorde.
248func (s *Store) SetJobOffer(ctx context.Context, jobID int64, tier int, at time.Time) error {
249 _, err := s.db.ExecContext(ctx, `INSERT INTO job_runs (job_id, offer_tier, offer_at) VALUES (?, ?, ?)
250 ON CONFLICT(job_id) DO UPDATE SET offer_tier = excluded.offer_tier, offer_at = excluded.offer_at`, jobID, tier, at.UTC().Format(time.RFC3339Nano))
251 return err
252}
253
254// ClearJobOffer haalt het aanbod weg (bijvoorbeeld bij een retry).
255func (s *Store) ClearJobOffer(ctx context.Context, jobID int64) error {
256 _, err := s.db.ExecContext(ctx, `UPDATE job_runs SET offer_at = '', offer_tier = 0 WHERE job_id = ?`, jobID)
257 return err
258}
259
260// SetJobRunner noteert wie de job draait.
261func (s *Store) SetJobRunner(ctx context.Context, jobID, runnerID int64, name string) error {
262 _, err := s.db.ExecContext(ctx, `INSERT INTO job_runs (job_id, runner_id, runner_name) VALUES (?, ?, ?)
263 ON CONFLICT(job_id) DO UPDATE SET runner_id = excluded.runner_id, runner_name = excluded.runner_name`, jobID, runnerID, name)
264 return err
265}
266
267// OfferedJobs zijn wachtende jobs met een actief aanbod.
268func (s *Store) OfferedJobs(ctx context.Context) ([]Job, map[int64]JobRun, error) {
269 rows, err := s.db.QueryContext(ctx, jobSelect+` JOIN job_runs r ON r.job_id = j.id WHERE j.status = 'queued' AND r.offer_at != '' ORDER BY j.id`)
270 if err != nil {
271 return nil, nil, err
272 }
273 var out []Job
274 for rows.Next() {
275 j, err := scanJob(rows)
276 if err != nil {
277 rows.Close()
278 return nil, nil, err
279 }
280 out = append(out, j)
281 }
282 rows.Close()
283 runs := map[int64]JobRun{}
284 for _, j := range out {
285 runs[j.ID] = s.JobRun(ctx, j.ID)
286 }
287 return out, runs, nil
288}
289
290// ClaimJob zet een wachtende job op running voor een runner. false als
291// iemand anders hem al had.
292func (s *Store) ClaimJob(ctx context.Context, jobID, runnerID int64, name string) (bool, error) {
293 ok, err := s.MarkJobRunning(ctx, jobID)
294 if err != nil || !ok {
295 return false, err
296 }
297 if err := s.SetJobRunner(ctx, jobID, runnerID, name); err != nil {
298 return true, err
299 }
300 _, err = s.db.ExecContext(ctx, `UPDATE job_runs SET offer_at = '' WHERE job_id = ?`, jobID)
301 return true, err
302}
303
304// RemoteJob is een lopende job op een aparte runner.
305type RemoteJob struct {
306 Job Job
307 RunnerID int64
308}
309
310// RemoteRunningJobs geeft lopende jobs die een aparte runner heeft.
311func (s *Store) RemoteRunningJobs(ctx context.Context) ([]RemoteJob, error) {
312 rows, err := s.db.QueryContext(ctx, jobSelect+` JOIN job_runs r ON r.job_id = j.id WHERE j.status = 'running' AND r.runner_id > 0 ORDER BY j.id`)
313 if err != nil {
314 return nil, err
315 }
316 var out []RemoteJob
317 for rows.Next() {
318 j, err := scanJob(rows)
319 if err != nil {
320 rows.Close()
321 return nil, err
322 }
323 out = append(out, RemoteJob{Job: j})
324 }
325 rows.Close()
326 for i := range out {
327 out[i].RunnerID = s.JobRun(ctx, out[i].Job.ID).RunnerID
328 }
329 return out, nil
330}
331
332// JobForRunner geeft een job als die bij runnerID hoort (en loopt of net klaar is).
333func (s *Store) JobForRunner(ctx context.Context, runnerID, jobID int64) (Job, error) {
334 if s.JobRun(ctx, jobID).RunnerID != runnerID || runnerID == 0 {
335 return Job{}, errNotFound
336 }
337 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
338 if err != nil {
339 return Job{}, err
340 }
341 defer rows.Close()
342 if !rows.Next() {
343 return Job{}, errNotFound
344 }
345 return scanJob(rows)
346}
347
348// RunnerRunsRepo zegt of de runner nu een job van de repo draait.
349func (s *Store) RunnerRunsRepo(ctx context.Context, runnerID, repoID int64) bool {
350 var n int
351 _ = s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs j JOIN job_runs r ON r.job_id = j.id WHERE r.runner_id = ? AND j.repo_id = ? AND j.status = 'running'`, runnerID, repoID).Scan(&n)
352 return n > 0 && runnerID > 0
353}
354
355// UpdateRunner hernoemt en/of pauzeert een runner van deze eigenaar.
356func (s *Store) UpdateRunner(ctx context.Context, ownerKind string, ownerID, id int64, name *string, paused *bool) (Runner, error) {
357 r, err := s.RunnerByID(ctx, id)
358 if err != nil || r.Revoked || r.OwnerKind != ownerKind || r.OwnerID != ownerID {
359 return Runner{}, errNotFound
360 }
361 if name != nil {
362 n := strings.TrimSpace(*name)
363 if n == "" || len(n) > 80 {
364 return Runner{}, errors.New("runner name must be 1-80 characters")
365 }
366 if _, err := s.db.ExecContext(ctx, `UPDATE runners SET name = ? WHERE id = ?`, n, id); err != nil {
367 return Runner{}, err
368 }
369 }
370 if paused != nil {
371 v := 0
372 if *paused {
373 v = 1
374 }
375 if _, err := s.db.ExecContext(ctx, `UPDATE runners SET paused = ? WHERE id = ?`, v, id); err != nil {
376 return Runner{}, err
377 }
378 }
379 return s.RunnerByID(ctx, id)
380}
381
382// RunnerJob is een recente job van een runner.
383type RunnerJob struct {
384 JobID int64
385 PipelineID int64
386 RepoID int64
387 Name string
388 Status string
389 StartedAt time.Time
390 FinishedAt time.Time
391}
392
393// RunnerJobs geeft de recentste jobs van een runner.
394func (s *Store) RunnerJobs(ctx context.Context, runnerID int64, limit int) ([]RunnerJob, error) {
395 if limit <= 0 || limit > 100 {
396 limit = 20
397 }
398 rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.repo_id, j.name, j.status, COALESCE(j.started_at, ''), COALESCE(j.finished_at, '')
399 FROM job_runs r JOIN jobs j ON j.id = r.job_id WHERE r.runner_id = ? ORDER BY j.id DESC LIMIT ?`, runnerID, limit)
400 if err != nil {
401 return nil, err
402 }
403 defer rows.Close()
404 var out []RunnerJob
405 for rows.Next() {
406 var j RunnerJob
407 var st, fin string
408 if err := rows.Scan(&j.JobID, &j.PipelineID, &j.RepoID, &j.Name, &j.Status, &st, &fin); err != nil {
409 return nil, err
410 }
411 j.StartedAt, j.FinishedAt = parseTime(st), parseTime(fin)
412 out = append(out, j)
413 }
414 return out, rows.Err()
415}