BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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