package store import ( "context" "database/sql" "errors" "strings" "time" ) // Runner is een aparte bluegit-runner op een eigen machine, gekoppeld aan // een account (owner_kind user) of een groep (owner_kind group). type Runner struct { ID int64 OwnerKind string OwnerID int64 Name string CreatedAt time.Time LastSeen time.Time Version string Revoked bool Paused bool // Draining: de runner zelf staat lokaal op pauze (drain); lopende jobs lopen af. Draining bool } // RunnerOnlineWindow: zo lang na de laatste heartbeat telt een runner als online. const RunnerOnlineWindow = 90 * time.Second // Online zegt of de runner recent contact had. func (r Runner) Online(now time.Time) bool { return !r.Revoked && !r.LastSeen.IsZero() && now.Sub(r.LastSeen) < RunnerOnlineWindow } // Runner-voorkeuren van een account. const ( RunnerPrefOwnFirst = "own_first" RunnerPrefBuiltinFirst = "builtin_first" ) // ErrRegToken is een onbekend, gebruikt of verlopen registratietoken. var ErrRegToken = errors.New("registration token invalid or expired") // RunnerGlobal is een runner van de instance (owner_id 0), door beheerders // geregistreerd, voor jobs uit alle repo's. const RunnerGlobal = "global" // CreateRunnerRegToken maakt een eenmalig registratietoken (24 uur geldig). func (s *Store) CreateRunnerRegToken(ctx context.Context, ownerKind string, ownerID, by int64) (string, error) { plain, err := newToken("bgrr_") if err != nil { return "", err } exp := time.Now().Add(24 * time.Hour).UTC().Format(time.RFC3339) _, err = s.db.ExecContext(ctx, `INSERT INTO runner_reg_tokens (owner_kind, owner_id, token_hash, created_by, expires_at) VALUES (?, ?, ?, ?, ?)`, ownerKind, ownerID, hashToken(plain), by, exp) return plain, err } // RegisterRunner wisselt een registratietoken in voor een runner en zijn // eigen runner-token (bgr_). Alleen de hash wordt bewaard. func (s *Store) RegisterRunner(ctx context.Context, regToken, name, version string) (Runner, string, error) { tx, err := s.db.BeginTx(ctx, nil) if err != nil { return Runner{}, "", err } defer func() { _ = tx.Rollback() }() var id, ownerID, by int64 var kind, exp string 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) if err != nil || parseTime(exp).Before(time.Now()) { return Runner{}, "", ErrRegToken } if _, err := tx.ExecContext(ctx, `UPDATE runner_reg_tokens SET used = 1 WHERE id = ?`, id); err != nil { return Runner{}, "", err } plain, err := newToken("bgr_") if err != nil { return Runner{}, "", err } name = strings.TrimSpace(name) if name == "" { name = "runner" } if len(name) > 80 { name = name[:80] } at := now() res, err := tx.ExecContext(ctx, `INSERT INTO runners (owner_kind, owner_id, name, token_hash, created_by, created_at, last_seen, version) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, kind, ownerID, name, hashToken(plain), by, at, at, version) if err != nil { return Runner{}, "", err } rid, _ := res.LastInsertId() if err := tx.Commit(); err != nil { return Runner{}, "", err } return Runner{ID: rid, OwnerKind: kind, OwnerID: ownerID, Name: name, CreatedAt: parseTime(at), LastSeen: parseTime(at), Version: version}, plain, nil } const runnerCols = `id, owner_kind, owner_id, name, created_at, last_seen, version, revoked, paused, draining` func scanRunner(sc interface{ Scan(...any) error }) (Runner, error) { var r Runner var created, seen string var revoked, paused, draining int if err := sc.Scan(&r.ID, &r.OwnerKind, &r.OwnerID, &r.Name, &created, &seen, &r.Version, &revoked, &paused, &draining); err != nil { return Runner{}, err } r.CreatedAt, r.LastSeen, r.Revoked, r.Paused, r.Draining = parseTime(created), parseTime(seen), revoked == 1, paused == 1, draining == 1 return r, nil } // RunnerByToken geeft de runner bij een bgr_-token. Ingetrokken telt niet. func (s *Store) RunnerByToken(ctx context.Context, token string) (Runner, error) { if !strings.HasPrefix(token, "bgr_") { return Runner{}, errNotFound } r, err := scanRunner(s.db.QueryRowContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE token_hash = ? AND revoked = 0`, hashToken(token))) if errors.Is(err, sql.ErrNoRows) { return Runner{}, errNotFound } return r, err } // RunnerByID geeft één runner. func (s *Store) RunnerByID(ctx context.Context, id int64) (Runner, error) { r, err := scanRunner(s.db.QueryRowContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE id = ?`, id)) if errors.Is(err, sql.ErrNoRows) { return Runner{}, errNotFound } return r, err } // TouchRunner is de heartbeat. func (s *Store) TouchRunner(ctx context.Context, id int64, version string) error { _, err := s.db.ExecContext(ctx, `UPDATE runners SET last_seen = ?, version = CASE WHEN ? = '' THEN version ELSE ? END WHERE id = ?`, now(), version, version, id) return err } // SetRunnerDraining slaat de lokale pauze van de runner op (uit de heartbeat). func (s *Store) SetRunnerDraining(ctx context.Context, id int64, draining bool) error { v := 0 if draining { v = 1 } _, err := s.db.ExecContext(ctx, `UPDATE runners SET draining = ? WHERE id = ?`, v, id) return err } // ListRunners geeft de niet-ingetrokken runners van een eigenaar. func (s *Store) ListRunners(ctx context.Context, ownerKind string, ownerID int64) ([]Runner, error) { rows, err := s.db.QueryContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE owner_kind = ? AND owner_id = ? AND revoked = 0 ORDER BY id`, ownerKind, ownerID) if err != nil { return nil, err } defer rows.Close() var out []Runner for rows.Next() { r, err := scanRunner(rows) if err != nil { return nil, err } out = append(out, r) } return out, rows.Err() } // RevokeRunner trekt een runner in; zijn token werkt daarna niet meer. func (s *Store) RevokeRunner(ctx context.Context, ownerKind string, ownerID, id int64) error { res, err := s.db.ExecContext(ctx, `UPDATE runners SET revoked = 1 WHERE id = ? AND owner_kind = ? AND owner_id = ?`, id, ownerKind, ownerID) if err != nil { return err } if n, _ := res.RowsAffected(); n == 0 { return errNotFound } return nil } // UserRunnerPref is own_first of builtin_first. func (s *Store) UserRunnerPref(ctx context.Context, userID int64) string { var p string if err := s.db.QueryRowContext(ctx, `SELECT runner_pref FROM users WHERE id = ?`, userID).Scan(&p); err != nil || p != RunnerPrefOwnFirst { return RunnerPrefBuiltinFirst } return p } // SetUserRunnerPref bewaart de voorkeur. func (s *Store) SetUserRunnerPref(ctx context.Context, userID int64, pref string) error { if pref != RunnerPrefOwnFirst { pref = RunnerPrefBuiltinFirst } _, err := s.db.ExecContext(ctx, `UPDATE users SET runner_pref = ? WHERE id = ?`, pref, userID) return err } // GroupBuiltinFirst: "Probeer BlueGit runner eerst". func (s *Store) GroupBuiltinFirst(ctx context.Context, groupID int64) bool { var v int _ = s.db.QueryRowContext(ctx, `SELECT builtin_first FROM groups WHERE id = ?`, groupID).Scan(&v) return v == 1 } // SetGroupBuiltinFirst zet de groepsinstelling. func (s *Store) SetGroupBuiltinFirst(ctx context.Context, groupID int64, on bool) error { v := 0 if on { v = 1 } _, err := s.db.ExecContext(ctx, `UPDATE groups SET builtin_first = ? WHERE id = ?`, v, groupID) return err } // SetRunnerOptIn: maintainer userID staat zijn account-runners toe voor de groep. func (s *Store) SetRunnerOptIn(ctx context.Context, groupID, userID int64, on bool) error { if on { _, err := s.db.ExecContext(ctx, `INSERT OR IGNORE INTO group_runner_optin (group_id, user_id) VALUES (?, ?)`, groupID, userID) return err } _, err := s.db.ExecContext(ctx, `DELETE FROM group_runner_optin WHERE group_id = ? AND user_id = ?`, groupID, userID) return err } // RunnerOptIns zijn de gebruikers die hun runners voor de groep toestaan. func (s *Store) RunnerOptIns(ctx context.Context, groupID int64) ([]int64, error) { rows, err := s.db.QueryContext(ctx, `SELECT user_id FROM group_runner_optin WHERE group_id = ? ORDER BY user_id`, groupID) if err != nil { return nil, err } defer rows.Close() var out []int64 for rows.Next() { var id int64 if err := rows.Scan(&id); err != nil { return nil, err } out = append(out, id) } return out, rows.Err() } // JobRun is de runner-administratie van één job. type JobRun struct { RunnerID int64 RunnerName string OfferTier int OfferAt time.Time } // JobRun leest de administratie; een lege JobRun als er niets is. func (s *Store) JobRun(ctx context.Context, jobID int64) JobRun { var jr JobRun var at string 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 { return JobRun{} } jr.OfferAt = parseTime(at) return jr } // SetJobOffer zet de huidige trede in de runnervolgorde. func (s *Store) SetJobOffer(ctx context.Context, jobID int64, tier int, at time.Time) error { _, err := s.db.ExecContext(ctx, `INSERT INTO job_runs (job_id, offer_tier, offer_at) VALUES (?, ?, ?) ON CONFLICT(job_id) DO UPDATE SET offer_tier = excluded.offer_tier, offer_at = excluded.offer_at`, jobID, tier, at.UTC().Format(time.RFC3339Nano)) return err } // ClearJobOffer haalt het aanbod weg (bijvoorbeeld bij een retry). func (s *Store) ClearJobOffer(ctx context.Context, jobID int64) error { _, err := s.db.ExecContext(ctx, `UPDATE job_runs SET offer_at = '', offer_tier = 0 WHERE job_id = ?`, jobID) return err } // SetJobRunner noteert wie de job draait. func (s *Store) SetJobRunner(ctx context.Context, jobID, runnerID int64, name string) error { _, err := s.db.ExecContext(ctx, `INSERT INTO job_runs (job_id, runner_id, runner_name) VALUES (?, ?, ?) ON CONFLICT(job_id) DO UPDATE SET runner_id = excluded.runner_id, runner_name = excluded.runner_name`, jobID, runnerID, name) return err } // OfferedJobs zijn wachtende jobs met een actief aanbod. func (s *Store) OfferedJobs(ctx context.Context) ([]Job, map[int64]JobRun, error) { 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`) if err != nil { return nil, nil, err } var out []Job for rows.Next() { j, err := scanJob(rows) if err != nil { rows.Close() return nil, nil, err } out = append(out, j) } rows.Close() runs := map[int64]JobRun{} for _, j := range out { runs[j.ID] = s.JobRun(ctx, j.ID) } return out, runs, nil } // ClaimJob zet een wachtende job op running voor een runner. false als // iemand anders hem al had. func (s *Store) ClaimJob(ctx context.Context, jobID, runnerID int64, name string) (bool, error) { ok, err := s.MarkJobRunning(ctx, jobID) if err != nil || !ok { return false, err } if err := s.SetJobRunner(ctx, jobID, runnerID, name); err != nil { return true, err } _, err = s.db.ExecContext(ctx, `UPDATE job_runs SET offer_at = '' WHERE job_id = ?`, jobID) return true, err } // RemoteJob is een lopende job op een aparte runner. type RemoteJob struct { Job Job RunnerID int64 } // RemoteRunningJobs geeft lopende jobs die een aparte runner heeft. func (s *Store) RemoteRunningJobs(ctx context.Context) ([]RemoteJob, error) { 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`) if err != nil { return nil, err } var out []RemoteJob for rows.Next() { j, err := scanJob(rows) if err != nil { rows.Close() return nil, err } out = append(out, RemoteJob{Job: j}) } rows.Close() for i := range out { out[i].RunnerID = s.JobRun(ctx, out[i].Job.ID).RunnerID } return out, nil } // JobForRunner geeft een job als die bij runnerID hoort (en loopt of net klaar is). func (s *Store) JobForRunner(ctx context.Context, runnerID, jobID int64) (Job, error) { if s.JobRun(ctx, jobID).RunnerID != runnerID || runnerID == 0 { return Job{}, errNotFound } rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID) if err != nil { return Job{}, err } defer rows.Close() if !rows.Next() { return Job{}, errNotFound } return scanJob(rows) } // RunnerRunsRepo zegt of de runner nu een job van de repo draait. func (s *Store) RunnerRunsRepo(ctx context.Context, runnerID, repoID int64) bool { var n int _ = 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) return n > 0 && runnerID > 0 } // UpdateRunner hernoemt en/of pauzeert een runner van deze eigenaar. func (s *Store) UpdateRunner(ctx context.Context, ownerKind string, ownerID, id int64, name *string, paused *bool) (Runner, error) { r, err := s.RunnerByID(ctx, id) if err != nil || r.Revoked || r.OwnerKind != ownerKind || r.OwnerID != ownerID { return Runner{}, errNotFound } if name != nil { n := strings.TrimSpace(*name) if n == "" || len(n) > 80 { return Runner{}, errors.New("runner name must be 1-80 characters") } if _, err := s.db.ExecContext(ctx, `UPDATE runners SET name = ? WHERE id = ?`, n, id); err != nil { return Runner{}, err } } if paused != nil { v := 0 if *paused { v = 1 } if _, err := s.db.ExecContext(ctx, `UPDATE runners SET paused = ? WHERE id = ?`, v, id); err != nil { return Runner{}, err } } return s.RunnerByID(ctx, id) } // RunnerJob is een recente job van een runner. type RunnerJob struct { JobID int64 PipelineID int64 RepoID int64 Name string Status string StartedAt time.Time FinishedAt time.Time } // RunnerJobs geeft de recentste jobs van een runner. func (s *Store) RunnerJobs(ctx context.Context, runnerID int64, limit int) ([]RunnerJob, error) { if limit <= 0 || limit > 100 { limit = 20 } 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, '') 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) if err != nil { return nil, err } defer rows.Close() var out []RunnerJob for rows.Next() { var j RunnerJob var st, fin string if err := rows.Scan(&j.JobID, &j.PipelineID, &j.RepoID, &j.Name, &j.Status, &st, &fin); err != nil { return nil, err } j.StartedAt, j.FinishedAt = parseTime(st), parseTime(fin) out = append(out, j) } return out, rows.Err() }