| 1 | package store |
| 2 | |
| 3 | import ( |
| 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). |
| 13 | type 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. |
| 28 | const RunnerOnlineWindow = 90 * time.Second |
| 29 | |
| 30 | // Online zegt of de runner recent contact had. |
| 31 | func (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. |
| 36 | const ( |
| 37 | RunnerPrefOwnFirst = "own_first" |
| 38 | RunnerPrefBuiltinFirst = "builtin_first" |
| 39 | ) |
| 40 | |
| 41 | // ErrRegToken is een onbekend, gebruikt of verlopen registratietoken. |
| 42 | var 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. |
| 46 | const RunnerGlobal = "global" |
| 47 | |
| 48 | // CreateRunnerRegToken maakt een eenmalig registratietoken (24 uur geldig). |
| 49 | func (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. |
| 62 | func (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 | |
| 101 | const runnerCols = `id, owner_kind, owner_id, name, created_at, last_seen, version, revoked, paused, draining` |
| 102 | |
| 103 | func 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. |
| 115 | func (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. |
| 127 | func (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. |
| 136 | func (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). |
| 142 | func (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. |
| 152 | func (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. |
| 170 | func (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. |
| 182 | func (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. |
| 191 | func (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". |
| 200 | func (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. |
| 207 | func (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. |
| 217 | func (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. |
| 227 | func (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. |
| 245 | type 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. |
| 253 | func (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. |
| 264 | func (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). |
| 271 | func (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. |
| 277 | func (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. |
| 284 | func (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. |
| 308 | func (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. |
| 321 | type RemoteJob struct { |
| 322 | Job Job |
| 323 | RunnerID int64 |
| 324 | } |
| 325 | |
| 326 | // RemoteRunningJobs geeft lopende jobs die een aparte runner heeft. |
| 327 | func (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). |
| 349 | func (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. |
| 365 | func (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. |
| 372 | func (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. |
| 399 | type 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. |
| 410 | func (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 | } |