BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

flow.go 51.4 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}
379
380// Service is een sidecar die de runner naast de job start.
381type Service struct {
382 Name string `json:"name"`
383 Alias string `json:"alias"`
384 Command []string `json:"command,omitempty"`
385 Entrypoint []string `json:"entrypoint,omitempty"`
386 Variables map[string]string `json:"variables,omitempty"`
387}
388
389// Pipeline is een draai van blue-ci-cd.yml.
390type Pipeline struct {
391 ID int64
392 RepoID int64
393 CommitSHA string
394 Ref string
395 Status string
396 Source string
397 Actor string
398 CommitTitle string
399 CreatedAt time.Time
400 StartedAt time.Time
401 FinishedAt time.Time
402 MRID int64
403 // TargetSHA is de doelcommit van een merge-request-pipeline.
404 // Leeg zolang de rij nog niet aan een merge request hangt.
405 // Een nieuwe doelcommit start een nieuwe pipeline.
406 TargetSHA string
407}
408
409// Job is één container in een pipeline.
410type Job struct {
411 ID int64
412 PipelineID int64
413 RepoID int64
414 Name string
415 Stage string
416 Position int
417 Status string
418 Image string
419 Before string
420 Script string
421 After string
422 Needs []string
423 Optional []string
424 NeedsSet bool
425 Variables map[string]string
426 ArtifactPaths []string
427 ArtifactExpire time.Duration
428 AllowFailure bool
429 When string
430 Timeout time.Duration
431 Tags []string
432 CachePaths []string
433 CacheKey string
434 ResourceGroup string
435 RetryMax int
436 RetryWhen []string
437 Attempt int
438 Services []Service
439 Environment string
440 EnvironmentURL string
441 Interruptible bool
442 // Reason zegt waarom een job failed of canceled is: job_execution_timeout,
443 // script_failure, runner_system_failure, canceled_by_user,
444 // canceled_by_newer_pipeline. Leeg bij succes of onbekend (oude jobs).
445 Reason string
446 Log string
447 CommitSHA string
448 Ref string
449 StartedAt time.Time
450 FinishedAt time.Time
451}
452
453// RecordConfigFailure bewaart een pipeline die niet kon starten.
454// Dezelfde repo, ref, sha, bron, merge request en doel-sha levert de
455// bestaande pipeline terug. Een kapotte push die al bestaat wordt aan
456// de merge request gekoppeld in plaats van een tweede mislukte rij.
457func (s *Store) RecordConfigFailure(ctx context.Context, repoID int64, sha, ref, source, message string, mrID int64, targetSHA string) (int64, bool, error) {
458 if source == "" {
459 source = "push"
460 }
461 tx, err := s.db.BeginTx(ctx, nil)
462 if err != nil {
463 return 0, false, err
464 }
465 defer func() { _ = tx.Rollback() }()
466 if id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA); err != nil {
467 return 0, false, err
468 } else if ok {
469 return finishExisting(ctx, tx, id)
470 }
471 if source == "push" && mrID == 0 {
472 if id, ok, err := newestPush(ctx, tx, repoID, sha, ref); err != nil {
473 return 0, false, err
474 } else if ok {
475 return finishExisting(ctx, tx, id)
476 }
477 }
478 if mrID != 0 {
479 if id, ok, err := configFailurePush(ctx, tx, repoID, sha, ref, mrID, targetSHA); err != nil {
480 return 0, false, err
481 } else if ok {
482 if err := bindPipelineMR(ctx, tx, id, mrID, targetSHA); err != nil {
483 return 0, false, err
484 }
485 return finishExisting(ctx, tx, id)
486 }
487 }
488 ts := now()
489 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, created_at, finished_at, mr_id, target_sha)
490 SELECT ?, ?, ?, 'failed', ?, ?, ?, ?, ?
491 WHERE NOT EXISTS (
492 SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = ? AND mr_id = ? AND target_sha = ?
493 )`, repoID, sha, ref, source, ts, ts, mrID, targetSHA, repoID, sha, ref, source, mrID, targetSHA)
494 if err != nil {
495 return 0, false, err
496 }
497 if n, _ := res.RowsAffected(); n == 0 {
498 id, err := pipelineKeyID(ctx, tx, repoID, sha, ref, source, mrID, targetSHA)
499 if err != nil {
500 return 0, false, err
501 }
502 return finishExisting(ctx, tx, id)
503 }
504 id, _ := res.LastInsertId()
505 _, 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)
506 VALUES (?, ?, 'blue-ci-cd', 'test', 0, 'failed', 'alpine:3.20', 'exit 1', '[]', 0, '{}', '[]', 0, 0, ?, ?)`, id, repoID, message, ts)
507 if err != nil {
508 return 0, false, err
509 }
510 if err := tx.Commit(); err != nil {
511 return 0, false, err
512 }
513 return id, true, nil
514}
515
516// CreatePipeline maakt een pipeline met jobs in de wachtrij.
517// Elke aanroep voegt een rij toe. Starten via een push of merge request
518// gaat via OpenPipeline, zodat een dubbele hook dezelfde run teruggeeft.
519func (s *Store) CreatePipeline(ctx context.Context, repoID int64, sha, ref, source, actor, title string, jobs []NewJob) (int64, error) {
520 tx, err := s.db.BeginTx(ctx, nil)
521 if err != nil {
522 return 0, err
523 }
524 defer func() { _ = tx.Rollback() }()
525 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())
526 if err != nil {
527 return 0, err
528 }
529 id, _ := res.LastInsertId()
530 if err := insertPipelineJobs(ctx, tx, id, repoID, jobs); err != nil {
531 return 0, err
532 }
533 if err := tx.Commit(); err != nil {
534 return 0, err
535 }
536 return id, nil
537}
538
539// OpenPipeline maakt een pipeline, of geeft de bestaande terug.
540// De sleutel is repo, ref, sha, bron, merge request en doel-sha.
541// Een push voor dezelfde sha blijft één rij, ook nadat een merge request
542// hem heeft gekoppeld. Kiezen push en merge request dezelfde jobs, dan
543// koppelt deze aanroep de push-rij en maakt hij geen tweede pipeline.
544// Een andere jobset of een nieuwe doel-sha start wel een eigen rij.
545// created is false wanneer een eerdere trigger de run al had.
546func (s *Store) OpenPipeline(ctx context.Context, repoID int64, sha, ref, source, actor, title, targetSHA string, mrID int64, jobs []NewJob) (int64, bool, error) {
547 if source == "" {
548 source = "push"
549 }
550 tx, err := s.db.BeginTx(ctx, nil)
551 if err != nil {
552 return 0, false, err
553 }
554 defer func() { _ = tx.Rollback() }()
555 if id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA); err != nil {
556 return 0, false, err
557 } else if ok {
558 return finishExisting(ctx, tx, id)
559 }
560 if source == "push" && mrID == 0 {
561 if id, ok, err := newestPush(ctx, tx, repoID, sha, ref); err != nil {
562 return 0, false, err
563 } else if ok {
564 return finishExisting(ctx, tx, id)
565 }
566 }
567 if mrID != 0 {
568 if id, ok, err := claimMatchingPush(ctx, tx, repoID, sha, ref, mrID, targetSHA, jobs); err != nil {
569 return 0, false, err
570 } else if ok {
571 return finishExisting(ctx, tx, id)
572 }
573 }
574 notExists := `SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = ? AND mr_id = ? AND target_sha = ?`
575 args := []any{repoID, sha, ref, source, actor, title, now(), mrID, targetSHA, repoID, sha, ref, source, mrID, targetSHA}
576 if source == "push" && mrID == 0 {
577 notExists = `SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = 'push'`
578 args = []any{repoID, sha, ref, source, actor, title, now(), mrID, targetSHA, repoID, sha, ref}
579 }
580 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, actor, commit_title, created_at, mr_id, target_sha)
581 SELECT ?, ?, ?, 'queued', ?, ?, ?, ?, ?, ?
582 WHERE NOT EXISTS (`+notExists+`)`, args...)
583 if err != nil {
584 return 0, false, err
585 }
586 if n, _ := res.RowsAffected(); n == 0 {
587 id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA)
588 if err != nil {
589 return 0, false, err
590 }
591 if !ok && source == "push" && mrID == 0 {
592 id, ok, err = newestPush(ctx, tx, repoID, sha, ref)
593 if err != nil {
594 return 0, false, err
595 }
596 }
597 if !ok {
598 return 0, false, errors.New("pipeline ontbreekt na een lege insert")
599 }
600 return finishExisting(ctx, tx, id)
601 }
602 id, _ := res.LastInsertId()
603 if err := insertPipelineJobs(ctx, tx, id, repoID, jobs); err != nil {
604 return 0, false, err
605 }
606 if err := tx.Commit(); err != nil {
607 return 0, false, err
608 }
609 return id, true, nil
610}
611
612func finishExisting(ctx context.Context, tx *sql.Tx, id int64) (int64, bool, error) {
613 if err := tx.Commit(); err != nil {
614 return 0, false, err
615 }
616 return id, false, nil
617}
618
619func existingPipeline(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref, source string, mrID int64, targetSHA string) (int64, bool, error) {
620 id, err := pipelineKeyID(ctx, tx, repoID, sha, ref, source, mrID, targetSHA)
621 if errors.Is(err, sql.ErrNoRows) {
622 return 0, false, nil
623 }
624 if err != nil {
625 return 0, false, err
626 }
627 return id, true, nil
628}
629
630func pipelineKeyID(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref, source string, mrID int64, targetSHA string) (int64, error) {
631 var id int64
632 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`,
633 repoID, sha, ref, source, mrID, targetSHA).Scan(&id)
634 return id, err
635}
636
637func newestPush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string) (int64, bool, error) {
638 var id int64
639 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`,
640 repoID, sha, ref).Scan(&id)
641 if errors.Is(err, sql.ErrNoRows) {
642 return 0, false, nil
643 }
644 if err != nil {
645 return 0, false, err
646 }
647 return id, true, nil
648}
649
650// configFailurePush zoekt een mislukte push die alleen de kapotte yaml bewaart.
651func configFailurePush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string, mrID int64, targetSHA string) (int64, bool, error) {
652 var id int64
653 err := tx.QueryRowContext(ctx, `SELECT p.id FROM pipelines p
654 WHERE p.repo_id = ? AND p.commit_sha = ? AND p.ref = ? AND p.source = 'push' AND p.status = 'failed'
655 AND (p.mr_id = 0 OR p.mr_id = ?) AND (p.target_sha = '' OR p.target_sha = ?)
656 AND EXISTS (SELECT 1 FROM jobs j WHERE j.pipeline_id = p.id AND j.name = 'blue-ci-cd')
657 ORDER BY p.id DESC LIMIT 1`, repoID, sha, ref, mrID, targetSHA).Scan(&id)
658 if errors.Is(err, sql.ErrNoRows) {
659 return 0, false, nil
660 }
661 if err != nil {
662 return 0, false, err
663 }
664 return id, true, nil
665}
666
667type pushCandidate struct {
668 id int64
669 mrID int64
670 target string
671}
672
673// claimMatchingPush koppelt een push-pipeline met dezelfde jobs aan de merge request.
674func claimMatchingPush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string, mrID int64, targetSHA string, jobs []NewJob) (int64, bool, error) {
675 rows, err := tx.QueryContext(ctx, `SELECT id, mr_id, target_sha FROM pipelines
676 WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = 'push'
677 AND (mr_id = 0 OR mr_id = ?) AND (target_sha = '' OR target_sha = ?)
678 ORDER BY id DESC`, repoID, sha, ref, mrID, targetSHA)
679 if err != nil {
680 return 0, false, err
681 }
682 var cands []pushCandidate
683 for rows.Next() {
684 var c pushCandidate
685 if err := rows.Scan(&c.id, &c.mrID, &c.target); err != nil {
686 rows.Close()
687 return 0, false, err
688 }
689 cands = append(cands, c)
690 }
691 if err := rows.Err(); err != nil {
692 rows.Close()
693 return 0, false, err
694 }
695 rows.Close()
696 for _, c := range cands {
697 if c.mrID == mrID && c.target == targetSHA {
698 return c.id, true, nil
699 }
700 got, err := loadJobSigs(ctx, tx, c.id)
701 if err != nil {
702 return 0, false, err
703 }
704 if !sameJobSigs(got, jobs) {
705 continue
706 }
707 if err := bindPipelineMR(ctx, tx, c.id, mrID, targetSHA); err != nil {
708 return 0, false, err
709 }
710 return c.id, true, nil
711 }
712 return 0, false, nil
713}
714
715func bindPipelineMR(ctx context.Context, tx *sql.Tx, id, mrID int64, targetSHA string) error {
716 _, err := tx.ExecContext(ctx, `UPDATE pipelines SET mr_id = ?, target_sha = ? WHERE id = ?`, mrID, targetSHA, id)
717 return err
718}
719
720type jobSig struct {
721 name, stage, image, script, when string
722 allow bool
723}
724
725func loadJobSigs(ctx context.Context, tx *sql.Tx, pipelineID int64) ([]jobSig, error) {
726 rows, err := tx.QueryContext(ctx, `SELECT name, stage, image, script, when_mode, allow_failure FROM jobs WHERE pipeline_id = ? ORDER BY position, id`, pipelineID)
727 if err != nil {
728 return nil, err
729 }
730 defer rows.Close()
731 var out []jobSig
732 for rows.Next() {
733 var s jobSig
734 var allow int
735 if err := rows.Scan(&s.name, &s.stage, &s.image, &s.script, &s.when, &allow); err != nil {
736 return nil, err
737 }
738 s.allow = allow == 1
739 out = append(out, s)
740 }
741 return out, rows.Err()
742}
743
744func sameJobSigs(got []jobSig, jobs []NewJob) bool {
745 if len(got) != len(jobs) {
746 return false
747 }
748 for i, j := range jobs {
749 when := j.When
750 if when == "" {
751 when = "on_success"
752 }
753 g := got[i]
754 if g.name != j.Name || g.stage != j.Stage || g.image != j.Image || g.script != j.Script || g.when != when || g.allow != j.AllowFailure {
755 return false
756 }
757 }
758 return true
759}
760
761func insertPipelineJobs(ctx context.Context, tx *sql.Tx, id, repoID int64, jobs []NewJob) error {
762 for _, j := range jobs {
763 if j.Variables == nil {
764 j.Variables = map[string]string{}
765 }
766 if j.Needs == nil {
767 j.Needs = []string{}
768 }
769 if j.ArtifactPaths == nil {
770 j.ArtifactPaths = []string{}
771 }
772 if j.Optional == nil {
773 j.Optional = []string{}
774 }
775 if j.Tags == nil {
776 j.Tags = []string{}
777 }
778 if j.CachePaths == nil {
779 j.CachePaths = []string{}
780 }
781 if j.When == "" {
782 j.When = "on_success"
783 }
784 if j.RetryWhen == nil {
785 j.RetryWhen = []string{}
786 }
787 if j.Services == nil {
788 j.Services = []Service{}
789 }
790 status := "queued"
791 if j.When == "manual" {
792 status = "manual"
793 }
794 _, 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)
795 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
796 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),
797 j.Before, j.After, j.When, int(j.Timeout/time.Second), mustJSON(j.Tags), mustJSON(j.CachePaths), j.CacheKey, j.ResourceGroup, mustJSON(j.Optional),
798 j.RetryMax, mustJSON(j.RetryWhen), mustJSON(j.Services), j.Environment, j.EnvironmentURL, boolInt(j.Interruptible))
799 if err != nil {
800 return err
801 }
802 }
803 return nil
804}
805
806// ListPipelines geeft de nieuwste pipelines.
807func (s *Store) ListPipelines(ctx context.Context, repoID int64) ([]Pipeline, error) {
808 rows, err := s.db.QueryContext(ctx, pipelineCols+` WHERE repo_id = ? ORDER BY id DESC LIMIT 50`, repoID)
809 if err != nil {
810 return nil, err
811 }
812 defer rows.Close()
813 var out []Pipeline
814 for rows.Next() {
815 p, err := scanPipeline(rows)
816 if err != nil {
817 return nil, err
818 }
819 out = append(out, p)
820 }
821 return out, rows.Err()
822}
823
824// PipelineFilter beperkt FindPipelines. Lege velden filteren niet.
825// SHA mag een prefix van minstens 7 tekens zijn. Refs is een lijst van
826// volledige refs; MRID neemt ook pipelines van de MR zelf mee.
827type PipelineFilter struct {
828 SHA string
829 Refs []string
830 MRID int64
831}
832
833// FindPipelines geeft de nieuwste pipelines die bij f passen, hooguit 50.
834func (s *Store) FindPipelines(ctx context.Context, repoID int64, f PipelineFilter) ([]Pipeline, error) {
835 q := pipelineCols + ` WHERE repo_id = ?`
836 args := []any{repoID}
837 if f.SHA != "" {
838 q += ` AND commit_sha LIKE ?`
839 args = append(args, strings.ToLower(f.SHA)+"%")
840 }
841 var alt []string
842 if f.MRID != 0 {
843 alt = append(alt, `mr_id = ?`)
844 args = append(args, f.MRID)
845 }
846 for _, ref := range f.Refs {
847 alt = append(alt, `ref = ?`)
848 args = append(args, ref)
849 }
850 if len(alt) > 0 {
851 q += ` AND (` + strings.Join(alt, ` OR `) + `)`
852 }
853 q += ` ORDER BY id DESC LIMIT 50`
854 rows, err := s.db.QueryContext(ctx, q, args...)
855 if err != nil {
856 return nil, err
857 }
858 defer rows.Close()
859 var out []Pipeline
860 for rows.Next() {
861 p, err := scanPipeline(rows)
862 if err != nil {
863 return nil, err
864 }
865 out = append(out, p)
866 }
867 return out, rows.Err()
868}
869
870const 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`
871
872func scanPipeline(rows *sql.Rows) (Pipeline, error) {
873 return scanPipelineRow(rows)
874}
875
876func scanPipelineRow(sc scanner) (Pipeline, error) {
877 var p Pipeline
878 var created, finished, started sql.NullString
879 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 {
880 return Pipeline{}, err
881 }
882 p.CreatedAt = parseTime(created.String)
883 p.FinishedAt = parseTime(finished.String)
884 p.StartedAt = parseTime(started.String)
885 return p, nil
886}
887
888type scanner interface {
889 Scan(dest ...any) error
890}
891
892// LatestPipelineByCommit geeft de nieuwste pipeline van deze commit.
893func (s *Store) LatestPipelineByCommit(ctx context.Context, repoID int64, sha string) (Pipeline, error) {
894 p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND commit_sha = ? ORDER BY id DESC LIMIT 1`, repoID, sha))
895 if errors.Is(err, sql.ErrNoRows) {
896 return Pipeline{}, errNotFound
897 }
898 return p, err
899}
900
901// PipelineByID leest één pipeline.
902func (s *Store) PipelineByID(ctx context.Context, repoID, id int64) (Pipeline, error) {
903 p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND id = ?`, repoID, id))
904 if errors.Is(err, sql.ErrNoRows) {
905 return Pipeline{}, errNotFound
906 }
907 return p, err
908}
909
910// JobsByPipeline geeft de jobs in bestandsvolgorde.
911func (s *Store) JobsByPipeline(ctx context.Context, pipelineID int64) ([]Job, error) {
912 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.pipeline_id = ? ORDER BY j.position, j.id`, pipelineID)
913 if err != nil {
914 return nil, err
915 }
916 defer rows.Close()
917 var out []Job
918 for rows.Next() {
919 j, err := scanJob(rows)
920 if err != nil {
921 return nil, err
922 }
923 out = append(out, j)
924 }
925 return out, rows.Err()
926}
927
928const 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
929FROM jobs j JOIN pipelines p ON p.id = j.pipeline_id`
930
931func scanJob(rows *sql.Rows) (Job, error) {
932 var j Job
933 var needs, vars, paths, tags, cache, optional, retryWhen, services string
934 var needsSet, allow, expire, timeout, interruptible int
935 var started, finished sql.NullString
936 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); err != nil {
937 return Job{}, err
938 }
939 j.NeedsSet = needsSet == 1
940 j.AllowFailure = allow == 1
941 j.Interruptible = interruptible == 1
942 j.ArtifactExpire = time.Duration(expire) * time.Second
943 j.Timeout = time.Duration(timeout) * time.Second
944 j.StartedAt = parseTime(started.String)
945 j.FinishedAt = parseTime(finished.String)
946 _ = json.Unmarshal([]byte(needs), &j.Needs)
947 _ = json.Unmarshal([]byte(vars), &j.Variables)
948 _ = json.Unmarshal([]byte(paths), &j.ArtifactPaths)
949 _ = json.Unmarshal([]byte(tags), &j.Tags)
950 _ = json.Unmarshal([]byte(cache), &j.CachePaths)
951 _ = json.Unmarshal([]byte(optional), &j.Optional)
952 _ = json.Unmarshal([]byte(retryWhen), &j.RetryWhen)
953 _ = json.Unmarshal([]byte(services), &j.Services)
954 return j, nil
955}
956
957// ActivePipelines zijn nog niet af.
958func (s *Store) ActivePipelines(ctx context.Context) ([]Pipeline, error) {
959 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`)
960 if err != nil {
961 return nil, err
962 }
963 defer rows.Close()
964 var out []Pipeline
965 for rows.Next() {
966 p, err := scanPipeline(rows)
967 if err != nil {
968 return nil, err
969 }
970 out = append(out, p)
971 }
972 return out, rows.Err()
973}
974
975// MarkJobRunning zet een wachtende job op running als hij dat nog is.
976func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) {
977 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'running', failure_reason = '', started_at = ? WHERE id = ? AND status = 'queued'`, now(), id)
978 if err != nil {
979 return false, err
980 }
981 n, _ := res.RowsAffected()
982 if n == 1 {
983 _, _ = 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)
984 }
985 return n == 1, nil
986}
987
988// AbandonedJobNote komt in het log van een job die de herstart niet haalde.
989// Steve zit in dit proces. Een job die nog running is, heeft hier geen container.
990const AbandonedJobNote = "BlueGit herstartte terwijl deze job liep; het proces is weg.\n"
991
992// FailAbandonedJobs zet elke job met status running op failed.
993// Aanroep dit bij het starten van de service, vóór de runner jobs oppakt.
994// Een tweede keer doet niets. De pipelinestatus wordt daarna opnieuw berekend,
995// zodat retry met mode failed deze jobs en hun wachtende vervolg oppakt.
996func (s *Store) FailAbandonedJobs(ctx context.Context) (int, error) {
997 rows, err := s.db.QueryContext(ctx, `SELECT id, pipeline_id FROM jobs WHERE status = 'running' ORDER BY id`)
998 if err != nil {
999 return 0, err
1000 }
1001 defer rows.Close()
1002 type item struct{ id, pipe int64 }
1003 var found []item
1004 for rows.Next() {
1005 var it item
1006 if err := rows.Scan(&it.id, &it.pipe); err != nil {
1007 return 0, err
1008 }
1009 found = append(found, it)
1010 }
1011 if err := rows.Err(); err != nil {
1012 return 0, err
1013 }
1014 n := 0
1015 seen := map[int64]struct{}{}
1016 var pipes []int64
1017 for _, it := range found {
1018 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)
1019 if err != nil {
1020 return n, err
1021 }
1022 affected, _ := res.RowsAffected()
1023 if affected == 0 {
1024 continue
1025 }
1026 n++
1027 if _, ok := seen[it.pipe]; !ok {
1028 seen[it.pipe] = struct{}{}
1029 pipes = append(pipes, it.pipe)
1030 }
1031 }
1032 for _, id := range pipes {
1033 if _, err := s.RefreshPipelineStatus(ctx, id); err != nil {
1034 return n, err
1035 }
1036 }
1037 return n, nil
1038}
1039
1040// CountRunningJobs telt jobs die Steve nu uitvoert.
1041// publish_aur eindigt vóór de POST en self_update eindigt meteen daarna,
1042// dus er is geen job die tijdens de installatie op de updater wacht.
1043func (s *Store) CountRunningJobs(ctx context.Context) (int, error) {
1044 var n int
1045 err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs WHERE status = 'running'`).Scan(&n)
1046 return n, err
1047}
1048
1049// FinishJob schrijft het eindresultaat en het log.
1050func (s *Store) FinishJob(ctx context.Context, id int64, status, extra string) error {
1051 return s.FinishJobReason(ctx, id, status, extra, "")
1052}
1053
1054// FinishJobReason is FinishJob met een reden (zie Job.Reason). Een lege reden
1055// laat een eerder gezette reden staan (bijv. canceled_by_user).
1056func (s *Store) FinishJobReason(ctx context.Context, id int64, status, extra, reason string) error {
1057 _, 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)
1058 return err
1059}
1060
1061// AppendJobLog voegt tekst toe terwijl de job loopt.
1062func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error {
1063 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id)
1064 return err
1065}
1066
1067// RequeueJob zet een mislukte job terug in de wachtrij voor een nieuwe poging.
1068func (s *Store) RequeueJob(ctx context.Context, id int64, attempt int, note string) error {
1069 _, 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)
1070 return err
1071}
1072
1073// CancelInterruptible annuleert onderbreekbare jobs van oudere pipelines op dezelfde ref.
1074// Lopende jobs komen terug zodat de runner hun context kan stoppen.
1075func (s *Store) CancelInterruptible(ctx context.Context, repoID int64, ref string, keep int64) (running []int64, pipes []int64, err error) {
1076 rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.status FROM jobs j
1077 JOIN pipelines p ON p.id = j.pipeline_id
1078 WHERE p.repo_id = ? AND p.ref = ? AND p.id != ? AND j.interruptible = 1 AND j.status IN ('queued', 'running', 'manual')`, repoID, ref, keep)
1079 if err != nil {
1080 return nil, nil, err
1081 }
1082 defer rows.Close()
1083 type row struct {
1084 id, pipe int64
1085 status string
1086 }
1087 var found []row
1088 seenPipe := map[int64]bool{}
1089 for rows.Next() {
1090 var item row
1091 if err := rows.Scan(&item.id, &item.pipe, &item.status); err != nil {
1092 return nil, nil, err
1093 }
1094 found = append(found, item)
1095 if !seenPipe[item.pipe] {
1096 seenPipe[item.pipe] = true
1097 pipes = append(pipes, item.pipe)
1098 }
1099 }
1100 if err := rows.Err(); err != nil {
1101 return nil, nil, err
1102 }
1103 note := time.Now().UTC().Format(time.RFC3339) + "\tcanceled because a newer pipeline started for the same ref\n"
1104 for _, item := range found {
1105 if item.status == "running" {
1106 running = append(running, item.id)
1107 continue
1108 }
1109 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 {
1110 return running, pipes, err
1111 }
1112 }
1113 return running, pipes, nil
1114}
1115
1116// RefreshPipelineStatus berekent de pipelinestatus uit de jobs.
1117func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) {
1118 jobs, err := s.JobsByPipeline(ctx, pipelineID)
1119 if err != nil {
1120 return "", err
1121 }
1122 status := "success"
1123 open := false
1124 manual := false
1125 canceled := false
1126 for _, j := range jobs {
1127 switch j.Status {
1128 case "failed":
1129 if !j.AllowFailure {
1130 status = "failed"
1131 }
1132 case "canceled":
1133 if !j.AllowFailure {
1134 canceled = true
1135 }
1136 case "queued", "running":
1137 open = true
1138 case "manual":
1139 manual = true
1140 }
1141 }
1142 switch {
1143 case open:
1144 // Een harde mislukking wint pas als er niets meer in de wachtrij of
1145 // aan het werk is. Anders blijft de runner latere jobs overslaan.
1146 status = "running"
1147 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = ?`, pipelineID)
1148 case status == "failed":
1149 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID)
1150 case canceled:
1151 status = "canceled"
1152 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'canceled', finished_at = ? WHERE id = ?`, now(), pipelineID)
1153 case manual:
1154 status = "manual"
1155 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID)
1156 default:
1157 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID)
1158 }
1159 return status, err
1160}
1161
1162// ResourceBusy meldt of een andere job in deze repository die groep bezet.
1163func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) {
1164 if group == "" {
1165 return false, nil
1166 }
1167 var n int
1168 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)
1169 return n > 0, err
1170}
1171
1172// RetryJob zet een mislukte of geannuleerde job terug in de wachtrij.
1173func (s *Store) RetryJob(ctx context.Context, id int64) (bool, error) {
1174 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', failure_reason = '', finished_at = NULL WHERE id = ? AND status IN ('failed', 'canceled')`, id)
1175 if err != nil {
1176 return false, err
1177 }
1178 n, _ := res.RowsAffected()
1179 if n == 1 {
1180 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
1181 }
1182 return n == 1, nil
1183}
1184
1185// CancelJob stopt een job die nog niet klaar is.
1186func (s *Store) CancelJob(ctx context.Context, id int64) (bool, error) {
1187 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)
1188 if err != nil {
1189 return false, err
1190 }
1191 n, _ := res.RowsAffected()
1192 return n == 1, nil
1193}
1194
1195// QueueJob zet een handmatige job in de wachtrij.
1196func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
1197 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
1198 if err != nil {
1199 return false, err
1200 }
1201 n, _ := res.RowsAffected()
1202 if n == 1 {
1203 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
1204 }
1205 return n == 1, nil
1206}
1207
1208// SkipJob markeert een job die niet meer hoeft.
1209func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
1210 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id)
1211 return err
1212}
1213
1214// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
1215func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
1216 plain, err := newToken("bgj_")
1217 if err != nil {
1218 return "", err
1219 }
1220 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
1221 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
1222 jobID, hashToken(plain), now())
1223 if err != nil {
1224 return "", err
1225 }
1226 return plain, nil
1227}
1228
1229// JobByToken zoekt een lopende job bij een job-token.
1230func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
1231 if len(token) < 4 || token[:4] != "bgj_" {
1232 return Job{}, errNotFound
1233 }
1234 var jobID int64
1235 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
1236 if errors.Is(err, sql.ErrNoRows) {
1237 return Job{}, errNotFound
1238 }
1239 if err != nil {
1240 return Job{}, err
1241 }
1242 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
1243 if err != nil {
1244 return Job{}, err
1245 }
1246 defer rows.Close()
1247 if !rows.Next() {
1248 return Job{}, errNotFound
1249 }
1250 return scanJob(rows)
1251}
1252
1253// JobByID leest een job van deze repository.
1254func (s *Store) JobByID(ctx context.Context, repoID, id int64) (Job, error) {
1255 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.repo_id = ? AND j.id = ?`, repoID, id)
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// Artifact verwijst naar een bestand uit een job.
1267type Artifact struct {
1268 ID int64
1269 JobID int64
1270 Path string
1271 StoragePath string
1272 Size int64
1273}
1274
1275// AddArtifact registreert een bewaard bestand.
1276func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
1277 var exp any
1278 if expires != nil {
1279 exp = expires.UTC().Format(time.RFC3339)
1280 }
1281 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
1282 jobID, relPath, storagePath, size, exp)
1283 return err
1284}
1285
1286// ListArtifacts toont de bestanden van één job.
1287func (s *Store) ListArtifacts(ctx context.Context, jobID int64) ([]Artifact, error) {
1288 rows, err := s.db.QueryContext(ctx, `SELECT id, job_id, path, storage_path, size FROM artifacts WHERE job_id = ? ORDER BY path`, jobID)
1289 if err != nil {
1290 return nil, err
1291 }
1292 defer rows.Close()
1293 var out []Artifact
1294 for rows.Next() {
1295 var a Artifact
1296 if err := rows.Scan(&a.ID, &a.JobID, &a.Path, &a.StoragePath, &a.Size); err != nil {
1297 return nil, err
1298 }
1299 out = append(out, a)
1300 }
1301 return out, rows.Err()
1302}
1303
1304// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
1305func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
1306 var storage string
1307 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
1308 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
1309 if errors.Is(err, sql.ErrNoRows) {
1310 return "", errNotFound
1311 }
1312 return storage, err
1313}
1314
1315// Release is een publicatie op een commit.
1316type Release struct {
1317 ID int64
1318 RepoID int64
1319 Tag string
1320 CommitSHA string
1321 Name string
1322 Body string
1323 CreatedAt time.Time
1324 Assets []ReleaseAsset
1325}
1326
1327// ReleaseAsset is een bestand bij een release.
1328type ReleaseAsset struct {
1329 Name string
1330 StoragePath string
1331 Size int64
1332}
1333
1334// CreateRelease bewaart de release. De bestanden staan al op storagePath.
1335func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
1336 if err := names.ValidTag(tag); err != nil {
1337 return 0, err
1338 }
1339 tx, err := s.db.BeginTx(ctx, nil)
1340 if err != nil {
1341 return 0, err
1342 }
1343 defer func() { _ = tx.Rollback() }()
1344 var author, job any
1345 if authorID != 0 {
1346 author = authorID
1347 }
1348 if jobID != 0 {
1349 job = jobID
1350 }
1351 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
1352 repoID, tag, sha, name, body, author, job, now())
1353 if err != nil {
1354 if containsUnique(err) {
1355 return 0, i18n.E("err.tagExists", tag)
1356 }
1357 return 0, err
1358 }
1359 id, _ := res.LastInsertId()
1360 for _, a := range assets {
1361 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 {
1362 return 0, err
1363 }
1364 }
1365 if err := tx.Commit(); err != nil {
1366 return 0, err
1367 }
1368 return id, nil
1369}
1370
1371// ListReleases geeft publicaties, nieuwste eerst.
1372func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
1373 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)
1374 if err != nil {
1375 return nil, err
1376 }
1377 defer rows.Close()
1378 var out []Release
1379 for rows.Next() {
1380 var r Release
1381 var created string
1382 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
1383 return nil, err
1384 }
1385 r.CreatedAt = parseTime(created)
1386 out = append(out, r)
1387 }
1388 if err := rows.Err(); err != nil {
1389 return nil, err
1390 }
1391 for i := range out {
1392 assets, err := s.releaseAssets(ctx, out[i].ID)
1393 if err != nil {
1394 return nil, err
1395 }
1396 out[i].Assets = assets
1397 }
1398 return out, nil
1399}
1400
1401// ReleaseByTag leest één release.
1402func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
1403 var r Release
1404 var created string
1405 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).
1406 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
1407 if errors.Is(err, sql.ErrNoRows) {
1408 return Release{}, errNotFound
1409 }
1410 if err != nil {
1411 return Release{}, err
1412 }
1413 r.CreatedAt = parseTime(created)
1414 r.Assets, err = s.releaseAssets(ctx, r.ID)
1415 return r, err
1416}
1417
1418func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
1419 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
1420 if err != nil {
1421 return nil, err
1422 }
1423 defer rows.Close()
1424 var out []ReleaseAsset
1425 for rows.Next() {
1426 var a ReleaseAsset
1427 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
1428 return nil, err
1429 }
1430 out = append(out, a)
1431 }
1432 return out, rows.Err()
1433}
1434
1435func trim(s string, n int) string {
1436 s = string([]rune(s))
1437 if len([]rune(s)) > n {
1438 return string([]rune(s)[:n])
1439 }
1440 return s
1441}
1442
1443func containsUnique(err error) bool {
1444 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
1445}
1446
1447func contains(s, sub string) bool {
1448 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
1449}
1450
1451func indexOf(s, sub string) int {
1452 for i := 0; i+len(sub) <= len(s); i++ {
1453 if s[i:i+len(sub)] == sub {
1454 return i
1455 }
1456 }
1457 return -1
1458}
1459
1460// DeleteReleaseAsset haalt één asset van een release weg en geeft het pad
1461// op schijf terug (om op te ruimen). errNotFound als de naam niet bestaat.
1462func (s *Store) DeleteReleaseAsset(ctx context.Context, releaseID int64, name string) (string, error) {
1463 var path string
1464 err := s.db.QueryRowContext(ctx, `SELECT storage_path FROM release_assets WHERE release_id = ? AND name = ?`, releaseID, name).Scan(&path)
1465 if errors.Is(err, sql.ErrNoRows) {
1466 return "", errNotFound
1467 }
1468 if err != nil {
1469 return "", err
1470 }
1471 _, err = s.db.ExecContext(ctx, `DELETE FROM release_assets WHERE release_id = ? AND name = ?`, releaseID, name)
1472 return path, err
1473}
1474
1475// DeleteRelease verwijdert de release met zijn assets en geeft de paden op
1476// schijf terug. De git-tag blijft staan.
1477func (s *Store) DeleteRelease(ctx context.Context, releaseID int64) ([]string, error) {
1478 assets, err := s.releaseAssets(ctx, releaseID)
1479 if err != nil {
1480 return nil, err
1481 }
1482 tx, err := s.db.BeginTx(ctx, nil)
1483 if err != nil {
1484 return nil, err
1485 }
1486 defer func() { _ = tx.Rollback() }()
1487 if _, err := tx.ExecContext(ctx, `DELETE FROM release_assets WHERE release_id = ?`, releaseID); err != nil {
1488 return nil, err
1489 }
1490 if _, err := tx.ExecContext(ctx, `DELETE FROM releases WHERE id = ?`, releaseID); err != nil {
1491 return nil, err
1492 }
1493 if err := tx.Commit(); err != nil {
1494 return nil, err
1495 }
1496 var paths []string
1497 for _, a := range assets {
1498 paths = append(paths, a.StoragePath)
1499 }
1500 return paths, nil
1501}
1502
1503// Redenen in Job.Reason.
1504const (
1505 ReasonSuperseded = "canceled_by_newer_pipeline"
1506 ReasonManual = "canceled_by_user"
1507)
1508
1509// Obsolete is true voor een job die geannuleerd is omdat een nieuwere
1510// pipeline op dezelfde ref startte.
1511func (j Job) Obsolete() bool { return j.Status == "canceled" && j.Reason == ReasonSuperseded }
1512
1513// CancelReason geeft "superseded" of "manual" voor een geannuleerde job,
1514// anders "".
1515func (j Job) CancelReason() string {
1516 if j.Status != "canceled" {
1517 return ""
1518 }
1519 if j.Reason == ReasonSuperseded {
1520 return "superseded"
1521 }
1522 return "manual"
1523}
1524
1525// FailureReason geeft de reden van een mislukte job (bijv.
1526// job_execution_timeout), anders "".
1527func (j Job) FailureReason() string {
1528 if j.Status != "failed" {
1529 return ""
1530 }
1531 return j.Reason
1532}
1533
1534// PipelineObsolete is true als elke geannuleerde job die telt (geen
1535// allow_failure) obsolete is, en er minstens één is.
1536func PipelineObsolete(jobs []Job) bool {
1537 seen := false
1538 for _, j := range jobs {
1539 if j.Status != "canceled" || j.AllowFailure {
1540 continue
1541 }
1542 if !j.Obsolete() {
1543 return false
1544 }
1545 seen = true
1546 }
1547 return seen
1548}