BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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