BlueGit

timfa bluegit

Files

bluegit / internal / store / runners.go

runners.go

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