BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

feat: GitLab-achtige blue-ci-cd.yml
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed 17caa14a History
flow.go 25.4 KiB Download Raw
1package store
2
3import (
4 "context"
5 "database/sql"
6 "encoding/json"
7 "errors"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/i18n"
11 "gitlab.com/Timfa/bluegit/internal/names"
12)
13
14// Webhook is een uitgaande melding.
15type Webhook struct {
16 ID int64
17 ScopeKind string
18 ScopeID int64
19 Name string
20 Preset string
21 URLTemplate string
22 Headers map[string]string
23 BodyTemplate string
24 Events []string
25 BranchFilter string
26 Active bool
27 Method string
28}
29
30// CreateWebhook bewaart een webhook.
31func (s *Store) CreateWebhook(ctx context.Context, w Webhook) (int64, error) {
32 if w.Headers == nil {
33 w.Headers = map[string]string{}
34 }
35 if w.Preset == "" {
36 w.Preset = "generic"
37 }
38 if w.Method == "" {
39 w.Method = "POST"
40 }
41 res, err := s.db.ExecContext(ctx, `INSERT INTO webhooks (scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method, created_at)
42 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`,
43 w.ScopeKind, w.ScopeID, w.Name, w.Preset, w.URLTemplate, mustJSON(w.Headers), w.BodyTemplate, mustJSON(w.Events), w.BranchFilter, w.Method, now())
44 if err != nil {
45 return 0, err
46 }
47 return res.LastInsertId()
48}
49
50// ListWebhooks geeft de webhooks van een repository of groep.
51func (s *Store) ListWebhooks(ctx context.Context, scopeKind string, scopeID int64) ([]Webhook, error) {
52 rows, err := s.db.QueryContext(ctx, `SELECT id, scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method FROM webhooks WHERE scope_kind = ? AND scope_id = ? ORDER BY id`, scopeKind, scopeID)
53 if err != nil {
54 return nil, err
55 }
56 defer rows.Close()
57 var out []Webhook
58 for rows.Next() {
59 w, err := scanWebhook(rows)
60 if err != nil {
61 return nil, err
62 }
63 out = append(out, w)
64 }
65 return out, rows.Err()
66}
67
68func scanWebhook(rows *sql.Rows) (Webhook, error) {
69 var w Webhook
70 var headers, events string
71 var active int
72 if err := rows.Scan(&w.ID, &w.ScopeKind, &w.ScopeID, &w.Name, &w.Preset, &w.URLTemplate, &headers, &w.BodyTemplate, &events, &w.BranchFilter, &active, &w.Method); err != nil {
73 return Webhook{}, err
74 }
75 w.Active = active == 1
76 _ = json.Unmarshal([]byte(headers), &w.Headers)
77 _ = json.Unmarshal([]byte(events), &w.Events)
78 if w.Headers == nil {
79 w.Headers = map[string]string{}
80 }
81 return w, nil
82}
83
84// DeleteWebhook verwijdert een webhook in dit scope.
85func (s *Store) DeleteWebhook(ctx context.Context, scopeKind string, scopeID, id int64) error {
86 res, err := s.db.ExecContext(ctx, `DELETE FROM webhooks WHERE id = ? AND scope_kind = ? AND scope_id = ?`, id, scopeKind, scopeID)
87 if err != nil {
88 return err
89 }
90 n, _ := res.RowsAffected()
91 if n == 0 {
92 return errNotFound
93 }
94 return nil
95}
96
97// AddDelivery bewaart het resultaat van een poging.
98func (s *Store) AddDelivery(ctx context.Context, webhookID int64, eventType string, status int, errText string) error {
99 _, err := s.db.ExecContext(ctx, `INSERT INTO webhook_deliveries (webhook_id, event_type, status_code, error, created_at) VALUES (?, ?, ?, ?, ?)`,
100 webhookID, eventType, status, trim(errText, 500), now())
101 return err
102}
103
104// Delivery is één poging.
105type Delivery struct {
106 EventType string
107 StatusCode int
108 Error string
109 CreatedAt time.Time
110}
111
112// RecentDeliveries geeft de laatste pogingen.
113func (s *Store) RecentDeliveries(ctx context.Context, webhookID int64) ([]Delivery, error) {
114 rows, err := s.db.QueryContext(ctx, `SELECT event_type, status_code, error, created_at FROM webhook_deliveries WHERE webhook_id = ? ORDER BY id DESC LIMIT 8`, webhookID)
115 if err != nil {
116 return nil, err
117 }
118 defer rows.Close()
119 var out []Delivery
120 for rows.Next() {
121 var d Delivery
122 var created string
123 if err := rows.Scan(&d.EventType, &d.StatusCode, &d.Error, &created); err != nil {
124 return nil, err
125 }
126 d.CreatedAt = parseTime(created)
127 out = append(out, d)
128 }
129 return out, rows.Err()
130}
131
132// MergeRequest is een basisverzoek om een branch samen te voegen.
133type MergeRequest struct {
134 ID int64
135 RepoID int64
136 Number int64
137 Title string
138 Description string
139 SourceBranch string
140 TargetBranch string
141 AuthorID int64
142 Author string
143 Status string
144 CreatedAt time.Time
145 UpdatedAt time.Time
146}
147
148// CreateMergeRequest nummert per repository.
149func (s *Store) CreateMergeRequest(ctx context.Context, repoID, authorID int64, title, description, source, target string) (MergeRequest, error) {
150 title = trim(title, 200)
151 if title == "" {
152 return MergeRequest{}, i18n.E("err.mrTitle")
153 }
154 tx, err := s.db.BeginTx(ctx, nil)
155 if err != nil {
156 return MergeRequest{}, err
157 }
158 defer func() { _ = tx.Rollback() }()
159 var n int64
160 if err := tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(number), 0) FROM merge_requests WHERE repo_id = ?`, repoID).Scan(&n); err != nil {
161 return MergeRequest{}, err
162 }
163 ts := now()
164 res, err := tx.ExecContext(ctx, `INSERT INTO merge_requests (repo_id, number, title, description, source_branch, target_branch, author_id, status, created_at, updated_at)
165 VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`, repoID, n+1, title, description, source, target, authorID, ts, ts)
166 if err != nil {
167 return MergeRequest{}, err
168 }
169 id, _ := res.LastInsertId()
170 if err := tx.Commit(); err != nil {
171 return MergeRequest{}, err
172 }
173 return s.MergeRequest(ctx, repoID, id)
174}
175
176// MergeRequest leest op interne id.
177func (s *Store) MergeRequest(ctx context.Context, repoID, id int64) (MergeRequest, error) {
178 row := s.db.QueryRowContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.id = ?`, repoID, id)
179 return scanMR(row)
180}
181
182// MergeRequestByNumber leest !nummer.
183func (s *Store) MergeRequestByNumber(ctx context.Context, repoID, number int64) (MergeRequest, error) {
184 row := s.db.QueryRowContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.number = ?`, repoID, number)
185 return scanMR(row)
186}
187
188const mrSelect = `SELECT m.id, m.repo_id, m.number, m.title, m.description, m.source_branch, m.target_branch, m.author_id, u.username, m.status, m.created_at, m.updated_at
189FROM merge_requests m JOIN users u ON u.id = m.author_id`
190
191func scanMR(row *sql.Row) (MergeRequest, error) {
192 var m MergeRequest
193 var created, updated string
194 if err := row.Scan(&m.ID, &m.RepoID, &m.Number, &m.Title, &m.Description, &m.SourceBranch, &m.TargetBranch, &m.AuthorID, &m.Author, &m.Status, &created, &updated); err != nil {
195 if errors.Is(err, sql.ErrNoRows) {
196 return MergeRequest{}, errNotFound
197 }
198 return MergeRequest{}, err
199 }
200 m.CreatedAt = parseTime(created)
201 m.UpdatedAt = parseTime(updated)
202 return m, nil
203}
204
205// ListMergeRequests geeft verzoeken, open eerst.
206func (s *Store) ListMergeRequests(ctx context.Context, repoID int64) ([]MergeRequest, error) {
207 rows, err := s.db.QueryContext(ctx, mrSelect+` WHERE m.repo_id = ? ORDER BY CASE m.status WHEN 'open' THEN 0 ELSE 1 END, m.number DESC`, repoID)
208 if err != nil {
209 return nil, err
210 }
211 defer rows.Close()
212 var out []MergeRequest
213 for rows.Next() {
214 var m MergeRequest
215 var created, updated string
216 if err := rows.Scan(&m.ID, &m.RepoID, &m.Number, &m.Title, &m.Description, &m.SourceBranch, &m.TargetBranch, &m.AuthorID, &m.Author, &m.Status, &created, &updated); err != nil {
217 return nil, err
218 }
219 m.CreatedAt = parseTime(created)
220 m.UpdatedAt = parseTime(updated)
221 out = append(out, m)
222 }
223 return out, rows.Err()
224}
225
226// SetMergeRequestStatus zet open, merged of closed.
227func (s *Store) SetMergeRequestStatus(ctx context.Context, id int64, status string) error {
228 _, err := s.db.ExecContext(ctx, `UPDATE merge_requests SET status = ?, updated_at = ? WHERE id = ?`, status, now(), id)
229 return err
230}
231
232// NewJob is een job die nog de wachtrij in moet.
233type NewJob struct {
234 Name string
235 Stage string
236 Position int
237 Image string
238 Before string
239 Script string
240 After string
241 Needs []string
242 Optional []string
243 NeedsSet bool
244 Variables map[string]string
245 ArtifactPaths []string
246 ArtifactExpire time.Duration
247 AllowFailure bool
248 When string
249 Timeout time.Duration
250 Tags []string
251 CachePaths []string
252 CacheKey string
253 ResourceGroup string
254}
255
256// Pipeline is een draai van blue-ci-cd.yml.
257type Pipeline struct {
258 ID int64
259 RepoID int64
260 CommitSHA string
261 Ref string
262 Status string
263 Source string
264 Actor string
265 CommitTitle string
266 CreatedAt time.Time
267 StartedAt time.Time
268 FinishedAt time.Time
269}
270
271// Job is één container in een pipeline.
272type Job struct {
273 ID int64
274 PipelineID int64
275 RepoID int64
276 Name string
277 Stage string
278 Position int
279 Status string
280 Image string
281 Before string
282 Script string
283 After string
284 Needs []string
285 Optional []string
286 NeedsSet bool
287 Variables map[string]string
288 ArtifactPaths []string
289 ArtifactExpire time.Duration
290 AllowFailure bool
291 When string
292 Timeout time.Duration
293 Tags []string
294 CachePaths []string
295 CacheKey string
296 ResourceGroup string
297 Log string
298 CommitSHA string
299 Ref string
300 StartedAt time.Time
301 FinishedAt time.Time
302}
303
304// RecordConfigFailure bewaart een pipeline die niet kon starten.
305func (s *Store) RecordConfigFailure(ctx context.Context, repoID int64, sha, ref, message string) error {
306 tx, err := s.db.BeginTx(ctx, nil)
307 if err != nil {
308 return err
309 }
310 defer func() { _ = tx.Rollback() }()
311 ts := now()
312 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, created_at, finished_at) VALUES (?, ?, ?, 'failed', ?, ?)`, repoID, sha, ref, ts, ts)
313 if err != nil {
314 return err
315 }
316 id, _ := res.LastInsertId()
317 _, err = tx.ExecContext(ctx, `INSERT INTO jobs (pipeline_id, repo_id, name, stage, position, status, image, script, needs_json, needs_set, variables_json, artifact_paths, artifact_expire_seconds, allow_failure, log, finished_at)
318 VALUES (?, ?, 'blue-ci-cd', 'test', 0, 'failed', 'alpine:3.20', 'exit 1', '[]', 0, '{}', '[]', 0, 0, ?, ?)`, id, repoID, message, ts)
319 if err != nil {
320 return err
321 }
322 return tx.Commit()
323}
324
325// CreatePipeline maakt een pipeline met jobs in de wachtrij.
326func (s *Store) CreatePipeline(ctx context.Context, repoID int64, sha, ref, source, actor, title string, jobs []NewJob) (int64, error) {
327 tx, err := s.db.BeginTx(ctx, nil)
328 if err != nil {
329 return 0, err
330 }
331 defer func() { _ = tx.Rollback() }()
332 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, actor, commit_title, created_at) VALUES (?, ?, ?, 'queued', ?, ?, ?, ?)`, repoID, sha, ref, source, actor, title, now())
333 if err != nil {
334 return 0, err
335 }
336 id, _ := res.LastInsertId()
337 for _, j := range jobs {
338 if j.Variables == nil {
339 j.Variables = map[string]string{}
340 }
341 if j.Needs == nil {
342 j.Needs = []string{}
343 }
344 if j.ArtifactPaths == nil {
345 j.ArtifactPaths = []string{}
346 }
347 if j.Optional == nil {
348 j.Optional = []string{}
349 }
350 if j.Tags == nil {
351 j.Tags = []string{}
352 }
353 if j.CachePaths == nil {
354 j.CachePaths = []string{}
355 }
356 if j.When == "" {
357 j.When = "on_success"
358 }
359 status := "queued"
360 if j.When == "manual" {
361 status = "manual"
362 }
363 _, err := tx.ExecContext(ctx, `INSERT INTO jobs (pipeline_id, repo_id, name, stage, position, status, image, script, needs_json, needs_set, variables_json, artifact_paths, artifact_expire_seconds, allow_failure, log, before_script, after_script, when_mode, timeout_seconds, tags_json, cache_paths, cache_key, resource_group, optional_json)
364 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
365 id, repoID, j.Name, j.Stage, j.Position, status, j.Image, j.Script, mustJSON(j.Needs), boolInt(j.NeedsSet), mustJSON(j.Variables), mustJSON(j.ArtifactPaths), int(j.ArtifactExpire/time.Second), boolInt(j.AllowFailure),
366 j.Before, j.After, j.When, int(j.Timeout/time.Second), mustJSON(j.Tags), mustJSON(j.CachePaths), j.CacheKey, j.ResourceGroup, mustJSON(j.Optional))
367 if err != nil {
368 return 0, err
369 }
370 }
371 if err := tx.Commit(); err != nil {
372 return 0, err
373 }
374 return id, nil
375}
376
377// ListPipelines geeft de nieuwste pipelines.
378func (s *Store) ListPipelines(ctx context.Context, repoID int64) ([]Pipeline, error) {
379 rows, err := s.db.QueryContext(ctx, pipelineCols+` WHERE repo_id = ? ORDER BY id DESC LIMIT 50`, repoID)
380 if err != nil {
381 return nil, err
382 }
383 defer rows.Close()
384 var out []Pipeline
385 for rows.Next() {
386 p, err := scanPipeline(rows)
387 if err != nil {
388 return nil, err
389 }
390 out = append(out, p)
391 }
392 return out, rows.Err()
393}
394
395const pipelineCols = `SELECT id, repo_id, commit_sha, ref, status, created_at, finished_at, source, actor, commit_title, started_at FROM pipelines`
396
397func scanPipeline(rows *sql.Rows) (Pipeline, error) {
398 return scanPipelineRow(rows)
399}
400
401func scanPipelineRow(sc scanner) (Pipeline, error) {
402 var p Pipeline
403 var created, finished, started sql.NullString
404 if err := sc.Scan(&p.ID, &p.RepoID, &p.CommitSHA, &p.Ref, &p.Status, &created, &finished, &p.Source, &p.Actor, &p.CommitTitle, &started); err != nil {
405 return Pipeline{}, err
406 }
407 p.CreatedAt = parseTime(created.String)
408 p.FinishedAt = parseTime(finished.String)
409 p.StartedAt = parseTime(started.String)
410 return p, nil
411}
412
413type scanner interface {
414 Scan(dest ...any) error
415}
416
417// PipelineByID leest één pipeline.
418func (s *Store) PipelineByID(ctx context.Context, repoID, id int64) (Pipeline, error) {
419 p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND id = ?`, repoID, id))
420 if errors.Is(err, sql.ErrNoRows) {
421 return Pipeline{}, errNotFound
422 }
423 return p, err
424}
425
426// JobsByPipeline geeft de jobs in bestandsvolgorde.
427func (s *Store) JobsByPipeline(ctx context.Context, pipelineID int64) ([]Job, error) {
428 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.pipeline_id = ? ORDER BY j.position, j.id`, pipelineID)
429 if err != nil {
430 return nil, err
431 }
432 defer rows.Close()
433 var out []Job
434 for rows.Next() {
435 j, err := scanJob(rows)
436 if err != nil {
437 return nil, err
438 }
439 out = append(out, j)
440 }
441 return out, rows.Err()
442}
443
444const jobSelect = `SELECT j.id, j.pipeline_id, j.repo_id, j.name, j.stage, j.position, j.status, j.image, j.script, j.needs_json, j.needs_set, j.variables_json, j.artifact_paths, j.artifact_expire_seconds, j.allow_failure, j.log, p.commit_sha, p.ref, j.before_script, j.after_script, j.when_mode, j.timeout_seconds, j.tags_json, j.cache_paths, j.cache_key, j.resource_group, j.optional_json, j.started_at, j.finished_at
445FROM jobs j JOIN pipelines p ON p.id = j.pipeline_id`
446
447func scanJob(rows *sql.Rows) (Job, error) {
448 var j Job
449 var needs, vars, paths, tags, cache, optional string
450 var needsSet, allow, expire, timeout int
451 var started, finished sql.NullString
452 if err := rows.Scan(&j.ID, &j.PipelineID, &j.RepoID, &j.Name, &j.Stage, &j.Position, &j.Status, &j.Image, &j.Script, &needs, &needsSet, &vars, &paths, &expire, &allow, &j.Log, &j.CommitSHA, &j.Ref, &j.Before, &j.After, &j.When, &timeout, &tags, &cache, &j.CacheKey, &j.ResourceGroup, &optional, &started, &finished); err != nil {
453 return Job{}, err
454 }
455 j.NeedsSet = needsSet == 1
456 j.AllowFailure = allow == 1
457 j.ArtifactExpire = time.Duration(expire) * time.Second
458 j.Timeout = time.Duration(timeout) * time.Second
459 j.StartedAt = parseTime(started.String)
460 j.FinishedAt = parseTime(finished.String)
461 _ = json.Unmarshal([]byte(needs), &j.Needs)
462 _ = json.Unmarshal([]byte(vars), &j.Variables)
463 _ = json.Unmarshal([]byte(paths), &j.ArtifactPaths)
464 _ = json.Unmarshal([]byte(tags), &j.Tags)
465 _ = json.Unmarshal([]byte(cache), &j.CachePaths)
466 _ = json.Unmarshal([]byte(optional), &j.Optional)
467 return j, nil
468}
469
470// ActivePipelines zijn nog niet af.
471func (s *Store) ActivePipelines(ctx context.Context) ([]Pipeline, error) {
472 rows, err := s.db.QueryContext(ctx, pipelineCols+` WHERE status IN ('queued', 'running', 'manual') ORDER BY id`)
473 if err != nil {
474 return nil, err
475 }
476 defer rows.Close()
477 var out []Pipeline
478 for rows.Next() {
479 p, err := scanPipeline(rows)
480 if err != nil {
481 return nil, err
482 }
483 out = append(out, p)
484 }
485 return out, rows.Err()
486}
487
488// MarkJobRunning zet een wachtende job op running als hij dat nog is.
489func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) {
490 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'running', started_at = ? WHERE id = ? AND status = 'queued'`, now(), id)
491 if err != nil {
492 return false, err
493 }
494 n, _ := res.RowsAffected()
495 if n == 1 {
496 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', started_at = COALESCE(started_at, ?) WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, now(), id)
497 }
498 return n == 1, nil
499}
500
501// FinishJob schrijft het eindresultaat en het log.
502func (s *Store) FinishJob(ctx context.Context, id int64, status, extra string) error {
503 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = log || ?, finished_at = ? WHERE id = ?`, status, extra, now(), id)
504 return err
505}
506
507// AppendJobLog voegt tekst toe terwijl de job loopt.
508func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error {
509 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id)
510 return err
511}
512
513// RefreshPipelineStatus berekent de pipelinestatus uit de jobs.
514func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) {
515 jobs, err := s.JobsByPipeline(ctx, pipelineID)
516 if err != nil {
517 return "", err
518 }
519 status := "success"
520 open := false
521 manual := false
522 for _, j := range jobs {
523 switch j.Status {
524 case "failed":
525 if !j.AllowFailure {
526 status = "failed"
527 }
528 case "queued", "running":
529 open = true
530 case "manual":
531 manual = true
532 }
533 }
534 switch {
535 case status == "failed":
536 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID)
537 case open:
538 status = "running"
539 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running' WHERE id = ?`, pipelineID)
540 case manual:
541 status = "manual"
542 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID)
543 default:
544 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID)
545 }
546 return status, err
547}
548
549// ResourceBusy meldt of een andere job in deze repository die groep bezet.
550func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) {
551 if group == "" {
552 return false, nil
553 }
554 var n int
555 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)
556 return n > 0, err
557}
558
559// QueueJob zet een handmatige job in de wachtrij.
560func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
561 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
562 if err != nil {
563 return false, err
564 }
565 n, _ := res.RowsAffected()
566 if n == 1 {
567 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
568 }
569 return n == 1, nil
570}
571
572// SkipJob markeert een job die niet meer hoeft.
573func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
574 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id)
575 return err
576}
577
578// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
579func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
580 plain, err := newToken("bgj_")
581 if err != nil {
582 return "", err
583 }
584 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
585 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
586 jobID, hashToken(plain), now())
587 if err != nil {
588 return "", err
589 }
590 return plain, nil
591}
592
593// JobByToken zoekt een lopende job bij een job-token.
594func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
595 if len(token) < 4 || token[:4] != "bgj_" {
596 return Job{}, errNotFound
597 }
598 var jobID int64
599 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
600 if errors.Is(err, sql.ErrNoRows) {
601 return Job{}, errNotFound
602 }
603 if err != nil {
604 return Job{}, err
605 }
606 rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
607 if err != nil {
608 return Job{}, err
609 }
610 defer rows.Close()
611 if !rows.Next() {
612 return Job{}, errNotFound
613 }
614 return scanJob(rows)
615}
616
617// Artifact verwijst naar een bestand uit een job.
618type Artifact struct {
619 ID int64
620 JobID int64
621 Path string
622 StoragePath string
623 Size int64
624}
625
626// AddArtifact registreert een bewaard bestand.
627func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
628 var exp any
629 if expires != nil {
630 exp = expires.UTC().Format(time.RFC3339)
631 }
632 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
633 jobID, relPath, storagePath, size, exp)
634 return err
635}
636
637// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
638func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
639 var storage string
640 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
641 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
642 if errors.Is(err, sql.ErrNoRows) {
643 return "", errNotFound
644 }
645 return storage, err
646}
647
648// Release is een publicatie op een commit.
649type Release struct {
650 ID int64
651 RepoID int64
652 Tag string
653 CommitSHA string
654 Name string
655 Body string
656 CreatedAt time.Time
657 Assets []ReleaseAsset
658}
659
660// ReleaseAsset is een bestand bij een release.
661type ReleaseAsset struct {
662 Name string
663 StoragePath string
664 Size int64
665}
666
667// CreateRelease bewaart de release. De bestanden staan al op storagePath.
668func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
669 if err := names.ValidTag(tag); err != nil {
670 return 0, err
671 }
672 tx, err := s.db.BeginTx(ctx, nil)
673 if err != nil {
674 return 0, err
675 }
676 defer func() { _ = tx.Rollback() }()
677 var author, job any
678 if authorID != 0 {
679 author = authorID
680 }
681 if jobID != 0 {
682 job = jobID
683 }
684 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
685 repoID, tag, sha, name, body, author, job, now())
686 if err != nil {
687 if containsUnique(err) {
688 return 0, i18n.E("err.tagExists", tag)
689 }
690 return 0, err
691 }
692 id, _ := res.LastInsertId()
693 for _, a := range assets {
694 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 {
695 return 0, err
696 }
697 }
698 if err := tx.Commit(); err != nil {
699 return 0, err
700 }
701 return id, nil
702}
703
704// ListReleases geeft publicaties, nieuwste eerst.
705func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
706 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)
707 if err != nil {
708 return nil, err
709 }
710 defer rows.Close()
711 var out []Release
712 for rows.Next() {
713 var r Release
714 var created string
715 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
716 return nil, err
717 }
718 r.CreatedAt = parseTime(created)
719 out = append(out, r)
720 }
721 if err := rows.Err(); err != nil {
722 return nil, err
723 }
724 for i := range out {
725 assets, err := s.releaseAssets(ctx, out[i].ID)
726 if err != nil {
727 return nil, err
728 }
729 out[i].Assets = assets
730 }
731 return out, nil
732}
733
734// ReleaseByTag leest één release.
735func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
736 var r Release
737 var created string
738 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).
739 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
740 if errors.Is(err, sql.ErrNoRows) {
741 return Release{}, errNotFound
742 }
743 if err != nil {
744 return Release{}, err
745 }
746 r.CreatedAt = parseTime(created)
747 r.Assets, err = s.releaseAssets(ctx, r.ID)
748 return r, err
749}
750
751func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
752 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
753 if err != nil {
754 return nil, err
755 }
756 defer rows.Close()
757 var out []ReleaseAsset
758 for rows.Next() {
759 var a ReleaseAsset
760 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
761 return nil, err
762 }
763 out = append(out, a)
764 }
765 return out, rows.Err()
766}
767
768func trim(s string, n int) string {
769 s = string([]rune(s))
770 if len([]rune(s)) > n {
771 return string([]rune(s)[:n])
772 }
773 return s
774}
775
776func containsUnique(err error) bool {
777 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
778}
779
780func contains(s, sub string) bool {
781 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
782}
783
784func indexOf(s, sub string) int {
785 for i := 0; i+len(sub) <= len(s); i++ {
786 if s[i:i+len(sub)] == sub {
787 return i
788 }
789 }
790 return -1
791}