BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

feat: self-update via een root-unit achter een token
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
ad7bf26a History
flow.go 32.2 KiB Download Raw
1package store
2
3import (
4 "context"
5 "database/sql"
6 "encoding/json"
7 "errors"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/i18n"
11 "gitlab.com/Timfa/bluegit/internal/names"
12)
13
14// Webhook is een uitgaande melding.
15type Webhook struct {
16 ID int64
17 ScopeKind string
18 ScopeID int64
19 Name string
20 Preset string
21 URLTemplate string
22 Headers map[string]string
23 BodyTemplate string
24 Events []string
25 BranchFilter string
26 Active bool
27 Method string
28}
29
30// CreateWebhook bewaart een webhook.
31func (s *Store) CreateWebhook(ctx context.Context, w Webhook) (int64, error) {
32 if w.Headers == nil {
33 w.Headers = map[string]string{}
34 }
35 if w.Preset == "" {
36 w.Preset = "generic"
37 }
38 if w.Method == "" {
39 w.Method = "POST"
40 }
41 res, err := s.db.ExecContext(ctx, `INSERT INTO webhooks (scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method, created_at)
42 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`,
43 w.ScopeKind, w.ScopeID, w.Name, w.Preset, w.URLTemplate, mustJSON(w.Headers), w.BodyTemplate, mustJSON(w.Events), w.BranchFilter, w.Method, now())
44 if err != nil {
45 return 0, err
46 }
47 return res.LastInsertId()
48}
49
50// ListWebhooks geeft de webhooks van een repository of groep.
51func (s *Store) ListWebhooks(ctx context.Context, scopeKind string, scopeID int64) ([]Webhook, error) {
52 rows, err := s.db.QueryContext(ctx, `SELECT id, scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method FROM webhooks WHERE scope_kind = ? AND scope_id = ? ORDER BY id`, scopeKind, scopeID)
53 if err != nil {
54 return nil, err
55 }
56 defer rows.Close()
57 var out []Webhook
58 for rows.Next() {
59 w, err := scanWebhook(rows)
60 if err != nil {
61 return nil, err
62 }
63 out = append(out, w)
64 }
65 return out, rows.Err()
66}
67
68func scanWebhook(rows *sql.Rows) (Webhook, error) {
69 var w Webhook
70 var headers, events string
71 var active int
72 if err := rows.Scan(&w.ID, &w.ScopeKind, &w.ScopeID, &w.Name, &w.Preset, &w.URLTemplate, &headers, &w.BodyTemplate, &events, &w.BranchFilter, &active, &w.Method); err != nil {
73 return Webhook{}, err
74 }
75 w.Active = active == 1
76 _ = json.Unmarshal([]byte(headers), &w.Headers)
77 _ = json.Unmarshal([]byte(events), &w.Events)
78 if w.Headers == nil {
79 w.Headers = map[string]string{}
80 }
81 return w, nil
82}
83
84// DeleteWebhook verwijdert een webhook in dit scope.
85func (s *Store) DeleteWebhook(ctx context.Context, scopeKind string, scopeID, id int64) error {
86 res, err := s.db.ExecContext(ctx, `DELETE FROM webhooks WHERE id = ? AND scope_kind = ? AND scope_id = ?`, id, scopeKind, scopeID)
87 if err != nil {
88 return err
89 }
90 n, _ := res.RowsAffected()
91 if n == 0 {
92 return errNotFound
93 }
94 return nil
95}
96
97// AddDelivery bewaart het resultaat van een poging.
98func (s *Store) AddDelivery(ctx context.Context, webhookID int64, eventType string, status int, errText string) error {
99 _, err := s.db.ExecContext(ctx, `INSERT INTO webhook_deliveries (webhook_id, event_type, status_code, error, created_at) VALUES (?, ?, ?, ?, ?)`,
100 webhookID, eventType, status, trim(errText, 500), now())
101 return err
102}
103
104// Delivery is één poging.
105type Delivery struct {
106 EventType string
107 StatusCode int
108 Error string
109 CreatedAt time.Time
110}
111
112// RecentDeliveries geeft de laatste pogingen.
113func (s *Store) RecentDeliveries(ctx context.Context, webhookID int64) ([]Delivery, error) {
114 rows, err := s.db.QueryContext(ctx, `SELECT event_type, status_code, error, created_at FROM webhook_deliveries WHERE webhook_id = ? ORDER BY id DESC LIMIT 8`, webhookID)
115 if err != nil {
116 return nil, err
117 }
118 defer rows.Close()
119 var out []Delivery
120 for rows.Next() {
121 var d Delivery
122 var created string
123 if err := rows.Scan(&d.EventType, &d.StatusCode, &d.Error, &created); err != nil {
124 return nil, err
125 }
126 d.CreatedAt = parseTime(created)
127 out = append(out, d)
128 }
129 return out, rows.Err()
130}
131
132// MergeRequest is een basisverzoek om een branch samen te voegen.
133type MergeRequest struct {
134 ID int64
135 RepoID int64
136 Number int64
137 Title string
138 Description string
139 SourceBranch string
140 TargetBranch string
141 AuthorID int64
142 Author string
143 Status string
144 CreatedAt time.Time
145 UpdatedAt time.Time
146 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// CountRunningJobs telt jobs die Steve nu uitvoert.
622func (s *Store) CountRunningJobs(ctx context.Context) (int, error) {
623 var n int
624 err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs WHERE status = 'running'`).Scan(&n)
625 return n, err
626}
627
628// FinishJob schrijft het eindresultaat en het log.
629func (s *Store) FinishJob(ctx context.Context, id int64, status, extra string) error {
630 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = log || ?, finished_at = ? WHERE id = ?`, status, extra, now(), id)
631 return err
632}
633
634// AppendJobLog voegt tekst toe terwijl de job loopt.
635func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error {
636 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id)
637 return err
638}
639
640// RequeueJob zet een mislukte job terug in de wachtrij voor een nieuwe poging.
641func (s *Store) RequeueJob(ctx context.Context, id int64, attempt int, note string) error {
642 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', attempt = ?, log = log || ?, finished_at = NULL, started_at = NULL WHERE id = ?`, attempt, note, id)
643 return err
644}
645
646// CancelInterruptible annuleert onderbreekbare jobs van oudere pipelines op dezelfde ref.
647// Lopende jobs komen terug zodat de runner hun context kan stoppen.
648func (s *Store) CancelInterruptible(ctx context.Context, repoID int64, ref string, keep int64) (running []int64, pipes []int64, err error) {
649 rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.status FROM jobs j
650 JOIN pipelines p ON p.id = j.pipeline_id
651 WHERE p.repo_id = ? AND p.ref = ? AND p.id != ? AND j.interruptible = 1 AND j.status IN ('queued', 'running', 'manual')`, repoID, ref, keep)
652 if err != nil {
653 return nil, nil, err
654 }
655 defer rows.Close()
656 type row struct {
657 id, pipe int64
658 status string
659 }
660 var found []row
661 seenPipe := map[int64]bool{}
662 for rows.Next() {
663 var item row
664 if err := rows.Scan(&item.id, &item.pipe, &item.status); err != nil {
665 return nil, nil, err
666 }
667 found = append(found, item)
668 if !seenPipe[item.pipe] {
669 seenPipe[item.pipe] = true
670 pipes = append(pipes, item.pipe)
671 }
672 }
673 if err := rows.Err(); err != nil {
674 return nil, nil, err
675 }
676 note := time.Now().UTC().Format(time.RFC3339) + "\tcanceled because a newer pipeline started for the same ref\n"
677 for _, item := range found {
678 if item.status == "running" {
679 running = append(running, item.id)
680 continue
681 }
682 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 {
683 return running, pipes, err
684 }
685 }
686 return running, pipes, nil
687}
688
689// RefreshPipelineStatus berekent de pipelinestatus uit de jobs.
690func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) {
691 jobs, err := s.JobsByPipeline(ctx, pipelineID)
692 if err != nil {
693 return "", err
694 }
695 status := "success"
696 open := false
697 manual := false
698 canceled := false
699 for _, j := range jobs {
700 switch j.Status {
701 case "failed":
702 if !j.AllowFailure {
703 status = "failed"
704 }
705 case "canceled":
706 if !j.AllowFailure {
707 canceled = true
708 }
709 case "queued", "running":
710 open = true
711 case "manual":
712 manual = true
713 }
714 }
715 switch {
716 case open:
717 // Een harde mislukking wint pas als er niets meer in de wachtrij of
718 // aan het werk is. Anders blijft de runner latere jobs overslaan.
719 status = "running"
720 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = ?`, pipelineID)
721 case status == "failed":
722 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID)
723 case canceled:
724 status = "canceled"
725 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'canceled', finished_at = ? WHERE id = ?`, now(), pipelineID)
726 case manual:
727 status = "manual"
728 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID)
729 default:
730 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID)
731 }
732 return status, err
733}
734
735// ResourceBusy meldt of een andere job in deze repository die groep bezet.
736func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) {
737 if group == "" {
738 return false, nil
739 }
740 var n int
741 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)
742 return n > 0, err
743}
744
745// QueueJob zet een handmatige job in de wachtrij.
746func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
747 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
748 if err != nil {
749 return false, err
750 }
751 n, _ := res.RowsAffected()
752 if n == 1 {
753 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
754 }
755 return n == 1, nil
756}
757
758// SkipJob markeert een job die niet meer hoeft.
759func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
760 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id)
761 return err
762}
763
764// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
765func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
766 plain, err := newToken("bgj_")
767 if err != nil {
768 return "", err
769 }
770 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
771 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
772 jobID, hashToken(plain), now())
773 if err != nil {
774 return "", err
775 }
776 return plain, nil
777}
778
779// JobByToken zoekt een lopende job bij een job-token.
780func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
781 if len(token) < 4 || token[:4] != "bgj_" {
782 return Job{}, errNotFound
783 }
784 var jobID int64
785 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
786 if errors.Is(err, sql.ErrNoRows) {
787 return Job{}, errNotFound
788 }
789 if err != nil {
790 return Job{}, err
791 }
792 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
793 if err != nil {
794 return Job{}, err
795 }
796 defer rows.Close()
797 if !rows.Next() {
798 return Job{}, errNotFound
799 }
800 return scanJob(rows)
801}
802
803// Artifact verwijst naar een bestand uit een job.
804type Artifact struct {
805 ID int64
806 JobID int64
807 Path string
808 StoragePath string
809 Size int64
810}
811
812// AddArtifact registreert een bewaard bestand.
813func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
814 var exp any
815 if expires != nil {
816 exp = expires.UTC().Format(time.RFC3339)
817 }
818 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
819 jobID, relPath, storagePath, size, exp)
820 return err
821}
822
823// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
824func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
825 var storage string
826 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
827 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
828 if errors.Is(err, sql.ErrNoRows) {
829 return "", errNotFound
830 }
831 return storage, err
832}
833
834// Release is een publicatie op een commit.
835type Release struct {
836 ID int64
837 RepoID int64
838 Tag string
839 CommitSHA string
840 Name string
841 Body string
842 CreatedAt time.Time
843 Assets []ReleaseAsset
844}
845
846// ReleaseAsset is een bestand bij een release.
847type ReleaseAsset struct {
848 Name string
849 StoragePath string
850 Size int64
851}
852
853// CreateRelease bewaart de release. De bestanden staan al op storagePath.
854func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
855 if err := names.ValidTag(tag); err != nil {
856 return 0, err
857 }
858 tx, err := s.db.BeginTx(ctx, nil)
859 if err != nil {
860 return 0, err
861 }
862 defer func() { _ = tx.Rollback() }()
863 var author, job any
864 if authorID != 0 {
865 author = authorID
866 }
867 if jobID != 0 {
868 job = jobID
869 }
870 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
871 repoID, tag, sha, name, body, author, job, now())
872 if err != nil {
873 if containsUnique(err) {
874 return 0, i18n.E("err.tagExists", tag)
875 }
876 return 0, err
877 }
878 id, _ := res.LastInsertId()
879 for _, a := range assets {
880 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 {
881 return 0, err
882 }
883 }
884 if err := tx.Commit(); err != nil {
885 return 0, err
886 }
887 return id, nil
888}
889
890// ListReleases geeft publicaties, nieuwste eerst.
891func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
892 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)
893 if err != nil {
894 return nil, err
895 }
896 defer rows.Close()
897 var out []Release
898 for rows.Next() {
899 var r Release
900 var created string
901 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
902 return nil, err
903 }
904 r.CreatedAt = parseTime(created)
905 out = append(out, r)
906 }
907 if err := rows.Err(); err != nil {
908 return nil, err
909 }
910 for i := range out {
911 assets, err := s.releaseAssets(ctx, out[i].ID)
912 if err != nil {
913 return nil, err
914 }
915 out[i].Assets = assets
916 }
917 return out, nil
918}
919
920// ReleaseByTag leest één release.
921func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
922 var r Release
923 var created string
924 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).
925 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
926 if errors.Is(err, sql.ErrNoRows) {
927 return Release{}, errNotFound
928 }
929 if err != nil {
930 return Release{}, err
931 }
932 r.CreatedAt = parseTime(created)
933 r.Assets, err = s.releaseAssets(ctx, r.ID)
934 return r, err
935}
936
937func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
938 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
939 if err != nil {
940 return nil, err
941 }
942 defer rows.Close()
943 var out []ReleaseAsset
944 for rows.Next() {
945 var a ReleaseAsset
946 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
947 return nil, err
948 }
949 out = append(out, a)
950 }
951 return out, rows.Err()
952}
953
954func trim(s string, n int) string {
955 s = string([]rune(s))
956 if len([]rune(s)) > n {
957 return string([]rune(s)[:n])
958 }
959 return s
960}
961
962func containsUnique(err error) bool {
963 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
964}
965
966func contains(s, sub string) bool {
967 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
968}
969
970func indexOf(s, sub string) int {
971 for i := 0; i+len(sub) <= len(s); i++ {
972 if s[i:i+len(sub)] == sub {
973 return i
974 }
975 }
976 return -1
977}