BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

feat: breid rules en de ingebouwde runner uit
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
5fec96f0 History
flow.go 31.8 KiB Download Raw
1package store
2
3import (
4 "context"
5 "database/sql"
6 "encoding/json"
7 "errors"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/i18n"
11 "gitlab.com/Timfa/bluegit/internal/names"
12)
13
14// Webhook is een uitgaande melding.
15type Webhook struct {
16 ID int64
17 ScopeKind string
18 ScopeID int64
19 Name string
20 Preset string
21 URLTemplate string
22 Headers map[string]string
23 BodyTemplate string
24 Events []string
25 BranchFilter string
26 Active bool
27 Method string
28}
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// PipelineByID leest één pipeline.
531func (s *Store) PipelineByID(ctx context.Context, repoID, id int64) (Pipeline, error) {
532 p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND id = ?`, repoID, id))
533 if errors.Is(err, sql.ErrNoRows) {
534 return Pipeline{}, errNotFound
535 }
536 return p, err
537}
538
539// JobsByPipeline geeft de jobs in bestandsvolgorde.
540func (s *Store) JobsByPipeline(ctx context.Context, pipelineID int64) ([]Job, error) {
541 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.pipeline_id = ? ORDER BY j.position, j.id`, pipelineID)
542 if err != nil {
543 return nil, err
544 }
545 defer rows.Close()
546 var out []Job
547 for rows.Next() {
548 j, err := scanJob(rows)
549 if err != nil {
550 return nil, err
551 }
552 out = append(out, j)
553 }
554 return out, rows.Err()
555}
556
557const 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
558FROM jobs j JOIN pipelines p ON p.id = j.pipeline_id`
559
560func scanJob(rows *sql.Rows) (Job, error) {
561 var j Job
562 var needs, vars, paths, tags, cache, optional, retryWhen, services string
563 var needsSet, allow, expire, timeout, interruptible int
564 var started, finished sql.NullString
565 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 {
566 return Job{}, err
567 }
568 j.NeedsSet = needsSet == 1
569 j.AllowFailure = allow == 1
570 j.Interruptible = interruptible == 1
571 j.ArtifactExpire = time.Duration(expire) * time.Second
572 j.Timeout = time.Duration(timeout) * time.Second
573 j.StartedAt = parseTime(started.String)
574 j.FinishedAt = parseTime(finished.String)
575 _ = json.Unmarshal([]byte(needs), &j.Needs)
576 _ = json.Unmarshal([]byte(vars), &j.Variables)
577 _ = json.Unmarshal([]byte(paths), &j.ArtifactPaths)
578 _ = json.Unmarshal([]byte(tags), &j.Tags)
579 _ = json.Unmarshal([]byte(cache), &j.CachePaths)
580 _ = json.Unmarshal([]byte(optional), &j.Optional)
581 _ = json.Unmarshal([]byte(retryWhen), &j.RetryWhen)
582 _ = json.Unmarshal([]byte(services), &j.Services)
583 return j, nil
584}
585
586// ActivePipelines zijn nog niet af.
587func (s *Store) ActivePipelines(ctx context.Context) ([]Pipeline, error) {
588 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`)
589 if err != nil {
590 return nil, err
591 }
592 defer rows.Close()
593 var out []Pipeline
594 for rows.Next() {
595 p, err := scanPipeline(rows)
596 if err != nil {
597 return nil, err
598 }
599 out = append(out, p)
600 }
601 return out, rows.Err()
602}
603
604// MarkJobRunning zet een wachtende job op running als hij dat nog is.
605func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) {
606 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'running', started_at = ? WHERE id = ? AND status = 'queued'`, now(), id)
607 if err != nil {
608 return false, err
609 }
610 n, _ := res.RowsAffected()
611 if n == 1 {
612 _, _ = 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)
613 }
614 return n == 1, nil
615}
616
617// FinishJob schrijft het eindresultaat en het log.
618func (s *Store) FinishJob(ctx context.Context, id int64, status, extra string) error {
619 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = log || ?, finished_at = ? WHERE id = ?`, status, extra, now(), id)
620 return err
621}
622
623// AppendJobLog voegt tekst toe terwijl de job loopt.
624func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error {
625 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id)
626 return err
627}
628
629// RequeueJob zet een mislukte job terug in de wachtrij voor een nieuwe poging.
630func (s *Store) RequeueJob(ctx context.Context, id int64, attempt int, note string) error {
631 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', attempt = ?, log = log || ?, finished_at = NULL, started_at = NULL WHERE id = ?`, attempt, note, id)
632 return err
633}
634
635// CancelInterruptible annuleert onderbreekbare jobs van oudere pipelines op dezelfde ref.
636// Lopende jobs komen terug zodat de runner hun context kan stoppen.
637func (s *Store) CancelInterruptible(ctx context.Context, repoID int64, ref string, keep int64) (running []int64, pipes []int64, err error) {
638 rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.status FROM jobs j
639 JOIN pipelines p ON p.id = j.pipeline_id
640 WHERE p.repo_id = ? AND p.ref = ? AND p.id != ? AND j.interruptible = 1 AND j.status IN ('queued', 'running', 'manual')`, repoID, ref, keep)
641 if err != nil {
642 return nil, nil, err
643 }
644 defer rows.Close()
645 type row struct {
646 id, pipe int64
647 status string
648 }
649 var found []row
650 seenPipe := map[int64]bool{}
651 for rows.Next() {
652 var item row
653 if err := rows.Scan(&item.id, &item.pipe, &item.status); err != nil {
654 return nil, nil, err
655 }
656 found = append(found, item)
657 if !seenPipe[item.pipe] {
658 seenPipe[item.pipe] = true
659 pipes = append(pipes, item.pipe)
660 }
661 }
662 if err := rows.Err(); err != nil {
663 return nil, nil, err
664 }
665 note := time.Now().UTC().Format(time.RFC3339) + "\tcanceled because a newer pipeline started for the same ref\n"
666 for _, item := range found {
667 if item.status == "running" {
668 running = append(running, item.id)
669 continue
670 }
671 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 {
672 return running, pipes, err
673 }
674 }
675 return running, pipes, nil
676}
677
678// RefreshPipelineStatus berekent de pipelinestatus uit de jobs.
679func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) {
680 jobs, err := s.JobsByPipeline(ctx, pipelineID)
681 if err != nil {
682 return "", err
683 }
684 status := "success"
685 open := false
686 manual := false
687 canceled := false
688 for _, j := range jobs {
689 switch j.Status {
690 case "failed":
691 if !j.AllowFailure {
692 status = "failed"
693 }
694 case "canceled":
695 if !j.AllowFailure {
696 canceled = true
697 }
698 case "queued", "running":
699 open = true
700 case "manual":
701 manual = true
702 }
703 }
704 switch {
705 case open:
706 // Een harde mislukking wint pas als er niets meer in de wachtrij of
707 // aan het werk is. Anders blijft de runner latere jobs overslaan.
708 status = "running"
709 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = ?`, pipelineID)
710 case status == "failed":
711 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID)
712 case canceled:
713 status = "canceled"
714 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'canceled', finished_at = ? WHERE id = ?`, now(), pipelineID)
715 case manual:
716 status = "manual"
717 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID)
718 default:
719 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID)
720 }
721 return status, err
722}
723
724// ResourceBusy meldt of een andere job in deze repository die groep bezet.
725func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) {
726 if group == "" {
727 return false, nil
728 }
729 var n int
730 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)
731 return n > 0, err
732}
733
734// QueueJob zet een handmatige job in de wachtrij.
735func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
736 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
737 if err != nil {
738 return false, err
739 }
740 n, _ := res.RowsAffected()
741 if n == 1 {
742 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
743 }
744 return n == 1, nil
745}
746
747// SkipJob markeert een job die niet meer hoeft.
748func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
749 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id)
750 return err
751}
752
753// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
754func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
755 plain, err := newToken("bgj_")
756 if err != nil {
757 return "", err
758 }
759 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
760 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
761 jobID, hashToken(plain), now())
762 if err != nil {
763 return "", err
764 }
765 return plain, nil
766}
767
768// JobByToken zoekt een lopende job bij een job-token.
769func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
770 if len(token) < 4 || token[:4] != "bgj_" {
771 return Job{}, errNotFound
772 }
773 var jobID int64
774 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
775 if errors.Is(err, sql.ErrNoRows) {
776 return Job{}, errNotFound
777 }
778 if err != nil {
779 return Job{}, err
780 }
781 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
782 if err != nil {
783 return Job{}, err
784 }
785 defer rows.Close()
786 if !rows.Next() {
787 return Job{}, errNotFound
788 }
789 return scanJob(rows)
790}
791
792// Artifact verwijst naar een bestand uit een job.
793type Artifact struct {
794 ID int64
795 JobID int64
796 Path string
797 StoragePath string
798 Size int64
799}
800
801// AddArtifact registreert een bewaard bestand.
802func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
803 var exp any
804 if expires != nil {
805 exp = expires.UTC().Format(time.RFC3339)
806 }
807 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
808 jobID, relPath, storagePath, size, exp)
809 return err
810}
811
812// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
813func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
814 var storage string
815 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
816 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
817 if errors.Is(err, sql.ErrNoRows) {
818 return "", errNotFound
819 }
820 return storage, err
821}
822
823// Release is een publicatie op een commit.
824type Release struct {
825 ID int64
826 RepoID int64
827 Tag string
828 CommitSHA string
829 Name string
830 Body string
831 CreatedAt time.Time
832 Assets []ReleaseAsset
833}
834
835// ReleaseAsset is een bestand bij een release.
836type ReleaseAsset struct {
837 Name string
838 StoragePath string
839 Size int64
840}
841
842// CreateRelease bewaart de release. De bestanden staan al op storagePath.
843func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
844 if err := names.ValidTag(tag); err != nil {
845 return 0, err
846 }
847 tx, err := s.db.BeginTx(ctx, nil)
848 if err != nil {
849 return 0, err
850 }
851 defer func() { _ = tx.Rollback() }()
852 var author, job any
853 if authorID != 0 {
854 author = authorID
855 }
856 if jobID != 0 {
857 job = jobID
858 }
859 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
860 repoID, tag, sha, name, body, author, job, now())
861 if err != nil {
862 if containsUnique(err) {
863 return 0, i18n.E("err.tagExists", tag)
864 }
865 return 0, err
866 }
867 id, _ := res.LastInsertId()
868 for _, a := range assets {
869 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 {
870 return 0, err
871 }
872 }
873 if err := tx.Commit(); err != nil {
874 return 0, err
875 }
876 return id, nil
877}
878
879// ListReleases geeft publicaties, nieuwste eerst.
880func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
881 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)
882 if err != nil {
883 return nil, err
884 }
885 defer rows.Close()
886 var out []Release
887 for rows.Next() {
888 var r Release
889 var created string
890 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
891 return nil, err
892 }
893 r.CreatedAt = parseTime(created)
894 out = append(out, r)
895 }
896 if err := rows.Err(); err != nil {
897 return nil, err
898 }
899 for i := range out {
900 assets, err := s.releaseAssets(ctx, out[i].ID)
901 if err != nil {
902 return nil, err
903 }
904 out[i].Assets = assets
905 }
906 return out, nil
907}
908
909// ReleaseByTag leest één release.
910func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
911 var r Release
912 var created string
913 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).
914 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
915 if errors.Is(err, sql.ErrNoRows) {
916 return Release{}, errNotFound
917 }
918 if err != nil {
919 return Release{}, err
920 }
921 r.CreatedAt = parseTime(created)
922 r.Assets, err = s.releaseAssets(ctx, r.ID)
923 return r, err
924}
925
926func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
927 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
928 if err != nil {
929 return nil, err
930 }
931 defer rows.Close()
932 var out []ReleaseAsset
933 for rows.Next() {
934 var a ReleaseAsset
935 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
936 return nil, err
937 }
938 out = append(out, a)
939 }
940 return out, rows.Err()
941}
942
943func trim(s string, n int) string {
944 s = string([]rune(s))
945 if len([]rune(s)) > n {
946 return string([]rune(s)[:n])
947 }
948 return s
949}
950
951func containsUnique(err error) bool {
952 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
953}
954
955func contains(s, sub string) bool {
956 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
957}
958
959func indexOf(s, sub string) int {
960 for i := 0; i+len(sub) <= len(s); i++ {
961 if s[i:i+len(sub)] == sub {
962 return i
963 }
964 }
965 return -1
966}