BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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