BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

fix: sla latere stages over na een harde mislukking
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
ceb7aa19 History
flow.go 25.6 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// NewJob is een job die nog de wachtrij in moet.
233type NewJob struct {
234 Name string
235 Stage string
236 Position int
237 Image string
238 Before string
239 Script string
240 After string
241 Needs []string
242 Optional []string
243 NeedsSet bool
244 Variables map[string]string
245 ArtifactPaths []string
246 ArtifactExpire time.Duration
247 AllowFailure bool
248 When string
249 Timeout time.Duration
250 Tags []string
251 CachePaths []string
252 CacheKey string
253 ResourceGroup string
254}
255
256// Pipeline is een draai van blue-ci-cd.yml.
257type Pipeline struct {
258 ID int64
259 RepoID int64
260 CommitSHA string
261 Ref string
262 Status string
263 Source string
264 Actor string
265 CommitTitle string
266 CreatedAt time.Time
267 StartedAt time.Time
268 FinishedAt time.Time
269}
270
271// Job is één container in een pipeline.
272type Job struct {
273 ID int64
274 PipelineID int64
275 RepoID int64
276 Name string
277 Stage string
278 Position int
279 Status string
280 Image string
281 Before string
282 Script string
283 After string
284 Needs []string
285 Optional []string
286 NeedsSet bool
287 Variables map[string]string
288 ArtifactPaths []string
289 ArtifactExpire time.Duration
290 AllowFailure bool
291 When string
292 Timeout time.Duration
293 Tags []string
294 CachePaths []string
295 CacheKey string
296 ResourceGroup string
297 Log string
298 CommitSHA string
299 Ref string
300 StartedAt time.Time
301 FinishedAt time.Time
302}
303
304// RecordConfigFailure bewaart een pipeline die niet kon starten.
305func (s *Store) RecordConfigFailure(ctx context.Context, repoID int64, sha, ref, message string) error {
306 tx, err := s.db.BeginTx(ctx, nil)
307 if err != nil {
308 return err
309 }
310 defer func() { _ = tx.Rollback() }()
311 ts := now()
312 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)
313 if err != nil {
314 return err
315 }
316 id, _ := res.LastInsertId()
317 _, 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)
318 VALUES (?, ?, 'blue-ci-cd', 'test', 0, 'failed', 'alpine:3.20', 'exit 1', '[]', 0, '{}', '[]', 0, 0, ?, ?)`, id, repoID, message, ts)
319 if err != nil {
320 return err
321 }
322 return tx.Commit()
323}
324
325// CreatePipeline maakt een pipeline met jobs in de wachtrij.
326func (s *Store) CreatePipeline(ctx context.Context, repoID int64, sha, ref, source, actor, title string, jobs []NewJob) (int64, error) {
327 tx, err := s.db.BeginTx(ctx, nil)
328 if err != nil {
329 return 0, err
330 }
331 defer func() { _ = tx.Rollback() }()
332 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())
333 if err != nil {
334 return 0, err
335 }
336 id, _ := res.LastInsertId()
337 for _, j := range jobs {
338 if j.Variables == nil {
339 j.Variables = map[string]string{}
340 }
341 if j.Needs == nil {
342 j.Needs = []string{}
343 }
344 if j.ArtifactPaths == nil {
345 j.ArtifactPaths = []string{}
346 }
347 if j.Optional == nil {
348 j.Optional = []string{}
349 }
350 if j.Tags == nil {
351 j.Tags = []string{}
352 }
353 if j.CachePaths == nil {
354 j.CachePaths = []string{}
355 }
356 if j.When == "" {
357 j.When = "on_success"
358 }
359 status := "queued"
360 if j.When == "manual" {
361 status = "manual"
362 }
363 _, 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)
364 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
365 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),
366 j.Before, j.After, j.When, int(j.Timeout/time.Second), mustJSON(j.Tags), mustJSON(j.CachePaths), j.CacheKey, j.ResourceGroup, mustJSON(j.Optional))
367 if err != nil {
368 return 0, err
369 }
370 }
371 if err := tx.Commit(); err != nil {
372 return 0, err
373 }
374 return id, nil
375}
376
377// ListPipelines geeft de nieuwste pipelines.
378func (s *Store) ListPipelines(ctx context.Context, repoID int64) ([]Pipeline, error) {
379 rows, err := s.db.QueryContext(ctx, pipelineCols+` WHERE repo_id = ? ORDER BY id DESC LIMIT 50`, repoID)
380 if err != nil {
381 return nil, err
382 }
383 defer rows.Close()
384 var out []Pipeline
385 for rows.Next() {
386 p, err := scanPipeline(rows)
387 if err != nil {
388 return nil, err
389 }
390 out = append(out, p)
391 }
392 return out, rows.Err()
393}
394
395const pipelineCols = `SELECT id, repo_id, commit_sha, ref, status, created_at, finished_at, source, actor, commit_title, started_at FROM pipelines`
396
397func scanPipeline(rows *sql.Rows) (Pipeline, error) {
398 return scanPipelineRow(rows)
399}
400
401func scanPipelineRow(sc scanner) (Pipeline, error) {
402 var p Pipeline
403 var created, finished, started sql.NullString
404 if err := sc.Scan(&p.ID, &p.RepoID, &p.CommitSHA, &p.Ref, &p.Status, &created, &finished, &p.Source, &p.Actor, &p.CommitTitle, &started); err != nil {
405 return Pipeline{}, err
406 }
407 p.CreatedAt = parseTime(created.String)
408 p.FinishedAt = parseTime(finished.String)
409 p.StartedAt = parseTime(started.String)
410 return p, nil
411}
412
413type scanner interface {
414 Scan(dest ...any) error
415}
416
417// PipelineByID leest één pipeline.
418func (s *Store) PipelineByID(ctx context.Context, repoID, id int64) (Pipeline, error) {
419 p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND id = ?`, repoID, id))
420 if errors.Is(err, sql.ErrNoRows) {
421 return Pipeline{}, errNotFound
422 }
423 return p, err
424}
425
426// JobsByPipeline geeft de jobs in bestandsvolgorde.
427func (s *Store) JobsByPipeline(ctx context.Context, pipelineID int64) ([]Job, error) {
428 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.pipeline_id = ? ORDER BY j.position, j.id`, pipelineID)
429 if err != nil {
430 return nil, err
431 }
432 defer rows.Close()
433 var out []Job
434 for rows.Next() {
435 j, err := scanJob(rows)
436 if err != nil {
437 return nil, err
438 }
439 out = append(out, j)
440 }
441 return out, rows.Err()
442}
443
444const 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
445FROM jobs j JOIN pipelines p ON p.id = j.pipeline_id`
446
447func scanJob(rows *sql.Rows) (Job, error) {
448 var j Job
449 var needs, vars, paths, tags, cache, optional string
450 var needsSet, allow, expire, timeout int
451 var started, finished sql.NullString
452 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); err != nil {
453 return Job{}, err
454 }
455 j.NeedsSet = needsSet == 1
456 j.AllowFailure = allow == 1
457 j.ArtifactExpire = time.Duration(expire) * time.Second
458 j.Timeout = time.Duration(timeout) * time.Second
459 j.StartedAt = parseTime(started.String)
460 j.FinishedAt = parseTime(finished.String)
461 _ = json.Unmarshal([]byte(needs), &j.Needs)
462 _ = json.Unmarshal([]byte(vars), &j.Variables)
463 _ = json.Unmarshal([]byte(paths), &j.ArtifactPaths)
464 _ = json.Unmarshal([]byte(tags), &j.Tags)
465 _ = json.Unmarshal([]byte(cache), &j.CachePaths)
466 _ = json.Unmarshal([]byte(optional), &j.Optional)
467 return j, nil
468}
469
470// ActivePipelines zijn nog niet af.
471func (s *Store) ActivePipelines(ctx context.Context) ([]Pipeline, error) {
472 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`)
473 if err != nil {
474 return nil, err
475 }
476 defer rows.Close()
477 var out []Pipeline
478 for rows.Next() {
479 p, err := scanPipeline(rows)
480 if err != nil {
481 return nil, err
482 }
483 out = append(out, p)
484 }
485 return out, rows.Err()
486}
487
488// MarkJobRunning zet een wachtende job op running als hij dat nog is.
489func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) {
490 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'running', started_at = ? WHERE id = ? AND status = 'queued'`, now(), id)
491 if err != nil {
492 return false, err
493 }
494 n, _ := res.RowsAffected()
495 if n == 1 {
496 _, _ = 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)
497 }
498 return n == 1, nil
499}
500
501// FinishJob schrijft het eindresultaat en het log.
502func (s *Store) FinishJob(ctx context.Context, id int64, status, extra string) error {
503 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = log || ?, finished_at = ? WHERE id = ?`, status, extra, now(), id)
504 return err
505}
506
507// AppendJobLog voegt tekst toe terwijl de job loopt.
508func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error {
509 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id)
510 return err
511}
512
513// RefreshPipelineStatus berekent de pipelinestatus uit de jobs.
514func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) {
515 jobs, err := s.JobsByPipeline(ctx, pipelineID)
516 if err != nil {
517 return "", err
518 }
519 status := "success"
520 open := false
521 manual := false
522 for _, j := range jobs {
523 switch j.Status {
524 case "failed":
525 if !j.AllowFailure {
526 status = "failed"
527 }
528 case "queued", "running":
529 open = true
530 case "manual":
531 manual = true
532 }
533 }
534 switch {
535 case open:
536 // Een harde mislukking wint pas als er niets meer in de wachtrij of
537 // aan het werk is. Anders blijft de runner latere jobs overslaan.
538 status = "running"
539 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = ?`, pipelineID)
540 case status == "failed":
541 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID)
542 case manual:
543 status = "manual"
544 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID)
545 default:
546 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID)
547 }
548 return status, err
549}
550
551// ResourceBusy meldt of een andere job in deze repository die groep bezet.
552func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) {
553 if group == "" {
554 return false, nil
555 }
556 var n int
557 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)
558 return n > 0, err
559}
560
561// QueueJob zet een handmatige job in de wachtrij.
562func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
563 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
564 if err != nil {
565 return false, err
566 }
567 n, _ := res.RowsAffected()
568 if n == 1 {
569 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
570 }
571 return n == 1, nil
572}
573
574// SkipJob markeert een job die niet meer hoeft.
575func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
576 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id)
577 return err
578}
579
580// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
581func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
582 plain, err := newToken("bgj_")
583 if err != nil {
584 return "", err
585 }
586 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
587 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
588 jobID, hashToken(plain), now())
589 if err != nil {
590 return "", err
591 }
592 return plain, nil
593}
594
595// JobByToken zoekt een lopende job bij een job-token.
596func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
597 if len(token) < 4 || token[:4] != "bgj_" {
598 return Job{}, errNotFound
599 }
600 var jobID int64
601 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
602 if errors.Is(err, sql.ErrNoRows) {
603 return Job{}, errNotFound
604 }
605 if err != nil {
606 return Job{}, err
607 }
608 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
609 if err != nil {
610 return Job{}, err
611 }
612 defer rows.Close()
613 if !rows.Next() {
614 return Job{}, errNotFound
615 }
616 return scanJob(rows)
617}
618
619// Artifact verwijst naar een bestand uit een job.
620type Artifact struct {
621 ID int64
622 JobID int64
623 Path string
624 StoragePath string
625 Size int64
626}
627
628// AddArtifact registreert een bewaard bestand.
629func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
630 var exp any
631 if expires != nil {
632 exp = expires.UTC().Format(time.RFC3339)
633 }
634 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
635 jobID, relPath, storagePath, size, exp)
636 return err
637}
638
639// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
640func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
641 var storage string
642 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
643 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
644 if errors.Is(err, sql.ErrNoRows) {
645 return "", errNotFound
646 }
647 return storage, err
648}
649
650// Release is een publicatie op een commit.
651type Release struct {
652 ID int64
653 RepoID int64
654 Tag string
655 CommitSHA string
656 Name string
657 Body string
658 CreatedAt time.Time
659 Assets []ReleaseAsset
660}
661
662// ReleaseAsset is een bestand bij een release.
663type ReleaseAsset struct {
664 Name string
665 StoragePath string
666 Size int64
667}
668
669// CreateRelease bewaart de release. De bestanden staan al op storagePath.
670func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
671 if err := names.ValidTag(tag); err != nil {
672 return 0, err
673 }
674 tx, err := s.db.BeginTx(ctx, nil)
675 if err != nil {
676 return 0, err
677 }
678 defer func() { _ = tx.Rollback() }()
679 var author, job any
680 if authorID != 0 {
681 author = authorID
682 }
683 if jobID != 0 {
684 job = jobID
685 }
686 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
687 repoID, tag, sha, name, body, author, job, now())
688 if err != nil {
689 if containsUnique(err) {
690 return 0, i18n.E("err.tagExists", tag)
691 }
692 return 0, err
693 }
694 id, _ := res.LastInsertId()
695 for _, a := range assets {
696 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 {
697 return 0, err
698 }
699 }
700 if err := tx.Commit(); err != nil {
701 return 0, err
702 }
703 return id, nil
704}
705
706// ListReleases geeft publicaties, nieuwste eerst.
707func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
708 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)
709 if err != nil {
710 return nil, err
711 }
712 defer rows.Close()
713 var out []Release
714 for rows.Next() {
715 var r Release
716 var created string
717 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
718 return nil, err
719 }
720 r.CreatedAt = parseTime(created)
721 out = append(out, r)
722 }
723 if err := rows.Err(); err != nil {
724 return nil, err
725 }
726 for i := range out {
727 assets, err := s.releaseAssets(ctx, out[i].ID)
728 if err != nil {
729 return nil, err
730 }
731 out[i].Assets = assets
732 }
733 return out, nil
734}
735
736// ReleaseByTag leest één release.
737func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
738 var r Release
739 var created string
740 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).
741 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
742 if errors.Is(err, sql.ErrNoRows) {
743 return Release{}, errNotFound
744 }
745 if err != nil {
746 return Release{}, err
747 }
748 r.CreatedAt = parseTime(created)
749 r.Assets, err = s.releaseAssets(ctx, r.ID)
750 return r, err
751}
752
753func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
754 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
755 if err != nil {
756 return nil, err
757 }
758 defer rows.Close()
759 var out []ReleaseAsset
760 for rows.Next() {
761 var a ReleaseAsset
762 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
763 return nil, err
764 }
765 out = append(out, a)
766 }
767 return out, rows.Err()
768}
769
770func trim(s string, n int) string {
771 s = string([]rune(s))
772 if len([]rune(s)) > n {
773 return string([]rune(s)[:n])
774 }
775 return s
776}
777
778func containsUnique(err error) bool {
779 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
780}
781
782func contains(s, sub string) bool {
783 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
784}
785
786func indexOf(s, sub string) int {
787 for i := 0; i+len(sub) <= len(s); i++ {
788 if s[i:i+len(sub)] == sub {
789 return i
790 }
791 }
792 return -1
793}