BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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