BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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