BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

flow.go 55.6 KiB Download Raw
1package store
2
3import (
4 "context"
5 "database/sql"
6 "encoding/json"
7 "errors"
8 "strings"
9 "time"
10
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/names"
13)
14
15// Webhook is een uitgaande melding.
16type Webhook struct {
17 ID int64
18 ScopeKind string
19 ScopeID int64
20 Name string
21 Preset string
22 URLTemplate string
23 Headers map[string]string
24 BodyTemplate string
25 Events []string
26 BranchFilter string
27 Active bool
28 Method string
29 Fields string
30}
31
32// CreateWebhook bewaart een webhook.
33func (s *Store) CreateWebhook(ctx context.Context, w Webhook) (int64, error) {
34 if w.Headers == nil {
35 w.Headers = map[string]string{}
36 }
37 if w.Preset == "" {
38 w.Preset = "generic"
39 }
40 if w.Method == "" {
41 w.Method = "POST"
42 }
43 res, err := s.db.ExecContext(ctx, `INSERT INTO webhooks (scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method, fields_json, created_at)
44 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`,
45 w.ScopeKind, w.ScopeID, w.Name, w.Preset, w.URLTemplate, mustJSON(w.Headers), w.BodyTemplate, mustJSON(w.Events), w.BranchFilter, w.Method, w.Fields, now())
46 if err != nil {
47 return 0, err
48 }
49 return res.LastInsertId()
50}
51
52// ListWebhooks geeft de webhooks van een repository of groep.
53func (s *Store) ListWebhooks(ctx context.Context, scopeKind string, scopeID int64) ([]Webhook, error) {
54 rows, err := s.db.QueryContext(ctx, `SELECT `+webhookCols+` FROM webhooks WHERE scope_kind = ? AND scope_id = ? ORDER BY id`, scopeKind, scopeID)
55 if err != nil {
56 return nil, err
57 }
58 defer rows.Close()
59 var out []Webhook
60 for rows.Next() {
61 w, err := scanWebhook(rows)
62 if err != nil {
63 return nil, err
64 }
65 out = append(out, w)
66 }
67 return out, rows.Err()
68}
69
70const webhookCols = `id, scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method, fields_json`
71
72// Webhook leest één webhook in dit scope.
73func (s *Store) Webhook(ctx context.Context, scopeKind string, scopeID, id int64) (Webhook, error) {
74 w, err := scanWebhook(s.db.QueryRowContext(ctx, `SELECT `+webhookCols+` FROM webhooks WHERE id = ? AND scope_kind = ? AND scope_id = ?`, id, scopeKind, scopeID))
75 if errors.Is(err, sql.ErrNoRows) {
76 return Webhook{}, errNotFound
77 }
78 return w, err
79}
80
81// UpdateWebhook werkt een webhook in dit scope bij.
82func (s *Store) UpdateWebhook(ctx context.Context, w Webhook) error {
83 if w.Headers == nil {
84 w.Headers = map[string]string{}
85 }
86 if w.Preset == "" {
87 w.Preset = "generic"
88 }
89 if w.Method == "" {
90 w.Method = "POST"
91 }
92 res, err := s.db.ExecContext(ctx, `UPDATE webhooks SET name = ?, preset = ?, url_template = ?, headers_json = ?, body_template = ?, events_json = ?, branch_filter = ?, method = ?, fields_json = ? WHERE id = ? AND scope_kind = ? AND scope_id = ?`,
93 w.Name, w.Preset, w.URLTemplate, mustJSON(w.Headers), w.BodyTemplate, mustJSON(w.Events), w.BranchFilter, w.Method, w.Fields, w.ID, w.ScopeKind, w.ScopeID)
94 if err != nil {
95 return err
96 }
97 n, _ := res.RowsAffected()
98 if n == 0 {
99 return errNotFound
100 }
101 return nil
102}
103
104func scanWebhook(row interface{ Scan(...any) error }) (Webhook, error) {
105 var w Webhook
106 var headers, events string
107 var active int
108 if err := row.Scan(&w.ID, &w.ScopeKind, &w.ScopeID, &w.Name, &w.Preset, &w.URLTemplate, &headers, &w.BodyTemplate, &events, &w.BranchFilter, &active, &w.Method, &w.Fields); err != nil {
109 return Webhook{}, err
110 }
111 w.Active = active == 1
112 _ = json.Unmarshal([]byte(headers), &w.Headers)
113 _ = json.Unmarshal([]byte(events), &w.Events)
114 if w.Headers == nil {
115 w.Headers = map[string]string{}
116 }
117 return w, nil
118}
119
120// DeleteWebhook verwijdert een webhook in dit scope.
121func (s *Store) DeleteWebhook(ctx context.Context, scopeKind string, scopeID, id int64) error {
122 res, err := s.db.ExecContext(ctx, `DELETE FROM webhooks WHERE id = ? AND scope_kind = ? AND scope_id = ?`, id, scopeKind, scopeID)
123 if err != nil {
124 return err
125 }
126 n, _ := res.RowsAffected()
127 if n == 0 {
128 return errNotFound
129 }
130 return nil
131}
132
133// AddDelivery bewaart het resultaat van een poging.
134func (s *Store) AddDelivery(ctx context.Context, webhookID int64, eventType string, status int, errText string) error {
135 _, err := s.db.ExecContext(ctx, `INSERT INTO webhook_deliveries (webhook_id, event_type, status_code, error, created_at) VALUES (?, ?, ?, ?, ?)`,
136 webhookID, eventType, status, trim(errText, 500), now())
137 return err
138}
139
140// Delivery is één poging.
141type Delivery struct {
142 EventType string
143 StatusCode int
144 Error string
145 CreatedAt time.Time
146}
147
148// RecentDeliveries geeft de laatste pogingen.
149func (s *Store) RecentDeliveries(ctx context.Context, webhookID int64) ([]Delivery, error) {
150 rows, err := s.db.QueryContext(ctx, `SELECT event_type, status_code, error, created_at FROM webhook_deliveries WHERE webhook_id = ? ORDER BY id DESC LIMIT 8`, webhookID)
151 if err != nil {
152 return nil, err
153 }
154 defer rows.Close()
155 var out []Delivery
156 for rows.Next() {
157 var d Delivery
158 var created string
159 if err := rows.Scan(&d.EventType, &d.StatusCode, &d.Error, &created); err != nil {
160 return nil, err
161 }
162 d.CreatedAt = parseTime(created)
163 out = append(out, d)
164 }
165 return out, rows.Err()
166}
167
168// MergeRequest is een basisverzoek om een branch samen te voegen.
169type MergeRequest struct {
170 ID int64
171 RepoID int64
172 Number int64
173 Title string
174 Description string
175 SourceBranch string
176 TargetBranch string
177 AuthorID int64
178 Author string
179 Status string
180 CreatedAt time.Time
181 UpdatedAt time.Time
182 Draft bool
183 Labels string
184 RemoveSourceBranch bool
185 Squash bool
186 SquashMessage string
187}
188
189// CreateMergeRequest nummert per repository.
190func (s *Store) CreateMergeRequest(ctx context.Context, repoID, authorID int64, title, description, source, target string) (MergeRequest, error) {
191 title = trim(title, 200)
192 if title == "" {
193 return MergeRequest{}, i18n.E("err.mrTitle")
194 }
195 tx, err := s.db.BeginTx(ctx, nil)
196 if err != nil {
197 return MergeRequest{}, err
198 }
199 defer func() { _ = tx.Rollback() }()
200 var n int64
201 if err := tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(number), 0) FROM merge_requests WHERE repo_id = ?`, repoID).Scan(&n); err != nil {
202 return MergeRequest{}, err
203 }
204 ts := now()
205 res, err := tx.ExecContext(ctx, `INSERT INTO merge_requests (repo_id, number, title, description, source_branch, target_branch, author_id, status, created_at, updated_at)
206 VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`, repoID, n+1, title, description, source, target, authorID, ts, ts)
207 if err != nil {
208 return MergeRequest{}, err
209 }
210 id, _ := res.LastInsertId()
211 if err := tx.Commit(); err != nil {
212 return MergeRequest{}, err
213 }
214 return s.MergeRequest(ctx, repoID, id)
215}
216
217// MergeRequest leest op interne id.
218func (s *Store) MergeRequest(ctx context.Context, repoID, id int64) (MergeRequest, error) {
219 row := s.db.QueryRowContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.id = ?`, repoID, id)
220 return scanMR(row)
221}
222
223// MergeRequestByNumber leest !nummer.
224func (s *Store) MergeRequestByNumber(ctx context.Context, repoID, number int64) (MergeRequest, error) {
225 row := s.db.QueryRowContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.number = ?`, repoID, number)
226 return scanMR(row)
227}
228
229const mrSelect = `SELECT m.id, m.repo_id, m.number, m.title, m.description, m.source_branch, m.target_branch, m.author_id, u.username, m.status, m.created_at, m.updated_at, m.draft, m.labels, m.remove_source_branch, m.squash, m.squash_message
230FROM merge_requests m JOIN users u ON u.id = m.author_id`
231
232func scanMR(row *sql.Row) (MergeRequest, error) {
233 var m MergeRequest
234 var created, updated string
235 var draft, remove, squash int
236 if err := row.Scan(&m.ID, &m.RepoID, &m.Number, &m.Title, &m.Description, &m.SourceBranch, &m.TargetBranch, &m.AuthorID, &m.Author, &m.Status, &created, &updated, &draft, &m.Labels, &remove, &squash, &m.SquashMessage); err != nil {
237 if errors.Is(err, sql.ErrNoRows) {
238 return MergeRequest{}, errNotFound
239 }
240 return MergeRequest{}, err
241 }
242 applyMR(&m, created, updated, draft, remove, squash)
243 return m, nil
244}
245
246func applyMR(m *MergeRequest, created, updated string, draft, remove, squash int) {
247 m.CreatedAt = parseTime(created)
248 m.UpdatedAt = parseTime(updated)
249 m.Draft = draft == 1
250 m.RemoveSourceBranch = remove == 1
251 m.Squash = squash == 1
252}
253
254// ListMergeRequests geeft verzoeken, open eerst.
255func (s *Store) ListMergeRequests(ctx context.Context, repoID int64) ([]MergeRequest, error) {
256 rows, err := s.db.QueryContext(ctx, mrSelect+` WHERE m.repo_id = ? ORDER BY CASE m.status WHEN 'open' THEN 0 ELSE 1 END, m.number DESC`, repoID)
257 if err != nil {
258 return nil, err
259 }
260 defer rows.Close()
261 return scanMRList(rows)
262}
263
264// SetMergeRequestStatus zet open, merged of closed.
265func (s *Store) SetMergeRequestStatus(ctx context.Context, id int64, status string) error {
266 _, err := s.db.ExecContext(ctx, `UPDATE merge_requests SET status = ?, updated_at = ? WHERE id = ?`, status, now(), id)
267 return err
268}
269
270// OpenMergeRequestsBySource geeft open verzoeken waarvan de bronbranch deze is.
271func (s *Store) OpenMergeRequestsBySource(ctx context.Context, repoID int64, branch string) ([]MergeRequest, error) {
272 return s.openMergeRequests(ctx, repoID, "source_branch", branch)
273}
274
275// OpenMergeRequestsByTarget geeft open verzoeken waarvan de doelbranch deze is.
276func (s *Store) OpenMergeRequestsByTarget(ctx context.Context, repoID int64, branch string) ([]MergeRequest, error) {
277 return s.openMergeRequests(ctx, repoID, "target_branch", branch)
278}
279
280func (s *Store) openMergeRequests(ctx context.Context, repoID int64, column, branch string) ([]MergeRequest, error) {
281 if column != "source_branch" && column != "target_branch" {
282 return nil, errNotFound
283 }
284 rows, err := s.db.QueryContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.`+column+` = ? AND m.status = 'open' ORDER BY m.number`, repoID, branch)
285 if err != nil {
286 return nil, err
287 }
288 defer rows.Close()
289 return scanMRList(rows)
290}
291
292func scanMRList(rows *sql.Rows) ([]MergeRequest, error) {
293 var out []MergeRequest
294 for rows.Next() {
295 var m MergeRequest
296 var created, updated string
297 var draft, remove, squash int
298 if err := rows.Scan(&m.ID, &m.RepoID, &m.Number, &m.Title, &m.Description, &m.SourceBranch, &m.TargetBranch, &m.AuthorID, &m.Author, &m.Status, &created, &updated, &draft, &m.Labels, &remove, &squash, &m.SquashMessage); err != nil {
299 return nil, err
300 }
301 applyMR(&m, created, updated, draft, remove, squash)
302 out = append(out, m)
303 }
304 return out, rows.Err()
305}
306
307// AttachPipelineMR koppelt een pipeline aan een merge request.
308func (s *Store) AttachPipelineMR(ctx context.Context, pipelineID, mrID int64) error {
309 _, err := s.db.ExecContext(ctx, `UPDATE pipelines SET mr_id = ? WHERE id = ?`, mrID, pipelineID)
310 return err
311}
312
313// LatestMergePipeline is de nieuwste pipeline van deze merge request.
314func (s *Store) LatestMergePipeline(ctx context.Context, repoID, mrID int64) (Pipeline, error) {
315 p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND mr_id = ? ORDER BY id DESC LIMIT 1`, repoID, mrID))
316 if errors.Is(err, sql.ErrNoRows) {
317 return Pipeline{}, errNotFound
318 }
319 return p, err
320}
321
322// PipelineBlocksMerge zegt of deze jobs een merge tegenhouden.
323// Een lege tekst betekent dat elke job klaar is en geen harde fout heeft.
324// allow_failure mag mislukt zijn, maar moet wel af zijn.
325func PipelineBlocksMerge(jobs []Job) string {
326 if len(jobs) == 0 {
327 return "waiting"
328 }
329 hard, open := false, false
330 for _, j := range jobs {
331 switch j.Status {
332 case "success", "skipped":
333 case "failed", "canceled":
334 if !j.AllowFailure {
335 hard = true
336 }
337 default:
338 open = true
339 }
340 }
341 if open {
342 return "running"
343 }
344 if hard {
345 return "failed"
346 }
347 return ""
348}
349
350// NewJob is een job die nog de wachtrij in moet.
351type NewJob struct {
352 Name string
353 Stage string
354 Position int
355 Image string
356 Before string
357 Script string
358 After string
359 Needs []string
360 Optional []string
361 NeedsSet bool
362 Variables map[string]string
363 ArtifactPaths []string
364 ArtifactExpire time.Duration
365 AllowFailure bool
366 When string
367 Timeout time.Duration
368 Tags []string
369 CachePaths []string
370 CacheKey string
371 ResourceGroup string
372 RetryMax int
373 RetryWhen []string
374 Services []Service
375 Environment string
376 EnvironmentURL string
377 Interruptible bool
378 DoNotInterrupt bool
379}
380
381// Service is een sidecar die de runner naast de job start.
382type Service struct {
383 Name string `json:"name"`
384 Alias string `json:"alias"`
385 Command []string `json:"command,omitempty"`
386 Entrypoint []string `json:"entrypoint,omitempty"`
387 Variables map[string]string `json:"variables,omitempty"`
388}
389
390// Pipeline is een draai van blue-ci-cd.yml.
391type Pipeline struct {
392 ID int64
393 RepoID int64
394 CommitSHA string
395 Ref string
396 Status string
397 Source string
398 Actor string
399 CommitTitle string
400 CreatedAt time.Time
401 StartedAt time.Time
402 FinishedAt time.Time
403 MRID int64
404 // TargetSHA is de doelcommit van een merge-request-pipeline.
405 // Leeg zolang de rij nog niet aan een merge request hangt.
406 // Een nieuwe doelcommit start een nieuwe pipeline.
407 TargetSHA string
408}
409
410// Job is één container in een pipeline.
411type Job struct {
412 ID int64
413 PipelineID int64
414 RepoID int64
415 Name string
416 Stage string
417 Position int
418 Status string
419 Image string
420 Before string
421 Script string
422 After string
423 Needs []string
424 Optional []string
425 NeedsSet bool
426 Variables map[string]string
427 ArtifactPaths []string
428 ArtifactExpire time.Duration
429 AllowFailure bool
430 When string
431 Timeout time.Duration
432 Tags []string
433 CachePaths []string
434 CacheKey string
435 ResourceGroup string
436 RetryMax int
437 RetryWhen []string
438 Attempt int
439 Services []Service
440 Environment string
441 EnvironmentURL string
442 Interruptible bool
443 DoNotInterrupt bool
444 // Reason zegt waarom een job failed of canceled is: job_execution_timeout,
445 // script_failure, runner_system_failure, canceled_by_user,
446 // canceled_by_newer_pipeline. Leeg bij succes of onbekend (oude jobs).
447 Reason string
448 Log string
449 CommitSHA string
450 Ref string
451 StartedAt time.Time
452 FinishedAt time.Time
453}
454
455// RecordConfigFailure bewaart een pipeline die niet kon starten.
456// Dezelfde repo, ref, sha, bron, merge request en doel-sha levert de
457// bestaande pipeline terug. Een kapotte push die al bestaat wordt aan
458// de merge request gekoppeld in plaats van een tweede mislukte rij.
459func (s *Store) RecordConfigFailure(ctx context.Context, repoID int64, sha, ref, source, message string, mrID int64, targetSHA string) (int64, bool, error) {
460 if source == "" {
461 source = "push"
462 }
463 tx, err := s.db.BeginTx(ctx, nil)
464 if err != nil {
465 return 0, false, err
466 }
467 defer func() { _ = tx.Rollback() }()
468 if id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA); err != nil {
469 return 0, false, err
470 } else if ok {
471 return finishExisting(ctx, tx, id)
472 }
473 if source == "push" && mrID == 0 {
474 if id, ok, err := newestPush(ctx, tx, repoID, sha, ref); err != nil {
475 return 0, false, err
476 } else if ok {
477 return finishExisting(ctx, tx, id)
478 }
479 }
480 if mrID != 0 {
481 if id, ok, err := configFailurePush(ctx, tx, repoID, sha, ref, mrID, targetSHA); err != nil {
482 return 0, false, err
483 } else if ok {
484 if err := bindPipelineMR(ctx, tx, id, mrID, targetSHA); err != nil {
485 return 0, false, err
486 }
487 return finishExisting(ctx, tx, id)
488 }
489 }
490 ts := now()
491 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, created_at, finished_at, mr_id, target_sha)
492 SELECT ?, ?, ?, 'failed', ?, ?, ?, ?, ?
493 WHERE NOT EXISTS (
494 SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = ? AND mr_id = ? AND target_sha = ?
495 )`, repoID, sha, ref, source, ts, ts, mrID, targetSHA, repoID, sha, ref, source, mrID, targetSHA)
496 if err != nil {
497 return 0, false, err
498 }
499 if n, _ := res.RowsAffected(); n == 0 {
500 id, err := pipelineKeyID(ctx, tx, repoID, sha, ref, source, mrID, targetSHA)
501 if err != nil {
502 return 0, false, err
503 }
504 return finishExisting(ctx, tx, id)
505 }
506 id, _ := res.LastInsertId()
507 _, err = tx.ExecContext(ctx, `INSERT INTO jobs (pipeline_id, repo_id, name, stage, position, status, image, script, needs_json, needs_set, variables_json, artifact_paths, artifact_expire_seconds, allow_failure, log, finished_at)
508 VALUES (?, ?, 'blue-ci-cd', 'test', 0, 'failed', 'alpine:3.20', 'exit 1', '[]', 0, '{}', '[]', 0, 0, ?, ?)`, id, repoID, message, ts)
509 if err != nil {
510 return 0, false, err
511 }
512 if err := tx.Commit(); err != nil {
513 return 0, false, err
514 }
515 return id, true, nil
516}
517
518// CreatePipeline maakt een pipeline met jobs in de wachtrij.
519// Elke aanroep voegt een rij toe. Starten via een push of merge request
520// gaat via OpenPipeline, zodat een dubbele hook dezelfde run teruggeeft.
521func (s *Store) CreatePipeline(ctx context.Context, repoID int64, sha, ref, source, actor, title string, jobs []NewJob) (int64, error) {
522 tx, err := s.db.BeginTx(ctx, nil)
523 if err != nil {
524 return 0, err
525 }
526 defer func() { _ = tx.Rollback() }()
527 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, actor, commit_title, created_at) VALUES (?, ?, ?, 'queued', ?, ?, ?, ?)`, repoID, sha, ref, source, actor, title, now())
528 if err != nil {
529 return 0, err
530 }
531 id, _ := res.LastInsertId()
532 if err := insertPipelineJobs(ctx, tx, id, repoID, jobs); err != nil {
533 return 0, err
534 }
535 if err := tx.Commit(); err != nil {
536 return 0, err
537 }
538 return id, nil
539}
540
541// OpenPipeline maakt een pipeline, of geeft de bestaande terug.
542// De sleutel is repo, ref, sha, bron, merge request en doel-sha.
543// Een push voor dezelfde sha blijft één rij, ook nadat een merge request
544// hem heeft gekoppeld. Kiezen push en merge request dezelfde jobs, dan
545// koppelt deze aanroep de push-rij en maakt hij geen tweede pipeline.
546// Een andere jobset of een nieuwe doel-sha start wel een eigen rij.
547// created is false wanneer een eerdere trigger de run al had.
548func (s *Store) OpenPipeline(ctx context.Context, repoID int64, sha, ref, source, actor, title, targetSHA string, mrID int64, jobs []NewJob) (int64, bool, error) {
549 if source == "" {
550 source = "push"
551 }
552 tx, err := s.db.BeginTx(ctx, nil)
553 if err != nil {
554 return 0, false, err
555 }
556 defer func() { _ = tx.Rollback() }()
557 if id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA); err != nil {
558 return 0, false, err
559 } else if ok {
560 return finishExisting(ctx, tx, id)
561 }
562 if source == "push" && mrID == 0 {
563 if id, ok, err := newestPush(ctx, tx, repoID, sha, ref); err != nil {
564 return 0, false, err
565 } else if ok {
566 return finishExisting(ctx, tx, id)
567 }
568 }
569 if mrID != 0 {
570 if id, ok, err := claimMatchingPush(ctx, tx, repoID, sha, ref, mrID, targetSHA, jobs); err != nil {
571 return 0, false, err
572 } else if ok {
573 return finishExisting(ctx, tx, id)
574 }
575 }
576 notExists := `SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = ? AND mr_id = ? AND target_sha = ?`
577 args := []any{repoID, sha, ref, source, actor, title, now(), mrID, targetSHA, repoID, sha, ref, source, mrID, targetSHA}
578 if source == "push" && mrID == 0 {
579 notExists = `SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = 'push'`
580 args = []any{repoID, sha, ref, source, actor, title, now(), mrID, targetSHA, repoID, sha, ref}
581 }
582 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, actor, commit_title, created_at, mr_id, target_sha)
583 SELECT ?, ?, ?, 'queued', ?, ?, ?, ?, ?, ?
584 WHERE NOT EXISTS (`+notExists+`)`, args...)
585 if err != nil {
586 return 0, false, err
587 }
588 if n, _ := res.RowsAffected(); n == 0 {
589 id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA)
590 if err != nil {
591 return 0, false, err
592 }
593 if !ok && source == "push" && mrID == 0 {
594 id, ok, err = newestPush(ctx, tx, repoID, sha, ref)
595 if err != nil {
596 return 0, false, err
597 }
598 }
599 if !ok {
600 return 0, false, errors.New("pipeline ontbreekt na een lege insert")
601 }
602 return finishExisting(ctx, tx, id)
603 }
604 id, _ := res.LastInsertId()
605 if err := insertPipelineJobs(ctx, tx, id, repoID, jobs); err != nil {
606 return 0, false, err
607 }
608 if err := tx.Commit(); err != nil {
609 return 0, false, err
610 }
611 return id, true, nil
612}
613
614func finishExisting(ctx context.Context, tx *sql.Tx, id int64) (int64, bool, error) {
615 if err := tx.Commit(); err != nil {
616 return 0, false, err
617 }
618 return id, false, nil
619}
620
621func existingPipeline(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref, source string, mrID int64, targetSHA string) (int64, bool, error) {
622 id, err := pipelineKeyID(ctx, tx, repoID, sha, ref, source, mrID, targetSHA)
623 if errors.Is(err, sql.ErrNoRows) {
624 return 0, false, nil
625 }
626 if err != nil {
627 return 0, false, err
628 }
629 return id, true, nil
630}
631
632func pipelineKeyID(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref, source string, mrID int64, targetSHA string) (int64, error) {
633 var id int64
634 err := tx.QueryRowContext(ctx, `SELECT id FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = ? AND mr_id = ? AND target_sha = ? ORDER BY id LIMIT 1`,
635 repoID, sha, ref, source, mrID, targetSHA).Scan(&id)
636 return id, err
637}
638
639func newestPush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string) (int64, bool, error) {
640 var id int64
641 err := tx.QueryRowContext(ctx, `SELECT id FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = 'push' ORDER BY id DESC LIMIT 1`,
642 repoID, sha, ref).Scan(&id)
643 if errors.Is(err, sql.ErrNoRows) {
644 return 0, false, nil
645 }
646 if err != nil {
647 return 0, false, err
648 }
649 return id, true, nil
650}
651
652// configFailurePush zoekt een mislukte push die alleen de kapotte yaml bewaart.
653func configFailurePush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string, mrID int64, targetSHA string) (int64, bool, error) {
654 var id int64
655 err := tx.QueryRowContext(ctx, `SELECT p.id FROM pipelines p
656 WHERE p.repo_id = ? AND p.commit_sha = ? AND p.ref = ? AND p.source = 'push' AND p.status = 'failed'
657 AND (p.mr_id = 0 OR p.mr_id = ?) AND (p.target_sha = '' OR p.target_sha = ?)
658 AND EXISTS (SELECT 1 FROM jobs j WHERE j.pipeline_id = p.id AND j.name = 'blue-ci-cd')
659 ORDER BY p.id DESC LIMIT 1`, repoID, sha, ref, mrID, targetSHA).Scan(&id)
660 if errors.Is(err, sql.ErrNoRows) {
661 return 0, false, nil
662 }
663 if err != nil {
664 return 0, false, err
665 }
666 return id, true, nil
667}
668
669type pushCandidate struct {
670 id int64
671 mrID int64
672 target string
673}
674
675// claimMatchingPush koppelt een push-pipeline met dezelfde jobs aan de merge request.
676func claimMatchingPush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string, mrID int64, targetSHA string, jobs []NewJob) (int64, bool, error) {
677 rows, err := tx.QueryContext(ctx, `SELECT id, mr_id, target_sha FROM pipelines
678 WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = 'push'
679 AND (mr_id = 0 OR mr_id = ?) AND (target_sha = '' OR target_sha = ?)
680 ORDER BY id DESC`, repoID, sha, ref, mrID, targetSHA)
681 if err != nil {
682 return 0, false, err
683 }
684 var cands []pushCandidate
685 for rows.Next() {
686 var c pushCandidate
687 if err := rows.Scan(&c.id, &c.mrID, &c.target); err != nil {
688 rows.Close()
689 return 0, false, err
690 }
691 cands = append(cands, c)
692 }
693 if err := rows.Err(); err != nil {
694 rows.Close()
695 return 0, false, err
696 }
697 rows.Close()
698 for _, c := range cands {
699 if c.mrID == mrID && c.target == targetSHA {
700 return c.id, true, nil
701 }
702 got, err := loadJobSigs(ctx, tx, c.id)
703 if err != nil {
704 return 0, false, err
705 }
706 if !sameJobSigs(got, jobs) {
707 continue
708 }
709 if err := bindPipelineMR(ctx, tx, c.id, mrID, targetSHA); err != nil {
710 return 0, false, err
711 }
712 return c.id, true, nil
713 }
714 return 0, false, nil
715}
716
717func bindPipelineMR(ctx context.Context, tx *sql.Tx, id, mrID int64, targetSHA string) error {
718 _, err := tx.ExecContext(ctx, `UPDATE pipelines SET mr_id = ?, target_sha = ? WHERE id = ?`, mrID, targetSHA, id)
719 return err
720}
721
722type jobSig struct {
723 name, stage, image, script, when string
724 allow bool
725}
726
727func loadJobSigs(ctx context.Context, tx *sql.Tx, pipelineID int64) ([]jobSig, error) {
728 rows, err := tx.QueryContext(ctx, `SELECT name, stage, image, script, when_mode, allow_failure FROM jobs WHERE pipeline_id = ? ORDER BY position, id`, pipelineID)
729 if err != nil {
730 return nil, err
731 }
732 defer rows.Close()
733 var out []jobSig
734 for rows.Next() {
735 var s jobSig
736 var allow int
737 if err := rows.Scan(&s.name, &s.stage, &s.image, &s.script, &s.when, &allow); err != nil {
738 return nil, err
739 }
740 s.allow = allow == 1
741 out = append(out, s)
742 }
743 return out, rows.Err()
744}
745
746func sameJobSigs(got []jobSig, jobs []NewJob) bool {
747 if len(got) != len(jobs) {
748 return false
749 }
750 for i, j := range jobs {
751 when := j.When
752 if when == "" {
753 when = "on_success"
754 }
755 g := got[i]
756 if g.name != j.Name || g.stage != j.Stage || g.image != j.Image || g.script != j.Script || g.when != when || g.allow != j.AllowFailure {
757 return false
758 }
759 }
760 return true
761}
762
763func insertPipelineJobs(ctx context.Context, tx *sql.Tx, id, repoID int64, jobs []NewJob) error {
764 for _, j := range jobs {
765 if j.Variables == nil {
766 j.Variables = map[string]string{}
767 }
768 if j.Needs == nil {
769 j.Needs = []string{}
770 }
771 if j.ArtifactPaths == nil {
772 j.ArtifactPaths = []string{}
773 }
774 if j.Optional == nil {
775 j.Optional = []string{}
776 }
777 if j.Tags == nil {
778 j.Tags = []string{}
779 }
780 if j.CachePaths == nil {
781 j.CachePaths = []string{}
782 }
783 if j.When == "" {
784 j.When = "on_success"
785 }
786 if j.RetryWhen == nil {
787 j.RetryWhen = []string{}
788 }
789 if j.Services == nil {
790 j.Services = []Service{}
791 }
792 status := "queued"
793 if j.When == "manual" {
794 status = "manual"
795 }
796 _, err := tx.ExecContext(ctx, `INSERT INTO jobs (pipeline_id, repo_id, name, stage, position, status, image, script, needs_json, needs_set, variables_json, artifact_paths, artifact_expire_seconds, allow_failure, log, before_script, after_script, when_mode, timeout_seconds, tags_json, cache_paths, cache_key, resource_group, optional_json, retry_max, retry_when, services_json, environment_name, environment_url, interruptible, do_not_interrupt)
797 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
798 id, repoID, j.Name, j.Stage, j.Position, status, j.Image, j.Script, mustJSON(j.Needs), boolInt(j.NeedsSet), mustJSON(j.Variables), mustJSON(j.ArtifactPaths), int(j.ArtifactExpire/time.Second), boolInt(j.AllowFailure),
799 j.Before, j.After, j.When, int(j.Timeout/time.Second), mustJSON(j.Tags), mustJSON(j.CachePaths), j.CacheKey, j.ResourceGroup, mustJSON(j.Optional),
800 j.RetryMax, mustJSON(j.RetryWhen), mustJSON(j.Services), j.Environment, j.EnvironmentURL, boolInt(j.Interruptible), boolInt(j.DoNotInterrupt))
801 if err != nil {
802 return err
803 }
804 }
805 return nil
806}
807
808// ListPipelines geeft de nieuwste pipelines.
809func (s *Store) ListPipelines(ctx context.Context, repoID int64) ([]Pipeline, error) {
810 rows, err := s.db.QueryContext(ctx, pipelineCols+` WHERE repo_id = ? ORDER BY id DESC LIMIT 50`, repoID)
811 if err != nil {
812 return nil, err
813 }
814 defer rows.Close()
815 var out []Pipeline
816 for rows.Next() {
817 p, err := scanPipeline(rows)
818 if err != nil {
819 return nil, err
820 }
821 out = append(out, p)
822 }
823 return out, rows.Err()
824}
825
826// PipelineFilter beperkt FindPipelines. Lege velden filteren niet.
827// SHA mag een prefix van minstens 7 tekens zijn. Refs is een lijst van
828// volledige refs; MRID neemt ook pipelines van de MR zelf mee.
829type PipelineFilter struct {
830 SHA string
831 Refs []string
832 MRID int64
833}
834
835// FindPipelines geeft de nieuwste pipelines die bij f passen, hooguit 50.
836func (s *Store) FindPipelines(ctx context.Context, repoID int64, f PipelineFilter) ([]Pipeline, error) {
837 q := pipelineCols + ` WHERE repo_id = ?`
838 args := []any{repoID}
839 if f.SHA != "" {
840 q += ` AND commit_sha LIKE ?`
841 args = append(args, strings.ToLower(f.SHA)+"%")
842 }
843 var alt []string
844 if f.MRID != 0 {
845 alt = append(alt, `mr_id = ?`)
846 args = append(args, f.MRID)
847 }
848 for _, ref := range f.Refs {
849 alt = append(alt, `ref = ?`)
850 args = append(args, ref)
851 }
852 if len(alt) > 0 {
853 q += ` AND (` + strings.Join(alt, ` OR `) + `)`
854 }
855 q += ` ORDER BY id DESC LIMIT 50`
856 rows, err := s.db.QueryContext(ctx, q, args...)
857 if err != nil {
858 return nil, err
859 }
860 defer rows.Close()
861 var out []Pipeline
862 for rows.Next() {
863 p, err := scanPipeline(rows)
864 if err != nil {
865 return nil, err
866 }
867 out = append(out, p)
868 }
869 return out, rows.Err()
870}
871
872const pipelineCols = `SELECT id, repo_id, commit_sha, ref, status, created_at, finished_at, source, actor, commit_title, started_at, mr_id, target_sha FROM pipelines`
873
874func scanPipeline(rows *sql.Rows) (Pipeline, error) {
875 return scanPipelineRow(rows)
876}
877
878func scanPipelineRow(sc scanner) (Pipeline, error) {
879 var p Pipeline
880 var created, finished, started sql.NullString
881 if err := sc.Scan(&p.ID, &p.RepoID, &p.CommitSHA, &p.Ref, &p.Status, &created, &finished, &p.Source, &p.Actor, &p.CommitTitle, &started, &p.MRID, &p.TargetSHA); err != nil {
882 return Pipeline{}, err
883 }
884 p.CreatedAt = parseTime(created.String)
885 p.FinishedAt = parseTime(finished.String)
886 p.StartedAt = parseTime(started.String)
887 return p, nil
888}
889
890type scanner interface {
891 Scan(dest ...any) error
892}
893
894// LatestPipelineByCommit geeft de nieuwste pipeline van deze commit.
895func (s *Store) LatestPipelineByCommit(ctx context.Context, repoID int64, sha string) (Pipeline, error) {
896 p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND commit_sha = ? ORDER BY id DESC LIMIT 1`, repoID, sha))
897 if errors.Is(err, sql.ErrNoRows) {
898 return Pipeline{}, errNotFound
899 }
900 return p, err
901}
902
903// PipelineByID leest één pipeline.
904func (s *Store) PipelineByID(ctx context.Context, repoID, id int64) (Pipeline, error) {
905 p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND id = ?`, repoID, id))
906 if errors.Is(err, sql.ErrNoRows) {
907 return Pipeline{}, errNotFound
908 }
909 return p, err
910}
911
912// JobsByPipeline geeft de jobs in bestandsvolgorde.
913func (s *Store) JobsByPipeline(ctx context.Context, pipelineID int64) ([]Job, error) {
914 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.pipeline_id = ? ORDER BY j.position, j.id`, pipelineID)
915 if err != nil {
916 return nil, err
917 }
918 defer rows.Close()
919 var out []Job
920 for rows.Next() {
921 j, err := scanJob(rows)
922 if err != nil {
923 return nil, err
924 }
925 out = append(out, j)
926 }
927 return out, rows.Err()
928}
929
930const jobSelect = `SELECT j.id, j.pipeline_id, j.repo_id, j.name, j.stage, j.position, j.status, j.image, j.script, j.needs_json, j.needs_set, j.variables_json, j.artifact_paths, j.artifact_expire_seconds, j.allow_failure, j.log, p.commit_sha, p.ref, j.before_script, j.after_script, j.when_mode, j.timeout_seconds, j.tags_json, j.cache_paths, j.cache_key, j.resource_group, j.optional_json, j.started_at, j.finished_at, j.retry_max, j.retry_when, j.attempt, j.services_json, j.environment_name, j.environment_url, j.interruptible, j.failure_reason, j.do_not_interrupt
931FROM jobs j JOIN pipelines p ON p.id = j.pipeline_id`
932
933func scanJob(rows *sql.Rows) (Job, error) {
934 var j Job
935 var needs, vars, paths, tags, cache, optional, retryWhen, services string
936 var needsSet, allow, expire, timeout, interruptible, dni int
937 var started, finished sql.NullString
938 if err := rows.Scan(&j.ID, &j.PipelineID, &j.RepoID, &j.Name, &j.Stage, &j.Position, &j.Status, &j.Image, &j.Script, &needs, &needsSet, &vars, &paths, &expire, &allow, &j.Log, &j.CommitSHA, &j.Ref, &j.Before, &j.After, &j.When, &timeout, &tags, &cache, &j.CacheKey, &j.ResourceGroup, &optional, &started, &finished, &j.RetryMax, &retryWhen, &j.Attempt, &services, &j.Environment, &j.EnvironmentURL, &interruptible, &j.Reason, &dni); err != nil {
939 return Job{}, err
940 }
941 j.NeedsSet = needsSet == 1
942 j.AllowFailure = allow == 1
943 j.Interruptible = interruptible == 1
944 j.DoNotInterrupt = dni == 1
945 j.ArtifactExpire = time.Duration(expire) * time.Second
946 j.Timeout = time.Duration(timeout) * time.Second
947 j.StartedAt = parseTime(started.String)
948 j.FinishedAt = parseTime(finished.String)
949 _ = json.Unmarshal([]byte(needs), &j.Needs)
950 _ = json.Unmarshal([]byte(vars), &j.Variables)
951 _ = json.Unmarshal([]byte(paths), &j.ArtifactPaths)
952 _ = json.Unmarshal([]byte(tags), &j.Tags)
953 _ = json.Unmarshal([]byte(cache), &j.CachePaths)
954 _ = json.Unmarshal([]byte(optional), &j.Optional)
955 _ = json.Unmarshal([]byte(retryWhen), &j.RetryWhen)
956 _ = json.Unmarshal([]byte(services), &j.Services)
957 return j, nil
958}
959
960// ActivePipelines zijn nog niet af.
961func (s *Store) ActivePipelines(ctx context.Context) ([]Pipeline, error) {
962 rows, err := s.db.QueryContext(ctx, pipelineCols+` WHERE status IN ('queued', 'running', 'manual') OR id IN (SELECT pipeline_id FROM jobs WHERE status IN ('queued', 'running')) ORDER BY id`)
963 if err != nil {
964 return nil, err
965 }
966 defer rows.Close()
967 var out []Pipeline
968 for rows.Next() {
969 p, err := scanPipeline(rows)
970 if err != nil {
971 return nil, err
972 }
973 out = append(out, p)
974 }
975 return out, rows.Err()
976}
977
978// MarkJobRunning zet een wachtende job op running als hij dat nog is.
979func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) {
980 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'running', failure_reason = '', started_at = ? WHERE id = ? AND status = 'queued'`, now(), id)
981 if err != nil {
982 return false, err
983 }
984 n, _ := res.RowsAffected()
985 if n == 1 {
986 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', started_at = COALESCE(started_at, ?) WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, now(), id)
987 }
988 return n == 1, nil
989}
990
991// AbandonedJobNote komt in het log van een job die de herstart niet haalde.
992// Steve zit in dit proces. Een job die nog running is, heeft hier geen container.
993const AbandonedJobNote = "BlueGit herstartte terwijl deze job liep; het proces is weg.\n"
994
995// FailAbandonedJobs zet elke job met status running op failed.
996// Aanroep dit bij het starten van de service, vóór de runner jobs oppakt.
997// Een tweede keer doet niets. De pipelinestatus wordt daarna opnieuw berekend,
998// zodat retry met mode failed deze jobs en hun wachtende vervolg oppakt.
999func (s *Store) FailAbandonedJobs(ctx context.Context) (int, error) {
1000 rows, err := s.db.QueryContext(ctx, `SELECT id, pipeline_id FROM jobs WHERE status = 'running' ORDER BY id`)
1001 if err != nil {
1002 return 0, err
1003 }
1004 defer rows.Close()
1005 type item struct{ id, pipe int64 }
1006 var found []item
1007 for rows.Next() {
1008 var it item
1009 if err := rows.Scan(&it.id, &it.pipe); err != nil {
1010 return 0, err
1011 }
1012 found = append(found, it)
1013 }
1014 if err := rows.Err(); err != nil {
1015 return 0, err
1016 }
1017 n := 0
1018 seen := map[int64]struct{}{}
1019 var pipes []int64
1020 for _, it := range found {
1021 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'failed', failure_reason = 'runner_system_failure', log = log || ?, finished_at = ? WHERE id = ? AND status = 'running'`, AbandonedJobNote, now(), it.id)
1022 if err != nil {
1023 return n, err
1024 }
1025 affected, _ := res.RowsAffected()
1026 if affected == 0 {
1027 continue
1028 }
1029 n++
1030 if _, ok := seen[it.pipe]; !ok {
1031 seen[it.pipe] = struct{}{}
1032 pipes = append(pipes, it.pipe)
1033 }
1034 }
1035 for _, id := range pipes {
1036 if _, err := s.RefreshPipelineStatus(ctx, id); err != nil {
1037 return n, err
1038 }
1039 }
1040 return n, nil
1041}
1042
1043// CountRunningJobs telt jobs die Steve nu uitvoert.
1044// publish_aur eindigt vóór de POST en self_update eindigt meteen daarna,
1045// dus er is geen job die tijdens de installatie op de updater wacht.
1046func (s *Store) CountRunningJobs(ctx context.Context) (int, error) {
1047 var n int
1048 err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs WHERE status = 'running'`).Scan(&n)
1049 return n, err
1050}
1051
1052// FinishJob schrijft het eindresultaat en het log.
1053func (s *Store) FinishJob(ctx context.Context, id int64, status, extra string) error {
1054 return s.FinishJobReason(ctx, id, status, extra, "")
1055}
1056
1057// FinishJobReason is FinishJob met een reden (zie Job.Reason). Een lege reden
1058// laat een eerder gezette reden staan (bijv. canceled_by_user).
1059func (s *Store) FinishJobReason(ctx context.Context, id int64, status, extra, reason string) error {
1060 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = log || ?, finished_at = ?, failure_reason = CASE WHEN ? = '' THEN failure_reason ELSE ? END WHERE id = ?`, status, extra, now(), reason, reason, id)
1061 return err
1062}
1063
1064// AppendJobLog voegt tekst toe terwijl de job loopt.
1065func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error {
1066 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id)
1067 return err
1068}
1069
1070// RequeueJob zet een mislukte job terug in de wachtrij voor een nieuwe poging.
1071func (s *Store) RequeueJob(ctx context.Context, id int64, attempt int, note string) error {
1072 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', failure_reason = '', attempt = ?, log = log || ?, finished_at = NULL, started_at = NULL WHERE id = ?`, attempt, note, id)
1073 return err
1074}
1075
1076// CancelInterruptible annuleert onderbreekbare jobs van oudere pipelines op dezelfde ref.
1077// Lopende jobs komen terug zodat de runner hun context kan stoppen.
1078func (s *Store) CancelInterruptible(ctx context.Context, repoID int64, ref string, keep int64) (running []int64, pipes []int64, err error) {
1079 rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.status FROM jobs j
1080 JOIN pipelines p ON p.id = j.pipeline_id
1081 WHERE p.repo_id = ? AND p.ref = ? AND p.id != ? AND j.interruptible = 1 AND j.status IN ('queued', 'running', 'manual')
1082 AND NOT (j.status = 'running' AND j.do_not_interrupt = 1)`, repoID, ref, keep)
1083 if err != nil {
1084 return nil, nil, err
1085 }
1086 defer rows.Close()
1087 type row struct {
1088 id, pipe int64
1089 status string
1090 }
1091 var found []row
1092 seenPipe := map[int64]bool{}
1093 for rows.Next() {
1094 var item row
1095 if err := rows.Scan(&item.id, &item.pipe, &item.status); err != nil {
1096 return nil, nil, err
1097 }
1098 found = append(found, item)
1099 if !seenPipe[item.pipe] {
1100 seenPipe[item.pipe] = true
1101 pipes = append(pipes, item.pipe)
1102 }
1103 }
1104 if err := rows.Err(); err != nil {
1105 return nil, nil, err
1106 }
1107 note := time.Now().UTC().Format(time.RFC3339) + "\tcanceled because a newer pipeline started for the same ref\n"
1108 for _, item := range found {
1109 if item.status == "running" {
1110 running = append(running, item.id)
1111 continue
1112 }
1113 if _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'canceled', failure_reason = 'canceled_by_newer_pipeline', log = log || ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, note, now(), item.id); err != nil {
1114 return running, pipes, err
1115 }
1116 }
1117 return running, pipes, nil
1118}
1119
1120// RefreshPipelineStatus berekent de pipelinestatus uit de jobs.
1121func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) {
1122 jobs, err := s.JobsByPipeline(ctx, pipelineID)
1123 if err != nil {
1124 return "", err
1125 }
1126 status := "success"
1127 open := false
1128 manual := false
1129 canceled := false
1130 blocked := manualBlocked(jobs)
1131 for i, j := range jobs {
1132 switch j.Status {
1133 case "failed":
1134 if !j.AllowFailure {
1135 status = "failed"
1136 }
1137 case "canceled":
1138 if !j.AllowFailure {
1139 canceled = true
1140 }
1141 case "running":
1142 open = true
1143 case "queued":
1144 // Een job die alleen nog op een handmatige job wacht, telt niet
1145 // als bezig: de pipeline wacht dan op een handmatige actie.
1146 if blocked[i] {
1147 manual = true
1148 } else {
1149 open = true
1150 }
1151 case "manual":
1152 manual = true
1153 }
1154 }
1155 switch {
1156 case open:
1157 // Een harde mislukking wint pas als er niets meer in de wachtrij of
1158 // aan het werk is. Anders blijft de runner latere jobs overslaan.
1159 status = "running"
1160 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = ?`, pipelineID)
1161 case status == "failed":
1162 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID)
1163 case canceled:
1164 status = "canceled"
1165 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'canceled', finished_at = ? WHERE id = ?`, now(), pipelineID)
1166 case manual:
1167 status = "manual"
1168 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID)
1169 default:
1170 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID)
1171 }
1172 return status, err
1173}
1174
1175// ResourceBusy meldt of een andere job in deze repository die groep bezet.
1176func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) {
1177 if group == "" {
1178 return false, nil
1179 }
1180 var n int
1181 err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs WHERE repo_id = ? AND resource_group = ? AND status = 'running' AND id != ?`, repoID, group, except).Scan(&n)
1182 return n > 0, err
1183}
1184
1185// RetryJob zet een mislukte of geannuleerde job terug in de wachtrij.
1186func (s *Store) RetryJob(ctx context.Context, id int64) (bool, error) {
1187 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', failure_reason = '', finished_at = NULL WHERE id = ? AND status IN ('failed', 'canceled')`, id)
1188 if err != nil {
1189 return false, err
1190 }
1191 n, _ := res.RowsAffected()
1192 if n == 1 {
1193 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
1194 }
1195 return n == 1, nil
1196}
1197
1198// CancelJob stopt een job die nog niet klaar is.
1199func (s *Store) CancelJob(ctx context.Context, id int64) (bool, error) {
1200 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'canceled', failure_reason = 'canceled_by_user', finished_at = ? WHERE id = ? AND status IN ('created', 'pending', 'queued', 'manual', 'running')`, now(), id)
1201 if err != nil {
1202 return false, err
1203 }
1204 n, _ := res.RowsAffected()
1205 return n == 1, nil
1206}
1207
1208// QueueJob zet een handmatige job in de wachtrij.
1209func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
1210 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
1211 if err != nil {
1212 return false, err
1213 }
1214 n, _ := res.RowsAffected()
1215 if n == 1 {
1216 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
1217 }
1218 return n == 1, nil
1219}
1220
1221// SkipJob markeert een job die niet meer hoeft.
1222func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
1223 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id)
1224 return err
1225}
1226
1227// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
1228func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
1229 plain, err := newToken("bgj_")
1230 if err != nil {
1231 return "", err
1232 }
1233 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
1234 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
1235 jobID, hashToken(plain), now())
1236 if err != nil {
1237 return "", err
1238 }
1239 return plain, nil
1240}
1241
1242// JobByToken zoekt een lopende job bij een job-token.
1243func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
1244 if len(token) < 4 || token[:4] != "bgj_" {
1245 return Job{}, errNotFound
1246 }
1247 var jobID int64
1248 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
1249 if errors.Is(err, sql.ErrNoRows) {
1250 return Job{}, errNotFound
1251 }
1252 if err != nil {
1253 return Job{}, err
1254 }
1255 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
1256 if err != nil {
1257 return Job{}, err
1258 }
1259 defer rows.Close()
1260 if !rows.Next() {
1261 return Job{}, errNotFound
1262 }
1263 return scanJob(rows)
1264}
1265
1266// JobByID leest een job van deze repository.
1267func (s *Store) JobByID(ctx context.Context, repoID, id int64) (Job, error) {
1268 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.repo_id = ? AND j.id = ?`, repoID, id)
1269 if err != nil {
1270 return Job{}, err
1271 }
1272 defer rows.Close()
1273 if !rows.Next() {
1274 return Job{}, errNotFound
1275 }
1276 return scanJob(rows)
1277}
1278
1279// Artifact verwijst naar een bestand uit een job.
1280type Artifact struct {
1281 ID int64
1282 JobID int64
1283 Path string
1284 StoragePath string
1285 Size int64
1286}
1287
1288// AddArtifact registreert een bewaard bestand.
1289func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
1290 var exp any
1291 if expires != nil {
1292 exp = expires.UTC().Format(time.RFC3339)
1293 }
1294 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
1295 jobID, relPath, storagePath, size, exp)
1296 return err
1297}
1298
1299// ListArtifacts toont de bestanden van één job.
1300func (s *Store) ListArtifacts(ctx context.Context, jobID int64) ([]Artifact, error) {
1301 rows, err := s.db.QueryContext(ctx, `SELECT id, job_id, path, storage_path, size FROM artifacts WHERE job_id = ? ORDER BY path`, jobID)
1302 if err != nil {
1303 return nil, err
1304 }
1305 defer rows.Close()
1306 var out []Artifact
1307 for rows.Next() {
1308 var a Artifact
1309 if err := rows.Scan(&a.ID, &a.JobID, &a.Path, &a.StoragePath, &a.Size); err != nil {
1310 return nil, err
1311 }
1312 out = append(out, a)
1313 }
1314 return out, rows.Err()
1315}
1316
1317// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
1318func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
1319 var storage string
1320 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
1321 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
1322 if errors.Is(err, sql.ErrNoRows) {
1323 return "", errNotFound
1324 }
1325 return storage, err
1326}
1327
1328// Release is een publicatie op een commit.
1329type Release struct {
1330 ID int64
1331 RepoID int64
1332 Tag string
1333 CommitSHA string
1334 Name string
1335 Body string
1336 CreatedAt time.Time
1337 Assets []ReleaseAsset
1338}
1339
1340// ReleaseAsset is een bestand bij een release.
1341type ReleaseAsset struct {
1342 Name string
1343 StoragePath string
1344 Size int64
1345}
1346
1347// CreateRelease bewaart de release. De bestanden staan al op storagePath.
1348func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
1349 if err := names.ValidTag(tag); err != nil {
1350 return 0, err
1351 }
1352 tx, err := s.db.BeginTx(ctx, nil)
1353 if err != nil {
1354 return 0, err
1355 }
1356 defer func() { _ = tx.Rollback() }()
1357 var author, job any
1358 if authorID != 0 {
1359 author = authorID
1360 }
1361 if jobID != 0 {
1362 job = jobID
1363 }
1364 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
1365 repoID, tag, sha, name, body, author, job, now())
1366 if err != nil {
1367 if containsUnique(err) {
1368 return 0, i18n.E("err.tagExists", tag)
1369 }
1370 return 0, err
1371 }
1372 id, _ := res.LastInsertId()
1373 for _, a := range assets {
1374 if _, err := tx.ExecContext(ctx, `INSERT INTO release_assets (release_id, name, storage_path, size) VALUES (?, ?, ?, ?)`, id, a.Name, a.StoragePath, a.Size); err != nil {
1375 return 0, err
1376 }
1377 }
1378 if err := tx.Commit(); err != nil {
1379 return 0, err
1380 }
1381 return id, nil
1382}
1383
1384// ListReleases geeft publicaties, nieuwste eerst.
1385func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
1386 rows, err := s.db.QueryContext(ctx, `SELECT id, repo_id, tag, commit_sha, name, body, created_at FROM releases WHERE repo_id = ? ORDER BY id DESC`, repoID)
1387 if err != nil {
1388 return nil, err
1389 }
1390 defer rows.Close()
1391 var out []Release
1392 for rows.Next() {
1393 var r Release
1394 var created string
1395 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
1396 return nil, err
1397 }
1398 r.CreatedAt = parseTime(created)
1399 out = append(out, r)
1400 }
1401 if err := rows.Err(); err != nil {
1402 return nil, err
1403 }
1404 for i := range out {
1405 assets, err := s.releaseAssets(ctx, out[i].ID)
1406 if err != nil {
1407 return nil, err
1408 }
1409 out[i].Assets = assets
1410 }
1411 return out, nil
1412}
1413
1414// ReleaseByTag leest één release.
1415func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
1416 var r Release
1417 var created string
1418 err := s.db.QueryRowContext(ctx, `SELECT id, repo_id, tag, commit_sha, name, body, created_at FROM releases WHERE repo_id = ? AND tag = ?`, repoID, tag).
1419 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
1420 if errors.Is(err, sql.ErrNoRows) {
1421 return Release{}, errNotFound
1422 }
1423 if err != nil {
1424 return Release{}, err
1425 }
1426 r.CreatedAt = parseTime(created)
1427 r.Assets, err = s.releaseAssets(ctx, r.ID)
1428 return r, err
1429}
1430
1431func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
1432 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
1433 if err != nil {
1434 return nil, err
1435 }
1436 defer rows.Close()
1437 var out []ReleaseAsset
1438 for rows.Next() {
1439 var a ReleaseAsset
1440 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
1441 return nil, err
1442 }
1443 out = append(out, a)
1444 }
1445 return out, rows.Err()
1446}
1447
1448func trim(s string, n int) string {
1449 s = string([]rune(s))
1450 if len([]rune(s)) > n {
1451 return string([]rune(s)[:n])
1452 }
1453 return s
1454}
1455
1456func containsUnique(err error) bool {
1457 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
1458}
1459
1460func contains(s, sub string) bool {
1461 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
1462}
1463
1464func indexOf(s, sub string) int {
1465 for i := 0; i+len(sub) <= len(s); i++ {
1466 if s[i:i+len(sub)] == sub {
1467 return i
1468 }
1469 }
1470 return -1
1471}
1472
1473// DeleteReleaseAsset haalt één asset van een release weg en geeft het pad
1474// op schijf terug (om op te ruimen). errNotFound als de naam niet bestaat.
1475func (s *Store) DeleteReleaseAsset(ctx context.Context, releaseID int64, name string) (string, error) {
1476 var path string
1477 err := s.db.QueryRowContext(ctx, `SELECT storage_path FROM release_assets WHERE release_id = ? AND name = ?`, releaseID, name).Scan(&path)
1478 if errors.Is(err, sql.ErrNoRows) {
1479 return "", errNotFound
1480 }
1481 if err != nil {
1482 return "", err
1483 }
1484 _, err = s.db.ExecContext(ctx, `DELETE FROM release_assets WHERE release_id = ? AND name = ?`, releaseID, name)
1485 return path, err
1486}
1487
1488// DeleteRelease verwijdert de release met zijn assets en geeft de paden op
1489// schijf terug. De git-tag blijft staan.
1490func (s *Store) DeleteRelease(ctx context.Context, releaseID int64) ([]string, error) {
1491 assets, err := s.releaseAssets(ctx, releaseID)
1492 if err != nil {
1493 return nil, err
1494 }
1495 tx, err := s.db.BeginTx(ctx, nil)
1496 if err != nil {
1497 return nil, err
1498 }
1499 defer func() { _ = tx.Rollback() }()
1500 if _, err := tx.ExecContext(ctx, `DELETE FROM release_assets WHERE release_id = ?`, releaseID); err != nil {
1501 return nil, err
1502 }
1503 if _, err := tx.ExecContext(ctx, `DELETE FROM releases WHERE id = ?`, releaseID); err != nil {
1504 return nil, err
1505 }
1506 if err := tx.Commit(); err != nil {
1507 return nil, err
1508 }
1509 var paths []string
1510 for _, a := range assets {
1511 paths = append(paths, a.StoragePath)
1512 }
1513 return paths, nil
1514}
1515
1516// Redenen in Job.Reason.
1517const (
1518 ReasonSuperseded = "canceled_by_newer_pipeline"
1519 ReasonManual = "canceled_by_user"
1520 // ReasonStaleManual: een handmatige job die verlopen is omdat zijn
1521 // pipeline te lang alleen nog op handmatige actie wachtte.
1522 ReasonStaleManual = "canceled_stale_manual"
1523)
1524
1525// Obsolete is true voor een job die geannuleerd is omdat een nieuwere
1526// pipeline op dezelfde ref startte.
1527func (j Job) Obsolete() bool {
1528 return j.Status == "canceled" && (j.Reason == ReasonSuperseded || j.Reason == ReasonStaleManual)
1529}
1530
1531// CancelReason geeft "superseded" of "manual" voor een geannuleerde job,
1532// anders "".
1533func (j Job) CancelReason() string {
1534 if j.Status != "canceled" {
1535 return ""
1536 }
1537 if j.Reason == ReasonSuperseded {
1538 return "superseded"
1539 }
1540 if j.Reason == ReasonStaleManual {
1541 return "stale"
1542 }
1543 return "manual"
1544}
1545
1546// FailureReason geeft de reden van een mislukte job (bijv.
1547// job_execution_timeout), anders "".
1548func (j Job) FailureReason() string {
1549 if j.Status != "failed" {
1550 return ""
1551 }
1552 return j.Reason
1553}
1554
1555// PipelineObsolete is true als elke geannuleerde job die telt (geen
1556// allow_failure) obsolete is, en er minstens één is.
1557func PipelineObsolete(jobs []Job) bool {
1558 seen := false
1559 for _, j := range jobs {
1560 if j.Status != "canceled" || j.AllowFailure {
1561 continue
1562 }
1563 if !j.Obsolete() {
1564 return false
1565 }
1566 seen = true
1567 }
1568 return seen
1569}
1570
1571// ProtectedBlocker zoekt een lopende doNotInterrupt-job in een oudere
1572// pipeline op dezelfde ref. Zolang die er is, wacht pipeline pipelineID.
1573func (s *Store) ProtectedBlocker(ctx context.Context, repoID int64, ref string, pipelineID int64) (Job, bool) {
1574 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE p.repo_id = ? AND p.ref = ? AND p.id < ? AND j.status = 'running' AND j.do_not_interrupt = 1 ORDER BY j.id LIMIT 1`, repoID, ref, pipelineID)
1575 if err != nil {
1576 return Job{}, false
1577 }
1578 defer rows.Close()
1579 if !rows.Next() {
1580 return Job{}, false
1581 }
1582 j, err := scanJob(rows)
1583 return j, err == nil
1584}
1585
1586// RunningProtectedJobs geeft lopende doNotInterrupt-jobs. Met repoID > 0
1587// alleen in die repo; met runnerID > 0 alleen op die aparte runner.
1588func (s *Store) RunningProtectedJobs(ctx context.Context, repoID, runnerID int64) ([]Job, error) {
1589 q := jobSelect + ` WHERE j.status = 'running' AND j.do_not_interrupt = 1`
1590 var args []any
1591 if repoID > 0 {
1592 q += ` AND j.repo_id = ?`
1593 args = append(args, repoID)
1594 }
1595 if runnerID > 0 {
1596 q += ` AND j.id IN (SELECT job_id FROM job_runs WHERE runner_id = ?)`
1597 args = append(args, runnerID)
1598 }
1599 rows, err := s.db.QueryContext(ctx, q+` ORDER BY j.id`, args...)
1600 if err != nil {
1601 return nil, err
1602 }
1603 defer rows.Close()
1604 var out []Job
1605 for rows.Next() {
1606 j, err := scanJob(rows)
1607 if err != nil {
1608 return nil, err
1609 }
1610 out = append(out, j)
1611 }
1612 return out, rows.Err()
1613}
1614
1615// ProtectedRunning filtert de lopende doNotInterrupt-jobs uit jobs.
1616func ProtectedRunning(jobs []Job) []Job {
1617 var out []Job
1618 for _, j := range jobs {
1619 if j.Status == "running" && j.DoNotInterrupt {
1620 out = append(out, j)
1621 }
1622 }
1623 return out
1624}
1625
1626// CopySecret kopieert een versleuteld geheim naar een ander scope zonder het
1627// te ontcijferen. Een bestaande naam in het doel wordt niet overschreven.
1628func (s *Store) CopySecret(ctx context.Context, fromKind string, fromID int64, name, toKind string, toID int64) error {
1629 if toKind != "repo" && toKind != "group" {
1630 return i18n.E("err.scope")
1631 }
1632 res, err := s.db.ExecContext(ctx, `INSERT INTO secrets (scope_kind, scope_id, name, ciphertext, nonce, protected, invisible, created_at)
1633 SELECT ?, ?, name, ciphertext, nonce, protected, invisible, ? FROM secrets WHERE scope_kind = ? AND scope_id = ? AND name = ?`,
1634 toKind, toID, now(), fromKind, fromID, name)
1635 if err != nil {
1636 if strings.Contains(err.Error(), "UNIQUE") {
1637 return i18n.E("err.secretExists", name)
1638 }
1639 return err
1640 }
1641 n, _ := res.RowsAffected()
1642 if n == 0 {
1643 return errNotFound
1644 }
1645 return nil
1646}
1647
1648// SetWebhookActive zet een webhook aan of uit.
1649func (s *Store) SetWebhookActive(ctx context.Context, scopeKind string, scopeID, id int64, on bool) error {
1650 _, err := s.db.ExecContext(ctx, `UPDATE webhooks SET active = ? WHERE id = ? AND scope_kind = ? AND scope_id = ?`, boolInt(on), id, scopeKind, scopeID)
1651 return err
1652}
1653
1654// manualBlocked markeert queued jobs die (direct of via andere wachtende
1655// jobs) op een handmatige job wachten die nog niet gestart is. Een
1656// handmatige job met allow_failure blokkeert niet, net als in ci.Gate.
1657func manualBlocked(jobs []Job) map[int]bool {
1658 preds := predecessorIndexes(jobs)
1659 blocked := map[int]bool{}
1660 for {
1661 moved := false
1662 for i, j := range jobs {
1663 if blocked[i] || j.Status != "queued" {
1664 continue
1665 }
1666 for _, p := range preds[i] {
1667 pj := jobs[p]
1668 if (pj.Status == "manual" && !pj.AllowFailure) || blocked[p] {
1669 blocked[i] = true
1670 moved = true
1671 break
1672 }
1673 }
1674 }
1675 if !moved {
1676 return blocked
1677 }
1678 }
1679}