package store import ( "context" "database/sql" "errors" "strconv" "time" ) // Verlopen handmatige jobs (stale manual). // // Een handmatige job (status manual) verloopt als zijn pipeline stale is: // - superseded: er is een nieuwere pipeline op dezelfde ref (en hetzelfde // merge request) in dezelfde repository. Een pipeline die alleen een // kapotte blue-ci-cd.yml meldt, telt niet als nieuwere pipeline. // - leeftijd: de pipeline wacht alleen nog op handmatige jobs (status // manual) en is ouder dan N dagen. N is een instance-instelling // (standaard 7) die per repository overschreven kan worden; 0 = uit. // // Verlopen is niet destructief: de job gaat naar canceled met een reden en een // logregel; logs en artifacts blijven staan. Jobs die alleen nog op de // verlopen job wachtten (needs), verlopen mee. Niet-handmatige jobs die nog // lopen of in de wachtrij staan, blijven ongemoeid. // DefaultStaleManualDays is de standaard voor de leeftijdsregel. const DefaultStaleManualDays = 7 const staleManualKey = "stale_manual_days" // StaleManualDays geeft de instance-instelling (dagen, 0 = uit). func (s *Store) StaleManualDays(ctx context.Context) (int, error) { var v string err := s.db.QueryRowContext(ctx, `SELECT value FROM instance_settings WHERE key = ?`, staleManualKey).Scan(&v) if errors.Is(err, sql.ErrNoRows) { return DefaultStaleManualDays, nil } if err != nil { return 0, err } n, err := strconv.Atoi(v) if err != nil || n < 0 { return DefaultStaleManualDays, nil } return n, nil } // SetStaleManualDays zet de instance-instelling (0 = uit, max 3650). func (s *Store) SetStaleManualDays(ctx context.Context, days int) error { if days < 0 || days > 3650 { return errors.New("stale manual days out of range") } _, err := s.db.ExecContext(ctx, `INSERT INTO instance_settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`, staleManualKey, strconv.Itoa(days)) return err } // RepoStaleManualDays geeft de eigen instelling van een repository; // -1 = de instance-instelling volgen. func (s *Store) RepoStaleManualDays(ctx context.Context, repoID int64) (int, error) { var n int err := s.db.QueryRowContext(ctx, `SELECT stale_manual_days FROM repos WHERE id = ?`, repoID).Scan(&n) return n, err } // SetRepoStaleManualDays zet de eigen instelling (-1 = volgen, 0 = uit). func (s *Store) SetRepoStaleManualDays(ctx context.Context, repoID int64, days int) error { if days < -1 || days > 3650 { return errors.New("stale manual days out of range") } _, err := s.db.ExecContext(ctx, `UPDATE repos SET stale_manual_days = ? WHERE id = ?`, days, repoID) return err } // ExpiredManual is één pipeline waarvan handmatige jobs verlopen zijn. type ExpiredManual struct { RepoID int64 PipelineID int64 Ref string Jobs int Reason string // superseded of stale } // expirePipelineManual laat de handmatige jobs van één pipeline verlopen // (en de jobs die alleen daarop wachten) en werkt de pipelinestatus bij. func (s *Store) expirePipelineManual(ctx context.Context, pipelineID int64, reason, note string) (int, error) { jobs, err := s.JobsByPipeline(ctx, pipelineID) if err != nil { return 0, err } blocked := manualBlocked(jobs) line := time.Now().UTC().Format(time.RFC3339) + "\t" + note + "\n" n := 0 for i, j := range jobs { if j.Status != "manual" && !(j.Status == "queued" && blocked[i]) { continue } res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'canceled', failure_reason = ?, log = log || ?, finished_at = ? WHERE id = ? AND status = ?`, reason, line, now(), j.ID, j.Status) if err != nil { return n, err } if c, _ := res.RowsAffected(); c == 1 { n++ } } if n > 0 { if _, err := s.RefreshPipelineStatus(ctx, pipelineID); err != nil { return n, err } } return n, nil } const noteSuperseded = "manual job expired (obsolete): a newer pipeline exists for the same ref" func noteStale(days int) string { return "manual job expired (obsolete): the pipeline waited only for manual action for more than " + strconv.Itoa(days) + " days" } // configFailureSQL herkent een pipeline die alleen een kapotte config meldt. const configFailureSQL = `EXISTS (SELECT 1 FROM jobs cj WHERE cj.pipeline_id = n.id AND cj.name = 'blue-ci-cd' AND cj.script = 'exit 1' AND cj.image = 'alpine:3.20' AND cj.position = 0) AND (SELECT COUNT(*) FROM jobs cj WHERE cj.pipeline_id = n.id) = 1` // ExpireSupersededManual laat handmatige jobs verlopen in pipelines op // dezelfde ref (en hetzelfde MR) die ouder zijn dan keep. func (s *Store) ExpireSupersededManual(ctx context.Context, repoID int64, ref string, keep int64) ([]ExpiredManual, error) { rows, err := s.db.QueryContext(ctx, `SELECT DISTINCT p.id, p.ref FROM pipelines p JOIN jobs j ON j.pipeline_id = p.id JOIN pipelines n ON n.id = ? WHERE p.repo_id = ? AND p.ref = ? AND p.id < n.id AND p.mr_id = n.mr_id AND j.status = 'manual' AND NOT (`+configFailureSQL+`)`, keep, repoID, ref) if err != nil { return nil, err } return s.expireRows(ctx, rows, repoID, "superseded", ReasonSuperseded, noteSuperseded) } func (s *Store) expireRows(ctx context.Context, rows *sql.Rows, repoID int64, kind, reason, note string) ([]ExpiredManual, error) { type item struct { id int64 ref string } var items []item for rows.Next() { var it item if err := rows.Scan(&it.id, &it.ref); err != nil { rows.Close() return nil, err } items = append(items, it) } err := rows.Err() rows.Close() if err != nil { return nil, err } var out []ExpiredManual for _, it := range items { n, err := s.expirePipelineManual(ctx, it.id, reason, note) if err != nil { return out, err } if n > 0 { out = append(out, ExpiredManual{RepoID: repoID, PipelineID: it.id, Ref: it.ref, Jobs: n, Reason: kind}) } } return out, nil } // SweepStaleManual loopt alle repositories langs: eerst superseded // (voor oude pipelines van vóór deze functie), dan de leeftijdsregel. func (s *Store) SweepStaleManual(ctx context.Context, at time.Time) ([]ExpiredManual, error) { def, err := s.StaleManualDays(ctx) if err != nil { return nil, err } // Superseded: pipelines met een handmatige job en een nieuwere pipeline // op dezelfde ref en hetzelfde MR. rows, err := s.db.QueryContext(ctx, `SELECT DISTINCT p.repo_id, p.id, p.ref FROM pipelines p JOIN jobs j ON j.pipeline_id = p.id WHERE j.status = 'manual' AND EXISTS ( SELECT 1 FROM pipelines n WHERE n.repo_id = p.repo_id AND n.ref = p.ref AND n.mr_id = p.mr_id AND n.id > p.id AND NOT (`+configFailureSQL+`)) ORDER BY p.id`) if err != nil { return nil, err } type item struct { repo, id int64 ref string } var sup []item for rows.Next() { var it item if err := rows.Scan(&it.repo, &it.id, &it.ref); err != nil { rows.Close() return nil, err } sup = append(sup, it) } err = rows.Err() rows.Close() if err != nil { return nil, err } var out []ExpiredManual for _, it := range sup { n, err := s.expirePipelineManual(ctx, it.id, ReasonSuperseded, noteSuperseded) if err != nil { return out, err } if n > 0 { out = append(out, ExpiredManual{RepoID: it.repo, PipelineID: it.id, Ref: it.ref, Jobs: n, Reason: "superseded"}) } } // Leeftijd: pipelines die alleen nog op handmatige actie wachten. rows, err = s.db.QueryContext(ctx, `SELECT p.repo_id, p.id, p.ref, p.created_at, r.stale_manual_days FROM pipelines p JOIN repos r ON r.id = p.repo_id WHERE p.status = 'manual' ORDER BY p.id`) if err != nil { return out, err } type aged struct { item days int } var old []aged for rows.Next() { var it item var created string var days int if err := rows.Scan(&it.repo, &it.id, &it.ref, &created, &days); err != nil { rows.Close() return out, err } if days < 0 { days = def } if days == 0 { continue } t := parseTime(created) if t.IsZero() || at.Sub(t) < time.Duration(days)*24*time.Hour { continue } old = append(old, aged{it, days}) } err = rows.Err() rows.Close() if err != nil { return out, err } for _, it := range old { n, err := s.expirePipelineManual(ctx, it.id, ReasonStaleManual, noteStale(it.days)) if err != nil { return out, err } if n > 0 { out = append(out, ExpiredManual{RepoID: it.repo, PipelineID: it.id, Ref: it.ref, Jobs: n, Reason: "stale"}) } } return out, nil }