BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

fix: laat self_update wachten tot de update ok is
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed 91694978 History
flow.go 45.4 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.
938// self_update blijft buiten de telling. Die job polt tot deze update
939// status ok heeft. Meerekenen laat wait_until_idle op die poll wachten,
940// en de poll op pacman -U.
941func (s *Store) CountRunningJobs(ctx context.Context) (int, error) {
942 var n int
943 err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs WHERE status = 'running' AND name != 'self_update'`).Scan(&n)
944 return n, err
945}
946
947// FinishJob schrijft het eindresultaat en het log.
948func (s *Store) FinishJob(ctx context.Context, id int64, status, extra string) error {
949 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = log || ?, finished_at = ? WHERE id = ?`, status, extra, now(), id)
950 return err
951}
952
953// AppendJobLog voegt tekst toe terwijl de job loopt.
954func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error {
955 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id)
956 return err
957}
958
959// RequeueJob zet een mislukte job terug in de wachtrij voor een nieuwe poging.
960func (s *Store) RequeueJob(ctx context.Context, id int64, attempt int, note string) error {
961 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', attempt = ?, log = log || ?, finished_at = NULL, started_at = NULL WHERE id = ?`, attempt, note, id)
962 return err
963}
964
965// CancelInterruptible annuleert onderbreekbare jobs van oudere pipelines op dezelfde ref.
966// Lopende jobs komen terug zodat de runner hun context kan stoppen.
967func (s *Store) CancelInterruptible(ctx context.Context, repoID int64, ref string, keep int64) (running []int64, pipes []int64, err error) {
968 rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.status FROM jobs j
969 JOIN pipelines p ON p.id = j.pipeline_id
970 WHERE p.repo_id = ? AND p.ref = ? AND p.id != ? AND j.interruptible = 1 AND j.status IN ('queued', 'running', 'manual')`, repoID, ref, keep)
971 if err != nil {
972 return nil, nil, err
973 }
974 defer rows.Close()
975 type row struct {
976 id, pipe int64
977 status string
978 }
979 var found []row
980 seenPipe := map[int64]bool{}
981 for rows.Next() {
982 var item row
983 if err := rows.Scan(&item.id, &item.pipe, &item.status); err != nil {
984 return nil, nil, err
985 }
986 found = append(found, item)
987 if !seenPipe[item.pipe] {
988 seenPipe[item.pipe] = true
989 pipes = append(pipes, item.pipe)
990 }
991 }
992 if err := rows.Err(); err != nil {
993 return nil, nil, err
994 }
995 note := time.Now().UTC().Format(time.RFC3339) + "\tcanceled because a newer pipeline started for the same ref\n"
996 for _, item := range found {
997 if item.status == "running" {
998 running = append(running, item.id)
999 continue
1000 }
1001 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 {
1002 return running, pipes, err
1003 }
1004 }
1005 return running, pipes, nil
1006}
1007
1008// RefreshPipelineStatus berekent de pipelinestatus uit de jobs.
1009func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) {
1010 jobs, err := s.JobsByPipeline(ctx, pipelineID)
1011 if err != nil {
1012 return "", err
1013 }
1014 status := "success"
1015 open := false
1016 manual := false
1017 canceled := false
1018 for _, j := range jobs {
1019 switch j.Status {
1020 case "failed":
1021 if !j.AllowFailure {
1022 status = "failed"
1023 }
1024 case "canceled":
1025 if !j.AllowFailure {
1026 canceled = true
1027 }
1028 case "queued", "running":
1029 open = true
1030 case "manual":
1031 manual = true
1032 }
1033 }
1034 switch {
1035 case open:
1036 // Een harde mislukking wint pas als er niets meer in de wachtrij of
1037 // aan het werk is. Anders blijft de runner latere jobs overslaan.
1038 status = "running"
1039 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = ?`, pipelineID)
1040 case status == "failed":
1041 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID)
1042 case canceled:
1043 status = "canceled"
1044 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'canceled', finished_at = ? WHERE id = ?`, now(), pipelineID)
1045 case manual:
1046 status = "manual"
1047 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID)
1048 default:
1049 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID)
1050 }
1051 return status, err
1052}
1053
1054// ResourceBusy meldt of een andere job in deze repository die groep bezet.
1055func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) {
1056 if group == "" {
1057 return false, nil
1058 }
1059 var n int
1060 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)
1061 return n > 0, err
1062}
1063
1064// RetryJob zet een mislukte of geannuleerde job terug in de wachtrij.
1065func (s *Store) RetryJob(ctx context.Context, id int64) (bool, error) {
1066 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', finished_at = NULL WHERE id = ? AND status IN ('failed', 'canceled')`, id)
1067 if err != nil {
1068 return false, err
1069 }
1070 n, _ := res.RowsAffected()
1071 if n == 1 {
1072 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
1073 }
1074 return n == 1, nil
1075}
1076
1077// CancelJob stopt een job die nog niet klaar is.
1078func (s *Store) CancelJob(ctx context.Context, id int64) (bool, error) {
1079 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)
1080 if err != nil {
1081 return false, err
1082 }
1083 n, _ := res.RowsAffected()
1084 return n == 1, nil
1085}
1086
1087// QueueJob zet een handmatige job in de wachtrij.
1088func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
1089 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
1090 if err != nil {
1091 return false, err
1092 }
1093 n, _ := res.RowsAffected()
1094 if n == 1 {
1095 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
1096 }
1097 return n == 1, nil
1098}
1099
1100// SkipJob markeert een job die niet meer hoeft.
1101func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
1102 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id)
1103 return err
1104}
1105
1106// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
1107func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
1108 plain, err := newToken("bgj_")
1109 if err != nil {
1110 return "", err
1111 }
1112 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
1113 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
1114 jobID, hashToken(plain), now())
1115 if err != nil {
1116 return "", err
1117 }
1118 return plain, nil
1119}
1120
1121// JobByToken zoekt een lopende job bij een job-token.
1122func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
1123 if len(token) < 4 || token[:4] != "bgj_" {
1124 return Job{}, errNotFound
1125 }
1126 var jobID int64
1127 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
1128 if errors.Is(err, sql.ErrNoRows) {
1129 return Job{}, errNotFound
1130 }
1131 if err != nil {
1132 return Job{}, err
1133 }
1134 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
1135 if err != nil {
1136 return Job{}, err
1137 }
1138 defer rows.Close()
1139 if !rows.Next() {
1140 return Job{}, errNotFound
1141 }
1142 return scanJob(rows)
1143}
1144
1145// JobByID leest een job van deze repository.
1146func (s *Store) JobByID(ctx context.Context, repoID, id int64) (Job, error) {
1147 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.repo_id = ? AND j.id = ?`, repoID, id)
1148 if err != nil {
1149 return Job{}, err
1150 }
1151 defer rows.Close()
1152 if !rows.Next() {
1153 return Job{}, errNotFound
1154 }
1155 return scanJob(rows)
1156}
1157
1158// Artifact verwijst naar een bestand uit een job.
1159type Artifact struct {
1160 ID int64
1161 JobID int64
1162 Path string
1163 StoragePath string
1164 Size int64
1165}
1166
1167// AddArtifact registreert een bewaard bestand.
1168func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
1169 var exp any
1170 if expires != nil {
1171 exp = expires.UTC().Format(time.RFC3339)
1172 }
1173 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
1174 jobID, relPath, storagePath, size, exp)
1175 return err
1176}
1177
1178// ListArtifacts toont de bestanden van één job.
1179func (s *Store) ListArtifacts(ctx context.Context, jobID int64) ([]Artifact, error) {
1180 rows, err := s.db.QueryContext(ctx, `SELECT id, job_id, path, storage_path, size FROM artifacts WHERE job_id = ? ORDER BY path`, jobID)
1181 if err != nil {
1182 return nil, err
1183 }
1184 defer rows.Close()
1185 var out []Artifact
1186 for rows.Next() {
1187 var a Artifact
1188 if err := rows.Scan(&a.ID, &a.JobID, &a.Path, &a.StoragePath, &a.Size); err != nil {
1189 return nil, err
1190 }
1191 out = append(out, a)
1192 }
1193 return out, rows.Err()
1194}
1195
1196// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
1197func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
1198 var storage string
1199 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
1200 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
1201 if errors.Is(err, sql.ErrNoRows) {
1202 return "", errNotFound
1203 }
1204 return storage, err
1205}
1206
1207// Release is een publicatie op een commit.
1208type Release struct {
1209 ID int64
1210 RepoID int64
1211 Tag string
1212 CommitSHA string
1213 Name string
1214 Body string
1215 CreatedAt time.Time
1216 Assets []ReleaseAsset
1217}
1218
1219// ReleaseAsset is een bestand bij een release.
1220type ReleaseAsset struct {
1221 Name string
1222 StoragePath string
1223 Size int64
1224}
1225
1226// CreateRelease bewaart de release. De bestanden staan al op storagePath.
1227func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
1228 if err := names.ValidTag(tag); err != nil {
1229 return 0, err
1230 }
1231 tx, err := s.db.BeginTx(ctx, nil)
1232 if err != nil {
1233 return 0, err
1234 }
1235 defer func() { _ = tx.Rollback() }()
1236 var author, job any
1237 if authorID != 0 {
1238 author = authorID
1239 }
1240 if jobID != 0 {
1241 job = jobID
1242 }
1243 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
1244 repoID, tag, sha, name, body, author, job, now())
1245 if err != nil {
1246 if containsUnique(err) {
1247 return 0, i18n.E("err.tagExists", tag)
1248 }
1249 return 0, err
1250 }
1251 id, _ := res.LastInsertId()
1252 for _, a := range assets {
1253 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 {
1254 return 0, err
1255 }
1256 }
1257 if err := tx.Commit(); err != nil {
1258 return 0, err
1259 }
1260 return id, nil
1261}
1262
1263// ListReleases geeft publicaties, nieuwste eerst.
1264func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
1265 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)
1266 if err != nil {
1267 return nil, err
1268 }
1269 defer rows.Close()
1270 var out []Release
1271 for rows.Next() {
1272 var r Release
1273 var created string
1274 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
1275 return nil, err
1276 }
1277 r.CreatedAt = parseTime(created)
1278 out = append(out, r)
1279 }
1280 if err := rows.Err(); err != nil {
1281 return nil, err
1282 }
1283 for i := range out {
1284 assets, err := s.releaseAssets(ctx, out[i].ID)
1285 if err != nil {
1286 return nil, err
1287 }
1288 out[i].Assets = assets
1289 }
1290 return out, nil
1291}
1292
1293// ReleaseByTag leest één release.
1294func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
1295 var r Release
1296 var created string
1297 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).
1298 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
1299 if errors.Is(err, sql.ErrNoRows) {
1300 return Release{}, errNotFound
1301 }
1302 if err != nil {
1303 return Release{}, err
1304 }
1305 r.CreatedAt = parseTime(created)
1306 r.Assets, err = s.releaseAssets(ctx, r.ID)
1307 return r, err
1308}
1309
1310func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
1311 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
1312 if err != nil {
1313 return nil, err
1314 }
1315 defer rows.Close()
1316 var out []ReleaseAsset
1317 for rows.Next() {
1318 var a ReleaseAsset
1319 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
1320 return nil, err
1321 }
1322 out = append(out, a)
1323 }
1324 return out, rows.Err()
1325}
1326
1327func trim(s string, n int) string {
1328 s = string([]rune(s))
1329 if len([]rune(s)) > n {
1330 return string([]rune(s)[:n])
1331 }
1332 return s
1333}
1334
1335func containsUnique(err error) bool {
1336 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
1337}
1338
1339func contains(s, sub string) bool {
1340 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
1341}
1342
1343func indexOf(s, sub string) int {
1344 for i := 0; i+len(sub) <= len(s); i++ {
1345 if s[i:i+len(sub)] == sub {
1346 return i
1347 }
1348 }
1349 return -1
1350}