BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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