BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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