BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

flow.go 53.3 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 for _, j := range jobs {
1131 switch j.Status {
1132 case "failed":
1133 if !j.AllowFailure {
1134 status = "failed"
1135 }
1136 case "canceled":
1137 if !j.AllowFailure {
1138 canceled = true
1139 }
1140 case "queued", "running":
1141 open = true
1142 case "manual":
1143 manual = true
1144 }
1145 }
1146 switch {
1147 case open:
1148 // Een harde mislukking wint pas als er niets meer in de wachtrij of
1149 // aan het werk is. Anders blijft de runner latere jobs overslaan.
1150 status = "running"
1151 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = ?`, pipelineID)
1152 case status == "failed":
1153 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID)
1154 case canceled:
1155 status = "canceled"
1156 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'canceled', finished_at = ? WHERE id = ?`, now(), pipelineID)
1157 case manual:
1158 status = "manual"
1159 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID)
1160 default:
1161 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID)
1162 }
1163 return status, err
1164}
1165
1166// ResourceBusy meldt of een andere job in deze repository die groep bezet.
1167func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) {
1168 if group == "" {
1169 return false, nil
1170 }
1171 var n int
1172 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)
1173 return n > 0, err
1174}
1175
1176// RetryJob zet een mislukte of geannuleerde job terug in de wachtrij.
1177func (s *Store) RetryJob(ctx context.Context, id int64) (bool, error) {
1178 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', failure_reason = '', finished_at = NULL WHERE id = ? AND status IN ('failed', 'canceled')`, id)
1179 if err != nil {
1180 return false, err
1181 }
1182 n, _ := res.RowsAffected()
1183 if n == 1 {
1184 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
1185 }
1186 return n == 1, nil
1187}
1188
1189// CancelJob stopt een job die nog niet klaar is.
1190func (s *Store) CancelJob(ctx context.Context, id int64) (bool, error) {
1191 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)
1192 if err != nil {
1193 return false, err
1194 }
1195 n, _ := res.RowsAffected()
1196 return n == 1, nil
1197}
1198
1199// QueueJob zet een handmatige job in de wachtrij.
1200func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
1201 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
1202 if err != nil {
1203 return false, err
1204 }
1205 n, _ := res.RowsAffected()
1206 if n == 1 {
1207 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
1208 }
1209 return n == 1, nil
1210}
1211
1212// SkipJob markeert een job die niet meer hoeft.
1213func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
1214 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id)
1215 return err
1216}
1217
1218// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
1219func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
1220 plain, err := newToken("bgj_")
1221 if err != nil {
1222 return "", err
1223 }
1224 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
1225 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
1226 jobID, hashToken(plain), now())
1227 if err != nil {
1228 return "", err
1229 }
1230 return plain, nil
1231}
1232
1233// JobByToken zoekt een lopende job bij een job-token.
1234func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
1235 if len(token) < 4 || token[:4] != "bgj_" {
1236 return Job{}, errNotFound
1237 }
1238 var jobID int64
1239 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
1240 if errors.Is(err, sql.ErrNoRows) {
1241 return Job{}, errNotFound
1242 }
1243 if err != nil {
1244 return Job{}, err
1245 }
1246 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
1247 if err != nil {
1248 return Job{}, err
1249 }
1250 defer rows.Close()
1251 if !rows.Next() {
1252 return Job{}, errNotFound
1253 }
1254 return scanJob(rows)
1255}
1256
1257// JobByID leest een job van deze repository.
1258func (s *Store) JobByID(ctx context.Context, repoID, id int64) (Job, error) {
1259 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.repo_id = ? AND j.id = ?`, repoID, id)
1260 if err != nil {
1261 return Job{}, err
1262 }
1263 defer rows.Close()
1264 if !rows.Next() {
1265 return Job{}, errNotFound
1266 }
1267 return scanJob(rows)
1268}
1269
1270// Artifact verwijst naar een bestand uit een job.
1271type Artifact struct {
1272 ID int64
1273 JobID int64
1274 Path string
1275 StoragePath string
1276 Size int64
1277}
1278
1279// AddArtifact registreert een bewaard bestand.
1280func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
1281 var exp any
1282 if expires != nil {
1283 exp = expires.UTC().Format(time.RFC3339)
1284 }
1285 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
1286 jobID, relPath, storagePath, size, exp)
1287 return err
1288}
1289
1290// ListArtifacts toont de bestanden van één job.
1291func (s *Store) ListArtifacts(ctx context.Context, jobID int64) ([]Artifact, error) {
1292 rows, err := s.db.QueryContext(ctx, `SELECT id, job_id, path, storage_path, size FROM artifacts WHERE job_id = ? ORDER BY path`, jobID)
1293 if err != nil {
1294 return nil, err
1295 }
1296 defer rows.Close()
1297 var out []Artifact
1298 for rows.Next() {
1299 var a Artifact
1300 if err := rows.Scan(&a.ID, &a.JobID, &a.Path, &a.StoragePath, &a.Size); err != nil {
1301 return nil, err
1302 }
1303 out = append(out, a)
1304 }
1305 return out, rows.Err()
1306}
1307
1308// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
1309func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
1310 var storage string
1311 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
1312 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
1313 if errors.Is(err, sql.ErrNoRows) {
1314 return "", errNotFound
1315 }
1316 return storage, err
1317}
1318
1319// Release is een publicatie op een commit.
1320type Release struct {
1321 ID int64
1322 RepoID int64
1323 Tag string
1324 CommitSHA string
1325 Name string
1326 Body string
1327 CreatedAt time.Time
1328 Assets []ReleaseAsset
1329}
1330
1331// ReleaseAsset is een bestand bij een release.
1332type ReleaseAsset struct {
1333 Name string
1334 StoragePath string
1335 Size int64
1336}
1337
1338// CreateRelease bewaart de release. De bestanden staan al op storagePath.
1339func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
1340 if err := names.ValidTag(tag); err != nil {
1341 return 0, err
1342 }
1343 tx, err := s.db.BeginTx(ctx, nil)
1344 if err != nil {
1345 return 0, err
1346 }
1347 defer func() { _ = tx.Rollback() }()
1348 var author, job any
1349 if authorID != 0 {
1350 author = authorID
1351 }
1352 if jobID != 0 {
1353 job = jobID
1354 }
1355 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
1356 repoID, tag, sha, name, body, author, job, now())
1357 if err != nil {
1358 if containsUnique(err) {
1359 return 0, i18n.E("err.tagExists", tag)
1360 }
1361 return 0, err
1362 }
1363 id, _ := res.LastInsertId()
1364 for _, a := range assets {
1365 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 {
1366 return 0, err
1367 }
1368 }
1369 if err := tx.Commit(); err != nil {
1370 return 0, err
1371 }
1372 return id, nil
1373}
1374
1375// ListReleases geeft publicaties, nieuwste eerst.
1376func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
1377 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)
1378 if err != nil {
1379 return nil, err
1380 }
1381 defer rows.Close()
1382 var out []Release
1383 for rows.Next() {
1384 var r Release
1385 var created string
1386 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
1387 return nil, err
1388 }
1389 r.CreatedAt = parseTime(created)
1390 out = append(out, r)
1391 }
1392 if err := rows.Err(); err != nil {
1393 return nil, err
1394 }
1395 for i := range out {
1396 assets, err := s.releaseAssets(ctx, out[i].ID)
1397 if err != nil {
1398 return nil, err
1399 }
1400 out[i].Assets = assets
1401 }
1402 return out, nil
1403}
1404
1405// ReleaseByTag leest één release.
1406func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
1407 var r Release
1408 var created string
1409 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).
1410 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
1411 if errors.Is(err, sql.ErrNoRows) {
1412 return Release{}, errNotFound
1413 }
1414 if err != nil {
1415 return Release{}, err
1416 }
1417 r.CreatedAt = parseTime(created)
1418 r.Assets, err = s.releaseAssets(ctx, r.ID)
1419 return r, err
1420}
1421
1422func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
1423 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
1424 if err != nil {
1425 return nil, err
1426 }
1427 defer rows.Close()
1428 var out []ReleaseAsset
1429 for rows.Next() {
1430 var a ReleaseAsset
1431 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
1432 return nil, err
1433 }
1434 out = append(out, a)
1435 }
1436 return out, rows.Err()
1437}
1438
1439func trim(s string, n int) string {
1440 s = string([]rune(s))
1441 if len([]rune(s)) > n {
1442 return string([]rune(s)[:n])
1443 }
1444 return s
1445}
1446
1447func containsUnique(err error) bool {
1448 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
1449}
1450
1451func contains(s, sub string) bool {
1452 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
1453}
1454
1455func indexOf(s, sub string) int {
1456 for i := 0; i+len(sub) <= len(s); i++ {
1457 if s[i:i+len(sub)] == sub {
1458 return i
1459 }
1460 }
1461 return -1
1462}
1463
1464// DeleteReleaseAsset haalt één asset van een release weg en geeft het pad
1465// op schijf terug (om op te ruimen). errNotFound als de naam niet bestaat.
1466func (s *Store) DeleteReleaseAsset(ctx context.Context, releaseID int64, name string) (string, error) {
1467 var path string
1468 err := s.db.QueryRowContext(ctx, `SELECT storage_path FROM release_assets WHERE release_id = ? AND name = ?`, releaseID, name).Scan(&path)
1469 if errors.Is(err, sql.ErrNoRows) {
1470 return "", errNotFound
1471 }
1472 if err != nil {
1473 return "", err
1474 }
1475 _, err = s.db.ExecContext(ctx, `DELETE FROM release_assets WHERE release_id = ? AND name = ?`, releaseID, name)
1476 return path, err
1477}
1478
1479// DeleteRelease verwijdert de release met zijn assets en geeft de paden op
1480// schijf terug. De git-tag blijft staan.
1481func (s *Store) DeleteRelease(ctx context.Context, releaseID int64) ([]string, error) {
1482 assets, err := s.releaseAssets(ctx, releaseID)
1483 if err != nil {
1484 return nil, err
1485 }
1486 tx, err := s.db.BeginTx(ctx, nil)
1487 if err != nil {
1488 return nil, err
1489 }
1490 defer func() { _ = tx.Rollback() }()
1491 if _, err := tx.ExecContext(ctx, `DELETE FROM release_assets WHERE release_id = ?`, releaseID); err != nil {
1492 return nil, err
1493 }
1494 if _, err := tx.ExecContext(ctx, `DELETE FROM releases WHERE id = ?`, releaseID); err != nil {
1495 return nil, err
1496 }
1497 if err := tx.Commit(); err != nil {
1498 return nil, err
1499 }
1500 var paths []string
1501 for _, a := range assets {
1502 paths = append(paths, a.StoragePath)
1503 }
1504 return paths, nil
1505}
1506
1507// Redenen in Job.Reason.
1508const (
1509 ReasonSuperseded = "canceled_by_newer_pipeline"
1510 ReasonManual = "canceled_by_user"
1511)
1512
1513// Obsolete is true voor een job die geannuleerd is omdat een nieuwere
1514// pipeline op dezelfde ref startte.
1515func (j Job) Obsolete() bool { return j.Status == "canceled" && j.Reason == ReasonSuperseded }
1516
1517// CancelReason geeft "superseded" of "manual" voor een geannuleerde job,
1518// anders "".
1519func (j Job) CancelReason() string {
1520 if j.Status != "canceled" {
1521 return ""
1522 }
1523 if j.Reason == ReasonSuperseded {
1524 return "superseded"
1525 }
1526 return "manual"
1527}
1528
1529// FailureReason geeft de reden van een mislukte job (bijv.
1530// job_execution_timeout), anders "".
1531func (j Job) FailureReason() string {
1532 if j.Status != "failed" {
1533 return ""
1534 }
1535 return j.Reason
1536}
1537
1538// PipelineObsolete is true als elke geannuleerde job die telt (geen
1539// allow_failure) obsolete is, en er minstens één is.
1540func PipelineObsolete(jobs []Job) bool {
1541 seen := false
1542 for _, j := range jobs {
1543 if j.Status != "canceled" || j.AllowFailure {
1544 continue
1545 }
1546 if !j.Obsolete() {
1547 return false
1548 }
1549 seen = true
1550 }
1551 return seen
1552}
1553
1554// ProtectedBlocker zoekt een lopende doNotInterrupt-job in een oudere
1555// pipeline op dezelfde ref. Zolang die er is, wacht pipeline pipelineID.
1556func (s *Store) ProtectedBlocker(ctx context.Context, repoID int64, ref string, pipelineID int64) (Job, bool) {
1557 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)
1558 if err != nil {
1559 return Job{}, false
1560 }
1561 defer rows.Close()
1562 if !rows.Next() {
1563 return Job{}, false
1564 }
1565 j, err := scanJob(rows)
1566 return j, err == nil
1567}
1568
1569// RunningProtectedJobs geeft lopende doNotInterrupt-jobs. Met repoID > 0
1570// alleen in die repo; met runnerID > 0 alleen op die aparte runner.
1571func (s *Store) RunningProtectedJobs(ctx context.Context, repoID, runnerID int64) ([]Job, error) {
1572 q := jobSelect + ` WHERE j.status = 'running' AND j.do_not_interrupt = 1`
1573 var args []any
1574 if repoID > 0 {
1575 q += ` AND j.repo_id = ?`
1576 args = append(args, repoID)
1577 }
1578 if runnerID > 0 {
1579 q += ` AND j.id IN (SELECT job_id FROM job_runs WHERE runner_id = ?)`
1580 args = append(args, runnerID)
1581 }
1582 rows, err := s.db.QueryContext(ctx, q+` ORDER BY j.id`, args...)
1583 if err != nil {
1584 return nil, err
1585 }
1586 defer rows.Close()
1587 var out []Job
1588 for rows.Next() {
1589 j, err := scanJob(rows)
1590 if err != nil {
1591 return nil, err
1592 }
1593 out = append(out, j)
1594 }
1595 return out, rows.Err()
1596}
1597
1598// ProtectedRunning filtert de lopende doNotInterrupt-jobs uit jobs.
1599func ProtectedRunning(jobs []Job) []Job {
1600 var out []Job
1601 for _, j := range jobs {
1602 if j.Status == "running" && j.DoNotInterrupt {
1603 out = append(out, j)
1604 }
1605 }
1606 return out
1607}