BlueGit

timfa bluegit

Files

bluegit / internal / store / runners.go

runners.go

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