BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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