BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

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