BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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