| 1 | package store |
| 2 | |
| 3 | import ( |
| 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. |
| 15 | type 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 | Fields string |
| 29 | } |
| 30 | |
| 31 | // CreateWebhook bewaart een webhook. |
| 32 | func (s *Store) CreateWebhook(ctx context.Context, w Webhook) (int64, error) { |
| 33 | if w.Headers == nil { |
| 34 | w.Headers = map[string]string{} |
| 35 | } |
| 36 | if w.Preset == "" { |
| 37 | w.Preset = "generic" |
| 38 | } |
| 39 | if w.Method == "" { |
| 40 | w.Method = "POST" |
| 41 | } |
| 42 | 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, fields_json, created_at) |
| 43 | VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`, |
| 44 | w.ScopeKind, w.ScopeID, w.Name, w.Preset, w.URLTemplate, mustJSON(w.Headers), w.BodyTemplate, mustJSON(w.Events), w.BranchFilter, w.Method, w.Fields, now()) |
| 45 | if err != nil { |
| 46 | return 0, err |
| 47 | } |
| 48 | return res.LastInsertId() |
| 49 | } |
| 50 | |
| 51 | // ListWebhooks geeft de webhooks van een repository of groep. |
| 52 | func (s *Store) ListWebhooks(ctx context.Context, scopeKind string, scopeID int64) ([]Webhook, error) { |
| 53 | rows, err := s.db.QueryContext(ctx, `SELECT `+webhookCols+` FROM webhooks WHERE scope_kind = ? AND scope_id = ? ORDER BY id`, scopeKind, scopeID) |
| 54 | if err != nil { |
| 55 | return nil, err |
| 56 | } |
| 57 | defer rows.Close() |
| 58 | var out []Webhook |
| 59 | for rows.Next() { |
| 60 | w, err := scanWebhook(rows) |
| 61 | if err != nil { |
| 62 | return nil, err |
| 63 | } |
| 64 | out = append(out, w) |
| 65 | } |
| 66 | return out, rows.Err() |
| 67 | } |
| 68 | |
| 69 | const webhookCols = `id, scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method, fields_json` |
| 70 | |
| 71 | // Webhook leest één webhook in dit scope. |
| 72 | func (s *Store) Webhook(ctx context.Context, scopeKind string, scopeID, id int64) (Webhook, error) { |
| 73 | w, err := scanWebhook(s.db.QueryRowContext(ctx, `SELECT `+webhookCols+` FROM webhooks WHERE id = ? AND scope_kind = ? AND scope_id = ?`, id, scopeKind, scopeID)) |
| 74 | if errors.Is(err, sql.ErrNoRows) { |
| 75 | return Webhook{}, errNotFound |
| 76 | } |
| 77 | return w, err |
| 78 | } |
| 79 | |
| 80 | // UpdateWebhook werkt een webhook in dit scope bij. |
| 81 | func (s *Store) UpdateWebhook(ctx context.Context, w Webhook) error { |
| 82 | if w.Headers == nil { |
| 83 | w.Headers = map[string]string{} |
| 84 | } |
| 85 | if w.Preset == "" { |
| 86 | w.Preset = "generic" |
| 87 | } |
| 88 | if w.Method == "" { |
| 89 | w.Method = "POST" |
| 90 | } |
| 91 | res, err := s.db.ExecContext(ctx, `UPDATE webhooks SET name = ?, preset = ?, url_template = ?, headers_json = ?, body_template = ?, events_json = ?, branch_filter = ?, method = ?, fields_json = ? WHERE id = ? AND scope_kind = ? AND scope_id = ?`, |
| 92 | w.Name, w.Preset, w.URLTemplate, mustJSON(w.Headers), w.BodyTemplate, mustJSON(w.Events), w.BranchFilter, w.Method, w.Fields, w.ID, w.ScopeKind, w.ScopeID) |
| 93 | if err != nil { |
| 94 | return err |
| 95 | } |
| 96 | n, _ := res.RowsAffected() |
| 97 | if n == 0 { |
| 98 | return errNotFound |
| 99 | } |
| 100 | return nil |
| 101 | } |
| 102 | |
| 103 | func scanWebhook(row interface{ Scan(...any) error }) (Webhook, error) { |
| 104 | var w Webhook |
| 105 | var headers, events string |
| 106 | var active int |
| 107 | if err := row.Scan(&w.ID, &w.ScopeKind, &w.ScopeID, &w.Name, &w.Preset, &w.URLTemplate, &headers, &w.BodyTemplate, &events, &w.BranchFilter, &active, &w.Method, &w.Fields); err != nil { |
| 108 | return Webhook{}, err |
| 109 | } |
| 110 | w.Active = active == 1 |
| 111 | _ = json.Unmarshal([]byte(headers), &w.Headers) |
| 112 | _ = json.Unmarshal([]byte(events), &w.Events) |
| 113 | if w.Headers == nil { |
| 114 | w.Headers = map[string]string{} |
| 115 | } |
| 116 | return w, nil |
| 117 | } |
| 118 | |
| 119 | // DeleteWebhook verwijdert een webhook in dit scope. |
| 120 | func (s *Store) DeleteWebhook(ctx context.Context, scopeKind string, scopeID, id int64) error { |
| 121 | res, err := s.db.ExecContext(ctx, `DELETE FROM webhooks WHERE id = ? AND scope_kind = ? AND scope_id = ?`, id, scopeKind, scopeID) |
| 122 | if err != nil { |
| 123 | return err |
| 124 | } |
| 125 | n, _ := res.RowsAffected() |
| 126 | if n == 0 { |
| 127 | return errNotFound |
| 128 | } |
| 129 | return nil |
| 130 | } |
| 131 | |
| 132 | // AddDelivery bewaart het resultaat van een poging. |
| 133 | func (s *Store) AddDelivery(ctx context.Context, webhookID int64, eventType string, status int, errText string) error { |
| 134 | _, err := s.db.ExecContext(ctx, `INSERT INTO webhook_deliveries (webhook_id, event_type, status_code, error, created_at) VALUES (?, ?, ?, ?, ?)`, |
| 135 | webhookID, eventType, status, trim(errText, 500), now()) |
| 136 | return err |
| 137 | } |
| 138 | |
| 139 | // Delivery is één poging. |
| 140 | type Delivery struct { |
| 141 | EventType string |
| 142 | StatusCode int |
| 143 | Error string |
| 144 | CreatedAt time.Time |
| 145 | } |
| 146 | |
| 147 | // RecentDeliveries geeft de laatste pogingen. |
| 148 | func (s *Store) RecentDeliveries(ctx context.Context, webhookID int64) ([]Delivery, error) { |
| 149 | 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) |
| 150 | if err != nil { |
| 151 | return nil, err |
| 152 | } |
| 153 | defer rows.Close() |
| 154 | var out []Delivery |
| 155 | for rows.Next() { |
| 156 | var d Delivery |
| 157 | var created string |
| 158 | if err := rows.Scan(&d.EventType, &d.StatusCode, &d.Error, &created); err != nil { |
| 159 | return nil, err |
| 160 | } |
| 161 | d.CreatedAt = parseTime(created) |
| 162 | out = append(out, d) |
| 163 | } |
| 164 | return out, rows.Err() |
| 165 | } |
| 166 | |
| 167 | // MergeRequest is een basisverzoek om een branch samen te voegen. |
| 168 | type MergeRequest struct { |
| 169 | ID int64 |
| 170 | RepoID int64 |
| 171 | Number int64 |
| 172 | Title string |
| 173 | Description string |
| 174 | SourceBranch string |
| 175 | TargetBranch string |
| 176 | AuthorID int64 |
| 177 | Author string |
| 178 | Status string |
| 179 | CreatedAt time.Time |
| 180 | UpdatedAt time.Time |
| 181 | Draft bool |
| 182 | Labels string |
| 183 | RemoveSourceBranch bool |
| 184 | Squash bool |
| 185 | SquashMessage string |
| 186 | } |
| 187 | |
| 188 | // CreateMergeRequest nummert per repository. |
| 189 | func (s *Store) CreateMergeRequest(ctx context.Context, repoID, authorID int64, title, description, source, target string) (MergeRequest, error) { |
| 190 | title = trim(title, 200) |
| 191 | if title == "" { |
| 192 | return MergeRequest{}, i18n.E("err.mrTitle") |
| 193 | } |
| 194 | tx, err := s.db.BeginTx(ctx, nil) |
| 195 | if err != nil { |
| 196 | return MergeRequest{}, err |
| 197 | } |
| 198 | defer func() { _ = tx.Rollback() }() |
| 199 | var n int64 |
| 200 | if err := tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(number), 0) FROM merge_requests WHERE repo_id = ?`, repoID).Scan(&n); err != nil { |
| 201 | return MergeRequest{}, err |
| 202 | } |
| 203 | ts := now() |
| 204 | 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) |
| 205 | VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`, repoID, n+1, title, description, source, target, authorID, ts, ts) |
| 206 | if err != nil { |
| 207 | return MergeRequest{}, err |
| 208 | } |
| 209 | id, _ := res.LastInsertId() |
| 210 | if err := tx.Commit(); err != nil { |
| 211 | return MergeRequest{}, err |
| 212 | } |
| 213 | return s.MergeRequest(ctx, repoID, id) |
| 214 | } |
| 215 | |
| 216 | // MergeRequest leest op interne id. |
| 217 | func (s *Store) MergeRequest(ctx context.Context, repoID, id int64) (MergeRequest, error) { |
| 218 | row := s.db.QueryRowContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.id = ?`, repoID, id) |
| 219 | return scanMR(row) |
| 220 | } |
| 221 | |
| 222 | // MergeRequestByNumber leest !nummer. |
| 223 | func (s *Store) MergeRequestByNumber(ctx context.Context, repoID, number int64) (MergeRequest, error) { |
| 224 | row := s.db.QueryRowContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.number = ?`, repoID, number) |
| 225 | return scanMR(row) |
| 226 | } |
| 227 | |
| 228 | const 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, m.remove_source_branch, m.squash, m.squash_message |
| 229 | FROM merge_requests m JOIN users u ON u.id = m.author_id` |
| 230 | |
| 231 | func scanMR(row *sql.Row) (MergeRequest, error) { |
| 232 | var m MergeRequest |
| 233 | var created, updated string |
| 234 | var draft, remove, squash int |
| 235 | 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, &remove, &squash, &m.SquashMessage); err != nil { |
| 236 | if errors.Is(err, sql.ErrNoRows) { |
| 237 | return MergeRequest{}, errNotFound |
| 238 | } |
| 239 | return MergeRequest{}, err |
| 240 | } |
| 241 | applyMR(&m, created, updated, draft, remove, squash) |
| 242 | return m, nil |
| 243 | } |
| 244 | |
| 245 | func applyMR(m *MergeRequest, created, updated string, draft, remove, squash int) { |
| 246 | m.CreatedAt = parseTime(created) |
| 247 | m.UpdatedAt = parseTime(updated) |
| 248 | m.Draft = draft == 1 |
| 249 | m.RemoveSourceBranch = remove == 1 |
| 250 | m.Squash = squash == 1 |
| 251 | } |
| 252 | |
| 253 | // ListMergeRequests geeft verzoeken, open eerst. |
| 254 | func (s *Store) ListMergeRequests(ctx context.Context, repoID int64) ([]MergeRequest, error) { |
| 255 | 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) |
| 256 | if err != nil { |
| 257 | return nil, err |
| 258 | } |
| 259 | defer rows.Close() |
| 260 | return scanMRList(rows) |
| 261 | } |
| 262 | |
| 263 | // SetMergeRequestStatus zet open, merged of closed. |
| 264 | func (s *Store) SetMergeRequestStatus(ctx context.Context, id int64, status string) error { |
| 265 | _, err := s.db.ExecContext(ctx, `UPDATE merge_requests SET status = ?, updated_at = ? WHERE id = ?`, status, now(), id) |
| 266 | return err |
| 267 | } |
| 268 | |
| 269 | // OpenMergeRequestsBySource geeft open verzoeken waarvan de bronbranch deze is. |
| 270 | func (s *Store) OpenMergeRequestsBySource(ctx context.Context, repoID int64, branch string) ([]MergeRequest, error) { |
| 271 | return s.openMergeRequests(ctx, repoID, "source_branch", branch) |
| 272 | } |
| 273 | |
| 274 | // OpenMergeRequestsByTarget geeft open verzoeken waarvan de doelbranch deze is. |
| 275 | func (s *Store) OpenMergeRequestsByTarget(ctx context.Context, repoID int64, branch string) ([]MergeRequest, error) { |
| 276 | return s.openMergeRequests(ctx, repoID, "target_branch", branch) |
| 277 | } |
| 278 | |
| 279 | func (s *Store) openMergeRequests(ctx context.Context, repoID int64, column, branch string) ([]MergeRequest, error) { |
| 280 | if column != "source_branch" && column != "target_branch" { |
| 281 | return nil, errNotFound |
| 282 | } |
| 283 | rows, err := s.db.QueryContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.`+column+` = ? AND m.status = 'open' ORDER BY m.number`, repoID, branch) |
| 284 | if err != nil { |
| 285 | return nil, err |
| 286 | } |
| 287 | defer rows.Close() |
| 288 | return scanMRList(rows) |
| 289 | } |
| 290 | |
| 291 | func scanMRList(rows *sql.Rows) ([]MergeRequest, error) { |
| 292 | var out []MergeRequest |
| 293 | for rows.Next() { |
| 294 | var m MergeRequest |
| 295 | var created, updated string |
| 296 | var draft, remove, squash int |
| 297 | 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, &remove, &squash, &m.SquashMessage); err != nil { |
| 298 | return nil, err |
| 299 | } |
| 300 | applyMR(&m, created, updated, draft, remove, squash) |
| 301 | out = append(out, m) |
| 302 | } |
| 303 | return out, rows.Err() |
| 304 | } |
| 305 | |
| 306 | // AttachPipelineMR koppelt een pipeline aan een merge request. |
| 307 | func (s *Store) AttachPipelineMR(ctx context.Context, pipelineID, mrID int64) error { |
| 308 | _, err := s.db.ExecContext(ctx, `UPDATE pipelines SET mr_id = ? WHERE id = ?`, mrID, pipelineID) |
| 309 | return err |
| 310 | } |
| 311 | |
| 312 | // LatestMergePipeline is de nieuwste pipeline van deze merge request. |
| 313 | func (s *Store) LatestMergePipeline(ctx context.Context, repoID, mrID int64) (Pipeline, error) { |
| 314 | p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND mr_id = ? ORDER BY id DESC LIMIT 1`, repoID, mrID)) |
| 315 | if errors.Is(err, sql.ErrNoRows) { |
| 316 | return Pipeline{}, errNotFound |
| 317 | } |
| 318 | return p, err |
| 319 | } |
| 320 | |
| 321 | // PipelineBlocksMerge zegt of deze jobs een merge tegenhouden. |
| 322 | // Een lege tekst betekent dat elke job klaar is en geen harde fout heeft. |
| 323 | // allow_failure mag mislukt zijn, maar moet wel af zijn. |
| 324 | func PipelineBlocksMerge(jobs []Job) string { |
| 325 | if len(jobs) == 0 { |
| 326 | return "waiting" |
| 327 | } |
| 328 | hard, open := false, false |
| 329 | for _, j := range jobs { |
| 330 | switch j.Status { |
| 331 | case "success", "skipped": |
| 332 | case "failed", "canceled": |
| 333 | if !j.AllowFailure { |
| 334 | hard = true |
| 335 | } |
| 336 | default: |
| 337 | open = true |
| 338 | } |
| 339 | } |
| 340 | if open { |
| 341 | return "running" |
| 342 | } |
| 343 | if hard { |
| 344 | return "failed" |
| 345 | } |
| 346 | return "" |
| 347 | } |
| 348 | |
| 349 | // NewJob is een job die nog de wachtrij in moet. |
| 350 | type NewJob struct { |
| 351 | Name string |
| 352 | Stage string |
| 353 | Position int |
| 354 | Image string |
| 355 | Before string |
| 356 | Script string |
| 357 | After string |
| 358 | Needs []string |
| 359 | Optional []string |
| 360 | NeedsSet bool |
| 361 | Variables map[string]string |
| 362 | ArtifactPaths []string |
| 363 | ArtifactExpire time.Duration |
| 364 | AllowFailure bool |
| 365 | When string |
| 366 | Timeout time.Duration |
| 367 | Tags []string |
| 368 | CachePaths []string |
| 369 | CacheKey string |
| 370 | ResourceGroup string |
| 371 | RetryMax int |
| 372 | RetryWhen []string |
| 373 | Services []Service |
| 374 | Environment string |
| 375 | EnvironmentURL string |
| 376 | Interruptible bool |
| 377 | } |
| 378 | |
| 379 | // Service is een sidecar die de runner naast de job start. |
| 380 | type Service struct { |
| 381 | Name string `json:"name"` |
| 382 | Alias string `json:"alias"` |
| 383 | Command []string `json:"command,omitempty"` |
| 384 | Entrypoint []string `json:"entrypoint,omitempty"` |
| 385 | Variables map[string]string `json:"variables,omitempty"` |
| 386 | } |
| 387 | |
| 388 | // Pipeline is een draai van blue-ci-cd.yml. |
| 389 | type Pipeline struct { |
| 390 | ID int64 |
| 391 | RepoID int64 |
| 392 | CommitSHA string |
| 393 | Ref string |
| 394 | Status string |
| 395 | Source string |
| 396 | Actor string |
| 397 | CommitTitle string |
| 398 | CreatedAt time.Time |
| 399 | StartedAt time.Time |
| 400 | FinishedAt time.Time |
| 401 | MRID int64 |
| 402 | // TargetSHA is de doelcommit van een merge-request-pipeline. |
| 403 | // Leeg zolang de rij nog niet aan een merge request hangt. |
| 404 | // Een nieuwe doelcommit start een nieuwe pipeline. |
| 405 | TargetSHA string |
| 406 | } |
| 407 | |
| 408 | // Job is één container in een pipeline. |
| 409 | type Job struct { |
| 410 | ID int64 |
| 411 | PipelineID int64 |
| 412 | RepoID int64 |
| 413 | Name string |
| 414 | Stage string |
| 415 | Position int |
| 416 | Status string |
| 417 | Image string |
| 418 | Before string |
| 419 | Script string |
| 420 | After string |
| 421 | Needs []string |
| 422 | Optional []string |
| 423 | NeedsSet bool |
| 424 | Variables map[string]string |
| 425 | ArtifactPaths []string |
| 426 | ArtifactExpire time.Duration |
| 427 | AllowFailure bool |
| 428 | When string |
| 429 | Timeout time.Duration |
| 430 | Tags []string |
| 431 | CachePaths []string |
| 432 | CacheKey string |
| 433 | ResourceGroup string |
| 434 | RetryMax int |
| 435 | RetryWhen []string |
| 436 | Attempt int |
| 437 | Services []Service |
| 438 | Environment string |
| 439 | EnvironmentURL string |
| 440 | Interruptible bool |
| 441 | Log string |
| 442 | CommitSHA string |
| 443 | Ref string |
| 444 | StartedAt time.Time |
| 445 | FinishedAt time.Time |
| 446 | } |
| 447 | |
| 448 | // RecordConfigFailure bewaart een pipeline die niet kon starten. |
| 449 | // Dezelfde repo, ref, sha, bron, merge request en doel-sha levert de |
| 450 | // bestaande pipeline terug. Een kapotte push die al bestaat wordt aan |
| 451 | // de merge request gekoppeld in plaats van een tweede mislukte rij. |
| 452 | func (s *Store) RecordConfigFailure(ctx context.Context, repoID int64, sha, ref, source, message string, mrID int64, targetSHA string) (int64, bool, error) { |
| 453 | if source == "" { |
| 454 | source = "push" |
| 455 | } |
| 456 | tx, err := s.db.BeginTx(ctx, nil) |
| 457 | if err != nil { |
| 458 | return 0, false, err |
| 459 | } |
| 460 | defer func() { _ = tx.Rollback() }() |
| 461 | if id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA); err != nil { |
| 462 | return 0, false, err |
| 463 | } else if ok { |
| 464 | return finishExisting(ctx, tx, id) |
| 465 | } |
| 466 | if source == "push" && mrID == 0 { |
| 467 | if id, ok, err := newestPush(ctx, tx, repoID, sha, ref); err != nil { |
| 468 | return 0, false, err |
| 469 | } else if ok { |
| 470 | return finishExisting(ctx, tx, id) |
| 471 | } |
| 472 | } |
| 473 | if mrID != 0 { |
| 474 | if id, ok, err := configFailurePush(ctx, tx, repoID, sha, ref, mrID, targetSHA); err != nil { |
| 475 | return 0, false, err |
| 476 | } else if ok { |
| 477 | if err := bindPipelineMR(ctx, tx, id, mrID, targetSHA); err != nil { |
| 478 | return 0, false, err |
| 479 | } |
| 480 | return finishExisting(ctx, tx, id) |
| 481 | } |
| 482 | } |
| 483 | ts := now() |
| 484 | res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, created_at, finished_at, mr_id, target_sha) |
| 485 | SELECT ?, ?, ?, 'failed', ?, ?, ?, ?, ? |
| 486 | WHERE NOT EXISTS ( |
| 487 | SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = ? AND mr_id = ? AND target_sha = ? |
| 488 | )`, repoID, sha, ref, source, ts, ts, mrID, targetSHA, repoID, sha, ref, source, mrID, targetSHA) |
| 489 | if err != nil { |
| 490 | return 0, false, err |
| 491 | } |
| 492 | if n, _ := res.RowsAffected(); n == 0 { |
| 493 | id, err := pipelineKeyID(ctx, tx, repoID, sha, ref, source, mrID, targetSHA) |
| 494 | if err != nil { |
| 495 | return 0, false, err |
| 496 | } |
| 497 | return finishExisting(ctx, tx, id) |
| 498 | } |
| 499 | id, _ := res.LastInsertId() |
| 500 | _, 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) |
| 501 | VALUES (?, ?, 'blue-ci-cd', 'test', 0, 'failed', 'alpine:3.20', 'exit 1', '[]', 0, '{}', '[]', 0, 0, ?, ?)`, id, repoID, message, ts) |
| 502 | if err != nil { |
| 503 | return 0, false, err |
| 504 | } |
| 505 | if err := tx.Commit(); err != nil { |
| 506 | return 0, false, err |
| 507 | } |
| 508 | return id, true, nil |
| 509 | } |
| 510 | |
| 511 | // CreatePipeline maakt een pipeline met jobs in de wachtrij. |
| 512 | // Elke aanroep voegt een rij toe. Starten via een push of merge request |
| 513 | // gaat via OpenPipeline, zodat een dubbele hook dezelfde run teruggeeft. |
| 514 | func (s *Store) CreatePipeline(ctx context.Context, repoID int64, sha, ref, source, actor, title string, jobs []NewJob) (int64, error) { |
| 515 | tx, err := s.db.BeginTx(ctx, nil) |
| 516 | if err != nil { |
| 517 | return 0, err |
| 518 | } |
| 519 | defer func() { _ = tx.Rollback() }() |
| 520 | 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()) |
| 521 | if err != nil { |
| 522 | return 0, err |
| 523 | } |
| 524 | id, _ := res.LastInsertId() |
| 525 | if err := insertPipelineJobs(ctx, tx, id, repoID, jobs); err != nil { |
| 526 | return 0, err |
| 527 | } |
| 528 | if err := tx.Commit(); err != nil { |
| 529 | return 0, err |
| 530 | } |
| 531 | return id, nil |
| 532 | } |
| 533 | |
| 534 | // OpenPipeline maakt een pipeline, of geeft de bestaande terug. |
| 535 | // De sleutel is repo, ref, sha, bron, merge request en doel-sha. |
| 536 | // Een push voor dezelfde sha blijft één rij, ook nadat een merge request |
| 537 | // hem heeft gekoppeld. Kiezen push en merge request dezelfde jobs, dan |
| 538 | // koppelt deze aanroep de push-rij en maakt hij geen tweede pipeline. |
| 539 | // Een andere jobset of een nieuwe doel-sha start wel een eigen rij. |
| 540 | // created is false wanneer een eerdere trigger de run al had. |
| 541 | func (s *Store) OpenPipeline(ctx context.Context, repoID int64, sha, ref, source, actor, title, targetSHA string, mrID int64, jobs []NewJob) (int64, bool, error) { |
| 542 | if source == "" { |
| 543 | source = "push" |
| 544 | } |
| 545 | tx, err := s.db.BeginTx(ctx, nil) |
| 546 | if err != nil { |
| 547 | return 0, false, err |
| 548 | } |
| 549 | defer func() { _ = tx.Rollback() }() |
| 550 | if id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA); err != nil { |
| 551 | return 0, false, err |
| 552 | } else if ok { |
| 553 | return finishExisting(ctx, tx, id) |
| 554 | } |
| 555 | if source == "push" && mrID == 0 { |
| 556 | if id, ok, err := newestPush(ctx, tx, repoID, sha, ref); err != nil { |
| 557 | return 0, false, err |
| 558 | } else if ok { |
| 559 | return finishExisting(ctx, tx, id) |
| 560 | } |
| 561 | } |
| 562 | if mrID != 0 { |
| 563 | if id, ok, err := claimMatchingPush(ctx, tx, repoID, sha, ref, mrID, targetSHA, jobs); err != nil { |
| 564 | return 0, false, err |
| 565 | } else if ok { |
| 566 | return finishExisting(ctx, tx, id) |
| 567 | } |
| 568 | } |
| 569 | notExists := `SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = ? AND mr_id = ? AND target_sha = ?` |
| 570 | args := []any{repoID, sha, ref, source, actor, title, now(), mrID, targetSHA, repoID, sha, ref, source, mrID, targetSHA} |
| 571 | if source == "push" && mrID == 0 { |
| 572 | notExists = `SELECT 1 FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = 'push'` |
| 573 | args = []any{repoID, sha, ref, source, actor, title, now(), mrID, targetSHA, repoID, sha, ref} |
| 574 | } |
| 575 | res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, actor, commit_title, created_at, mr_id, target_sha) |
| 576 | SELECT ?, ?, ?, 'queued', ?, ?, ?, ?, ?, ? |
| 577 | WHERE NOT EXISTS (`+notExists+`)`, args...) |
| 578 | if err != nil { |
| 579 | return 0, false, err |
| 580 | } |
| 581 | if n, _ := res.RowsAffected(); n == 0 { |
| 582 | id, ok, err := existingPipeline(ctx, tx, repoID, sha, ref, source, mrID, targetSHA) |
| 583 | if err != nil { |
| 584 | return 0, false, err |
| 585 | } |
| 586 | if !ok && source == "push" && mrID == 0 { |
| 587 | id, ok, err = newestPush(ctx, tx, repoID, sha, ref) |
| 588 | if err != nil { |
| 589 | return 0, false, err |
| 590 | } |
| 591 | } |
| 592 | if !ok { |
| 593 | return 0, false, errors.New("pipeline ontbreekt na een lege insert") |
| 594 | } |
| 595 | return finishExisting(ctx, tx, id) |
| 596 | } |
| 597 | id, _ := res.LastInsertId() |
| 598 | if err := insertPipelineJobs(ctx, tx, id, repoID, jobs); err != nil { |
| 599 | return 0, false, err |
| 600 | } |
| 601 | if err := tx.Commit(); err != nil { |
| 602 | return 0, false, err |
| 603 | } |
| 604 | return id, true, nil |
| 605 | } |
| 606 | |
| 607 | func finishExisting(ctx context.Context, tx *sql.Tx, id int64) (int64, bool, error) { |
| 608 | if err := tx.Commit(); err != nil { |
| 609 | return 0, false, err |
| 610 | } |
| 611 | return id, false, nil |
| 612 | } |
| 613 | |
| 614 | func existingPipeline(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref, source string, mrID int64, targetSHA string) (int64, bool, error) { |
| 615 | id, err := pipelineKeyID(ctx, tx, repoID, sha, ref, source, mrID, targetSHA) |
| 616 | if errors.Is(err, sql.ErrNoRows) { |
| 617 | return 0, false, nil |
| 618 | } |
| 619 | if err != nil { |
| 620 | return 0, false, err |
| 621 | } |
| 622 | return id, true, nil |
| 623 | } |
| 624 | |
| 625 | func pipelineKeyID(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref, source string, mrID int64, targetSHA string) (int64, error) { |
| 626 | var id int64 |
| 627 | err := tx.QueryRowContext(ctx, `SELECT id FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = ? AND mr_id = ? AND target_sha = ? ORDER BY id LIMIT 1`, |
| 628 | repoID, sha, ref, source, mrID, targetSHA).Scan(&id) |
| 629 | return id, err |
| 630 | } |
| 631 | |
| 632 | func newestPush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string) (int64, bool, error) { |
| 633 | var id int64 |
| 634 | err := tx.QueryRowContext(ctx, `SELECT id FROM pipelines WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = 'push' ORDER BY id DESC LIMIT 1`, |
| 635 | repoID, sha, ref).Scan(&id) |
| 636 | if errors.Is(err, sql.ErrNoRows) { |
| 637 | return 0, false, nil |
| 638 | } |
| 639 | if err != nil { |
| 640 | return 0, false, err |
| 641 | } |
| 642 | return id, true, nil |
| 643 | } |
| 644 | |
| 645 | // configFailurePush zoekt een mislukte push die alleen de kapotte yaml bewaart. |
| 646 | func configFailurePush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string, mrID int64, targetSHA string) (int64, bool, error) { |
| 647 | var id int64 |
| 648 | err := tx.QueryRowContext(ctx, `SELECT p.id FROM pipelines p |
| 649 | WHERE p.repo_id = ? AND p.commit_sha = ? AND p.ref = ? AND p.source = 'push' AND p.status = 'failed' |
| 650 | AND (p.mr_id = 0 OR p.mr_id = ?) AND (p.target_sha = '' OR p.target_sha = ?) |
| 651 | AND EXISTS (SELECT 1 FROM jobs j WHERE j.pipeline_id = p.id AND j.name = 'blue-ci-cd') |
| 652 | ORDER BY p.id DESC LIMIT 1`, repoID, sha, ref, mrID, targetSHA).Scan(&id) |
| 653 | if errors.Is(err, sql.ErrNoRows) { |
| 654 | return 0, false, nil |
| 655 | } |
| 656 | if err != nil { |
| 657 | return 0, false, err |
| 658 | } |
| 659 | return id, true, nil |
| 660 | } |
| 661 | |
| 662 | type pushCandidate struct { |
| 663 | id int64 |
| 664 | mrID int64 |
| 665 | target string |
| 666 | } |
| 667 | |
| 668 | // claimMatchingPush koppelt een push-pipeline met dezelfde jobs aan de merge request. |
| 669 | func claimMatchingPush(ctx context.Context, tx *sql.Tx, repoID int64, sha, ref string, mrID int64, targetSHA string, jobs []NewJob) (int64, bool, error) { |
| 670 | rows, err := tx.QueryContext(ctx, `SELECT id, mr_id, target_sha FROM pipelines |
| 671 | WHERE repo_id = ? AND commit_sha = ? AND ref = ? AND source = 'push' |
| 672 | AND (mr_id = 0 OR mr_id = ?) AND (target_sha = '' OR target_sha = ?) |
| 673 | ORDER BY id DESC`, repoID, sha, ref, mrID, targetSHA) |
| 674 | if err != nil { |
| 675 | return 0, false, err |
| 676 | } |
| 677 | var cands []pushCandidate |
| 678 | for rows.Next() { |
| 679 | var c pushCandidate |
| 680 | if err := rows.Scan(&c.id, &c.mrID, &c.target); err != nil { |
| 681 | rows.Close() |
| 682 | return 0, false, err |
| 683 | } |
| 684 | cands = append(cands, c) |
| 685 | } |
| 686 | if err := rows.Err(); err != nil { |
| 687 | rows.Close() |
| 688 | return 0, false, err |
| 689 | } |
| 690 | rows.Close() |
| 691 | for _, c := range cands { |
| 692 | if c.mrID == mrID && c.target == targetSHA { |
| 693 | return c.id, true, nil |
| 694 | } |
| 695 | got, err := loadJobSigs(ctx, tx, c.id) |
| 696 | if err != nil { |
| 697 | return 0, false, err |
| 698 | } |
| 699 | if !sameJobSigs(got, jobs) { |
| 700 | continue |
| 701 | } |
| 702 | if err := bindPipelineMR(ctx, tx, c.id, mrID, targetSHA); err != nil { |
| 703 | return 0, false, err |
| 704 | } |
| 705 | return c.id, true, nil |
| 706 | } |
| 707 | return 0, false, nil |
| 708 | } |
| 709 | |
| 710 | func bindPipelineMR(ctx context.Context, tx *sql.Tx, id, mrID int64, targetSHA string) error { |
| 711 | _, err := tx.ExecContext(ctx, `UPDATE pipelines SET mr_id = ?, target_sha = ? WHERE id = ?`, mrID, targetSHA, id) |
| 712 | return err |
| 713 | } |
| 714 | |
| 715 | type jobSig struct { |
| 716 | name, stage, image, script, when string |
| 717 | allow bool |
| 718 | } |
| 719 | |
| 720 | func loadJobSigs(ctx context.Context, tx *sql.Tx, pipelineID int64) ([]jobSig, error) { |
| 721 | rows, err := tx.QueryContext(ctx, `SELECT name, stage, image, script, when_mode, allow_failure FROM jobs WHERE pipeline_id = ? ORDER BY position, id`, pipelineID) |
| 722 | if err != nil { |
| 723 | return nil, err |
| 724 | } |
| 725 | defer rows.Close() |
| 726 | var out []jobSig |
| 727 | for rows.Next() { |
| 728 | var s jobSig |
| 729 | var allow int |
| 730 | if err := rows.Scan(&s.name, &s.stage, &s.image, &s.script, &s.when, &allow); err != nil { |
| 731 | return nil, err |
| 732 | } |
| 733 | s.allow = allow == 1 |
| 734 | out = append(out, s) |
| 735 | } |
| 736 | return out, rows.Err() |
| 737 | } |
| 738 | |
| 739 | func sameJobSigs(got []jobSig, jobs []NewJob) bool { |
| 740 | if len(got) != len(jobs) { |
| 741 | return false |
| 742 | } |
| 743 | for i, j := range jobs { |
| 744 | when := j.When |
| 745 | if when == "" { |
| 746 | when = "on_success" |
| 747 | } |
| 748 | g := got[i] |
| 749 | if g.name != j.Name || g.stage != j.Stage || g.image != j.Image || g.script != j.Script || g.when != when || g.allow != j.AllowFailure { |
| 750 | return false |
| 751 | } |
| 752 | } |
| 753 | return true |
| 754 | } |
| 755 | |
| 756 | func insertPipelineJobs(ctx context.Context, tx *sql.Tx, id, repoID int64, jobs []NewJob) error { |
| 757 | for _, j := range jobs { |
| 758 | if j.Variables == nil { |
| 759 | j.Variables = map[string]string{} |
| 760 | } |
| 761 | if j.Needs == nil { |
| 762 | j.Needs = []string{} |
| 763 | } |
| 764 | if j.ArtifactPaths == nil { |
| 765 | j.ArtifactPaths = []string{} |
| 766 | } |
| 767 | if j.Optional == nil { |
| 768 | j.Optional = []string{} |
| 769 | } |
| 770 | if j.Tags == nil { |
| 771 | j.Tags = []string{} |
| 772 | } |
| 773 | if j.CachePaths == nil { |
| 774 | j.CachePaths = []string{} |
| 775 | } |
| 776 | if j.When == "" { |
| 777 | j.When = "on_success" |
| 778 | } |
| 779 | if j.RetryWhen == nil { |
| 780 | j.RetryWhen = []string{} |
| 781 | } |
| 782 | if j.Services == nil { |
| 783 | j.Services = []Service{} |
| 784 | } |
| 785 | status := "queued" |
| 786 | if j.When == "manual" { |
| 787 | status = "manual" |
| 788 | } |
| 789 | _, 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) |
| 790 | VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, |
| 791 | 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), |
| 792 | j.Before, j.After, j.When, int(j.Timeout/time.Second), mustJSON(j.Tags), mustJSON(j.CachePaths), j.CacheKey, j.ResourceGroup, mustJSON(j.Optional), |
| 793 | j.RetryMax, mustJSON(j.RetryWhen), mustJSON(j.Services), j.Environment, j.EnvironmentURL, boolInt(j.Interruptible)) |
| 794 | if err != nil { |
| 795 | return err |
| 796 | } |
| 797 | } |
| 798 | return nil |
| 799 | } |
| 800 | |
| 801 | // ListPipelines geeft de nieuwste pipelines. |
| 802 | func (s *Store) ListPipelines(ctx context.Context, repoID int64) ([]Pipeline, error) { |
| 803 | rows, err := s.db.QueryContext(ctx, pipelineCols+` WHERE repo_id = ? ORDER BY id DESC LIMIT 50`, repoID) |
| 804 | if err != nil { |
| 805 | return nil, err |
| 806 | } |
| 807 | defer rows.Close() |
| 808 | var out []Pipeline |
| 809 | for rows.Next() { |
| 810 | p, err := scanPipeline(rows) |
| 811 | if err != nil { |
| 812 | return nil, err |
| 813 | } |
| 814 | out = append(out, p) |
| 815 | } |
| 816 | return out, rows.Err() |
| 817 | } |
| 818 | |
| 819 | const pipelineCols = `SELECT id, repo_id, commit_sha, ref, status, created_at, finished_at, source, actor, commit_title, started_at, mr_id, target_sha FROM pipelines` |
| 820 | |
| 821 | func scanPipeline(rows *sql.Rows) (Pipeline, error) { |
| 822 | return scanPipelineRow(rows) |
| 823 | } |
| 824 | |
| 825 | func scanPipelineRow(sc scanner) (Pipeline, error) { |
| 826 | var p Pipeline |
| 827 | var created, finished, started sql.NullString |
| 828 | 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, &p.TargetSHA); err != nil { |
| 829 | return Pipeline{}, err |
| 830 | } |
| 831 | p.CreatedAt = parseTime(created.String) |
| 832 | p.FinishedAt = parseTime(finished.String) |
| 833 | p.StartedAt = parseTime(started.String) |
| 834 | return p, nil |
| 835 | } |
| 836 | |
| 837 | type scanner interface { |
| 838 | Scan(dest ...any) error |
| 839 | } |
| 840 | |
| 841 | // LatestPipelineByCommit geeft de nieuwste pipeline van deze commit. |
| 842 | func (s *Store) LatestPipelineByCommit(ctx context.Context, repoID int64, sha string) (Pipeline, error) { |
| 843 | p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND commit_sha = ? ORDER BY id DESC LIMIT 1`, repoID, sha)) |
| 844 | if errors.Is(err, sql.ErrNoRows) { |
| 845 | return Pipeline{}, errNotFound |
| 846 | } |
| 847 | return p, err |
| 848 | } |
| 849 | |
| 850 | // PipelineByID leest één pipeline. |
| 851 | func (s *Store) PipelineByID(ctx context.Context, repoID, id int64) (Pipeline, error) { |
| 852 | p, err := scanPipelineRow(s.db.QueryRowContext(ctx, pipelineCols+` WHERE repo_id = ? AND id = ?`, repoID, id)) |
| 853 | if errors.Is(err, sql.ErrNoRows) { |
| 854 | return Pipeline{}, errNotFound |
| 855 | } |
| 856 | return p, err |
| 857 | } |
| 858 | |
| 859 | // JobsByPipeline geeft de jobs in bestandsvolgorde. |
| 860 | func (s *Store) JobsByPipeline(ctx context.Context, pipelineID int64) ([]Job, error) { |
| 861 | rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.pipeline_id = ? ORDER BY j.position, j.id`, pipelineID) |
| 862 | if err != nil { |
| 863 | return nil, err |
| 864 | } |
| 865 | defer rows.Close() |
| 866 | var out []Job |
| 867 | for rows.Next() { |
| 868 | j, err := scanJob(rows) |
| 869 | if err != nil { |
| 870 | return nil, err |
| 871 | } |
| 872 | out = append(out, j) |
| 873 | } |
| 874 | return out, rows.Err() |
| 875 | } |
| 876 | |
| 877 | const 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 |
| 878 | FROM jobs j JOIN pipelines p ON p.id = j.pipeline_id` |
| 879 | |
| 880 | func scanJob(rows *sql.Rows) (Job, error) { |
| 881 | var j Job |
| 882 | var needs, vars, paths, tags, cache, optional, retryWhen, services string |
| 883 | var needsSet, allow, expire, timeout, interruptible int |
| 884 | var started, finished sql.NullString |
| 885 | 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 { |
| 886 | return Job{}, err |
| 887 | } |
| 888 | j.NeedsSet = needsSet == 1 |
| 889 | j.AllowFailure = allow == 1 |
| 890 | j.Interruptible = interruptible == 1 |
| 891 | j.ArtifactExpire = time.Duration(expire) * time.Second |
| 892 | j.Timeout = time.Duration(timeout) * time.Second |
| 893 | j.StartedAt = parseTime(started.String) |
| 894 | j.FinishedAt = parseTime(finished.String) |
| 895 | _ = json.Unmarshal([]byte(needs), &j.Needs) |
| 896 | _ = json.Unmarshal([]byte(vars), &j.Variables) |
| 897 | _ = json.Unmarshal([]byte(paths), &j.ArtifactPaths) |
| 898 | _ = json.Unmarshal([]byte(tags), &j.Tags) |
| 899 | _ = json.Unmarshal([]byte(cache), &j.CachePaths) |
| 900 | _ = json.Unmarshal([]byte(optional), &j.Optional) |
| 901 | _ = json.Unmarshal([]byte(retryWhen), &j.RetryWhen) |
| 902 | _ = json.Unmarshal([]byte(services), &j.Services) |
| 903 | return j, nil |
| 904 | } |
| 905 | |
| 906 | // ActivePipelines zijn nog niet af. |
| 907 | func (s *Store) ActivePipelines(ctx context.Context) ([]Pipeline, error) { |
| 908 | 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`) |
| 909 | if err != nil { |
| 910 | return nil, err |
| 911 | } |
| 912 | defer rows.Close() |
| 913 | var out []Pipeline |
| 914 | for rows.Next() { |
| 915 | p, err := scanPipeline(rows) |
| 916 | if err != nil { |
| 917 | return nil, err |
| 918 | } |
| 919 | out = append(out, p) |
| 920 | } |
| 921 | return out, rows.Err() |
| 922 | } |
| 923 | |
| 924 | // MarkJobRunning zet een wachtende job op running als hij dat nog is. |
| 925 | func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) { |
| 926 | res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'running', started_at = ? WHERE id = ? AND status = 'queued'`, now(), id) |
| 927 | if err != nil { |
| 928 | return false, err |
| 929 | } |
| 930 | n, _ := res.RowsAffected() |
| 931 | if n == 1 { |
| 932 | _, _ = 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) |
| 933 | } |
| 934 | return n == 1, nil |
| 935 | } |
| 936 | |
| 937 | // CountRunningJobs telt jobs die Steve nu uitvoert. |
| 938 | func (s *Store) CountRunningJobs(ctx context.Context) (int, error) { |
| 939 | var n int |
| 940 | err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs WHERE status = 'running'`).Scan(&n) |
| 941 | return n, err |
| 942 | } |
| 943 | |
| 944 | // FinishJob schrijft het eindresultaat en het log. |
| 945 | func (s *Store) FinishJob(ctx context.Context, id int64, status, extra string) error { |
| 946 | _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = log || ?, finished_at = ? WHERE id = ?`, status, extra, now(), id) |
| 947 | return err |
| 948 | } |
| 949 | |
| 950 | // AppendJobLog voegt tekst toe terwijl de job loopt. |
| 951 | func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error { |
| 952 | _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id) |
| 953 | return err |
| 954 | } |
| 955 | |
| 956 | // RequeueJob zet een mislukte job terug in de wachtrij voor een nieuwe poging. |
| 957 | func (s *Store) RequeueJob(ctx context.Context, id int64, attempt int, note string) error { |
| 958 | _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', attempt = ?, log = log || ?, finished_at = NULL, started_at = NULL WHERE id = ?`, attempt, note, id) |
| 959 | return err |
| 960 | } |
| 961 | |
| 962 | // CancelInterruptible annuleert onderbreekbare jobs van oudere pipelines op dezelfde ref. |
| 963 | // Lopende jobs komen terug zodat de runner hun context kan stoppen. |
| 964 | func (s *Store) CancelInterruptible(ctx context.Context, repoID int64, ref string, keep int64) (running []int64, pipes []int64, err error) { |
| 965 | rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.status FROM jobs j |
| 966 | JOIN pipelines p ON p.id = j.pipeline_id |
| 967 | WHERE p.repo_id = ? AND p.ref = ? AND p.id != ? AND j.interruptible = 1 AND j.status IN ('queued', 'running', 'manual')`, repoID, ref, keep) |
| 968 | if err != nil { |
| 969 | return nil, nil, err |
| 970 | } |
| 971 | defer rows.Close() |
| 972 | type row struct { |
| 973 | id, pipe int64 |
| 974 | status string |
| 975 | } |
| 976 | var found []row |
| 977 | seenPipe := map[int64]bool{} |
| 978 | for rows.Next() { |
| 979 | var item row |
| 980 | if err := rows.Scan(&item.id, &item.pipe, &item.status); err != nil { |
| 981 | return nil, nil, err |
| 982 | } |
| 983 | found = append(found, item) |
| 984 | if !seenPipe[item.pipe] { |
| 985 | seenPipe[item.pipe] = true |
| 986 | pipes = append(pipes, item.pipe) |
| 987 | } |
| 988 | } |
| 989 | if err := rows.Err(); err != nil { |
| 990 | return nil, nil, err |
| 991 | } |
| 992 | note := time.Now().UTC().Format(time.RFC3339) + "\tcanceled because a newer pipeline started for the same ref\n" |
| 993 | for _, item := range found { |
| 994 | if item.status == "running" { |
| 995 | running = append(running, item.id) |
| 996 | continue |
| 997 | } |
| 998 | 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 { |
| 999 | return running, pipes, err |
| 1000 | } |
| 1001 | } |
| 1002 | return running, pipes, nil |
| 1003 | } |
| 1004 | |
| 1005 | // RefreshPipelineStatus berekent de pipelinestatus uit de jobs. |
| 1006 | func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) { |
| 1007 | jobs, err := s.JobsByPipeline(ctx, pipelineID) |
| 1008 | if err != nil { |
| 1009 | return "", err |
| 1010 | } |
| 1011 | status := "success" |
| 1012 | open := false |
| 1013 | manual := false |
| 1014 | canceled := false |
| 1015 | for _, j := range jobs { |
| 1016 | switch j.Status { |
| 1017 | case "failed": |
| 1018 | if !j.AllowFailure { |
| 1019 | status = "failed" |
| 1020 | } |
| 1021 | case "canceled": |
| 1022 | if !j.AllowFailure { |
| 1023 | canceled = true |
| 1024 | } |
| 1025 | case "queued", "running": |
| 1026 | open = true |
| 1027 | case "manual": |
| 1028 | manual = true |
| 1029 | } |
| 1030 | } |
| 1031 | switch { |
| 1032 | case open: |
| 1033 | // Een harde mislukking wint pas als er niets meer in de wachtrij of |
| 1034 | // aan het werk is. Anders blijft de runner latere jobs overslaan. |
| 1035 | status = "running" |
| 1036 | _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = ?`, pipelineID) |
| 1037 | case status == "failed": |
| 1038 | _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'failed', finished_at = ? WHERE id = ?`, now(), pipelineID) |
| 1039 | case canceled: |
| 1040 | status = "canceled" |
| 1041 | _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'canceled', finished_at = ? WHERE id = ?`, now(), pipelineID) |
| 1042 | case manual: |
| 1043 | status = "manual" |
| 1044 | _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'manual', finished_at = NULL WHERE id = ?`, pipelineID) |
| 1045 | default: |
| 1046 | _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'success', finished_at = ? WHERE id = ?`, now(), pipelineID) |
| 1047 | } |
| 1048 | return status, err |
| 1049 | } |
| 1050 | |
| 1051 | // ResourceBusy meldt of een andere job in deze repository die groep bezet. |
| 1052 | func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, except int64) (bool, error) { |
| 1053 | if group == "" { |
| 1054 | return false, nil |
| 1055 | } |
| 1056 | var n int |
| 1057 | 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) |
| 1058 | return n > 0, err |
| 1059 | } |
| 1060 | |
| 1061 | // RetryJob zet een mislukte of geannuleerde job terug in de wachtrij. |
| 1062 | func (s *Store) RetryJob(ctx context.Context, id int64) (bool, error) { |
| 1063 | res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', finished_at = NULL WHERE id = ? AND status IN ('failed', 'canceled')`, id) |
| 1064 | if err != nil { |
| 1065 | return false, err |
| 1066 | } |
| 1067 | n, _ := res.RowsAffected() |
| 1068 | if n == 1 { |
| 1069 | _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id) |
| 1070 | } |
| 1071 | return n == 1, nil |
| 1072 | } |
| 1073 | |
| 1074 | // CancelJob stopt een job die nog niet klaar is. |
| 1075 | func (s *Store) CancelJob(ctx context.Context, id int64) (bool, error) { |
| 1076 | res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'canceled', finished_at = ? WHERE id = ? AND status IN ('created', 'pending', 'queued', 'manual', 'running')`, now(), id) |
| 1077 | if err != nil { |
| 1078 | return false, err |
| 1079 | } |
| 1080 | n, _ := res.RowsAffected() |
| 1081 | return n == 1, nil |
| 1082 | } |
| 1083 | |
| 1084 | // QueueJob zet een handmatige job in de wachtrij. |
| 1085 | func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) { |
| 1086 | res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id) |
| 1087 | if err != nil { |
| 1088 | return false, err |
| 1089 | } |
| 1090 | n, _ := res.RowsAffected() |
| 1091 | if n == 1 { |
| 1092 | _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id) |
| 1093 | } |
| 1094 | return n == 1, nil |
| 1095 | } |
| 1096 | |
| 1097 | // SkipJob markeert een job die niet meer hoeft. |
| 1098 | func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error { |
| 1099 | _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status IN ('queued', 'manual')`, reason, now(), id) |
| 1100 | return err |
| 1101 | } |
| 1102 | |
| 1103 | // CreateJobToken maakt het token waarmee een lopende job de API aanroept. |
| 1104 | func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) { |
| 1105 | plain, err := newToken("bgj_") |
| 1106 | if err != nil { |
| 1107 | return "", err |
| 1108 | } |
| 1109 | _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?) |
| 1110 | ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`, |
| 1111 | jobID, hashToken(plain), now()) |
| 1112 | if err != nil { |
| 1113 | return "", err |
| 1114 | } |
| 1115 | return plain, nil |
| 1116 | } |
| 1117 | |
| 1118 | // JobByToken zoekt een lopende job bij een job-token. |
| 1119 | func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) { |
| 1120 | if len(token) < 4 || token[:4] != "bgj_" { |
| 1121 | return Job{}, errNotFound |
| 1122 | } |
| 1123 | var jobID int64 |
| 1124 | err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID) |
| 1125 | if errors.Is(err, sql.ErrNoRows) { |
| 1126 | return Job{}, errNotFound |
| 1127 | } |
| 1128 | if err != nil { |
| 1129 | return Job{}, err |
| 1130 | } |
| 1131 | rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID) |
| 1132 | if err != nil { |
| 1133 | return Job{}, err |
| 1134 | } |
| 1135 | defer rows.Close() |
| 1136 | if !rows.Next() { |
| 1137 | return Job{}, errNotFound |
| 1138 | } |
| 1139 | return scanJob(rows) |
| 1140 | } |
| 1141 | |
| 1142 | // JobByID leest een job van deze repository. |
| 1143 | func (s *Store) JobByID(ctx context.Context, repoID, id int64) (Job, error) { |
| 1144 | rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.repo_id = ? AND j.id = ?`, repoID, id) |
| 1145 | if err != nil { |
| 1146 | return Job{}, err |
| 1147 | } |
| 1148 | defer rows.Close() |
| 1149 | if !rows.Next() { |
| 1150 | return Job{}, errNotFound |
| 1151 | } |
| 1152 | return scanJob(rows) |
| 1153 | } |
| 1154 | |
| 1155 | // Artifact verwijst naar een bestand uit een job. |
| 1156 | type Artifact struct { |
| 1157 | ID int64 |
| 1158 | JobID int64 |
| 1159 | Path string |
| 1160 | StoragePath string |
| 1161 | Size int64 |
| 1162 | } |
| 1163 | |
| 1164 | // AddArtifact registreert een bewaard bestand. |
| 1165 | func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error { |
| 1166 | var exp any |
| 1167 | if expires != nil { |
| 1168 | exp = expires.UTC().Format(time.RFC3339) |
| 1169 | } |
| 1170 | _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`, |
| 1171 | jobID, relPath, storagePath, size, exp) |
| 1172 | return err |
| 1173 | } |
| 1174 | |
| 1175 | // ListArtifacts toont de bestanden van één job. |
| 1176 | func (s *Store) ListArtifacts(ctx context.Context, jobID int64) ([]Artifact, error) { |
| 1177 | rows, err := s.db.QueryContext(ctx, `SELECT id, job_id, path, storage_path, size FROM artifacts WHERE job_id = ? ORDER BY path`, jobID) |
| 1178 | if err != nil { |
| 1179 | return nil, err |
| 1180 | } |
| 1181 | defer rows.Close() |
| 1182 | var out []Artifact |
| 1183 | for rows.Next() { |
| 1184 | var a Artifact |
| 1185 | if err := rows.Scan(&a.ID, &a.JobID, &a.Path, &a.StoragePath, &a.Size); err != nil { |
| 1186 | return nil, err |
| 1187 | } |
| 1188 | out = append(out, a) |
| 1189 | } |
| 1190 | return out, rows.Err() |
| 1191 | } |
| 1192 | |
| 1193 | // ArtifactPath zoekt een bestand van een job in dezelfde pipeline. |
| 1194 | func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) { |
| 1195 | var storage string |
| 1196 | err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id |
| 1197 | WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage) |
| 1198 | if errors.Is(err, sql.ErrNoRows) { |
| 1199 | return "", errNotFound |
| 1200 | } |
| 1201 | return storage, err |
| 1202 | } |
| 1203 | |
| 1204 | // Release is een publicatie op een commit. |
| 1205 | type Release struct { |
| 1206 | ID int64 |
| 1207 | RepoID int64 |
| 1208 | Tag string |
| 1209 | CommitSHA string |
| 1210 | Name string |
| 1211 | Body string |
| 1212 | CreatedAt time.Time |
| 1213 | Assets []ReleaseAsset |
| 1214 | } |
| 1215 | |
| 1216 | // ReleaseAsset is een bestand bij een release. |
| 1217 | type ReleaseAsset struct { |
| 1218 | Name string |
| 1219 | StoragePath string |
| 1220 | Size int64 |
| 1221 | } |
| 1222 | |
| 1223 | // CreateRelease bewaart de release. De bestanden staan al op storagePath. |
| 1224 | func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) { |
| 1225 | if err := names.ValidTag(tag); err != nil { |
| 1226 | return 0, err |
| 1227 | } |
| 1228 | tx, err := s.db.BeginTx(ctx, nil) |
| 1229 | if err != nil { |
| 1230 | return 0, err |
| 1231 | } |
| 1232 | defer func() { _ = tx.Rollback() }() |
| 1233 | var author, job any |
| 1234 | if authorID != 0 { |
| 1235 | author = authorID |
| 1236 | } |
| 1237 | if jobID != 0 { |
| 1238 | job = jobID |
| 1239 | } |
| 1240 | res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, |
| 1241 | repoID, tag, sha, name, body, author, job, now()) |
| 1242 | if err != nil { |
| 1243 | if containsUnique(err) { |
| 1244 | return 0, i18n.E("err.tagExists", tag) |
| 1245 | } |
| 1246 | return 0, err |
| 1247 | } |
| 1248 | id, _ := res.LastInsertId() |
| 1249 | for _, a := range assets { |
| 1250 | 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 { |
| 1251 | return 0, err |
| 1252 | } |
| 1253 | } |
| 1254 | if err := tx.Commit(); err != nil { |
| 1255 | return 0, err |
| 1256 | } |
| 1257 | return id, nil |
| 1258 | } |
| 1259 | |
| 1260 | // ListReleases geeft publicaties, nieuwste eerst. |
| 1261 | func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) { |
| 1262 | 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) |
| 1263 | if err != nil { |
| 1264 | return nil, err |
| 1265 | } |
| 1266 | defer rows.Close() |
| 1267 | var out []Release |
| 1268 | for rows.Next() { |
| 1269 | var r Release |
| 1270 | var created string |
| 1271 | if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil { |
| 1272 | return nil, err |
| 1273 | } |
| 1274 | r.CreatedAt = parseTime(created) |
| 1275 | out = append(out, r) |
| 1276 | } |
| 1277 | if err := rows.Err(); err != nil { |
| 1278 | return nil, err |
| 1279 | } |
| 1280 | for i := range out { |
| 1281 | assets, err := s.releaseAssets(ctx, out[i].ID) |
| 1282 | if err != nil { |
| 1283 | return nil, err |
| 1284 | } |
| 1285 | out[i].Assets = assets |
| 1286 | } |
| 1287 | return out, nil |
| 1288 | } |
| 1289 | |
| 1290 | // ReleaseByTag leest één release. |
| 1291 | func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) { |
| 1292 | var r Release |
| 1293 | var created string |
| 1294 | 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). |
| 1295 | Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created) |
| 1296 | if errors.Is(err, sql.ErrNoRows) { |
| 1297 | return Release{}, errNotFound |
| 1298 | } |
| 1299 | if err != nil { |
| 1300 | return Release{}, err |
| 1301 | } |
| 1302 | r.CreatedAt = parseTime(created) |
| 1303 | r.Assets, err = s.releaseAssets(ctx, r.ID) |
| 1304 | return r, err |
| 1305 | } |
| 1306 | |
| 1307 | func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) { |
| 1308 | rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id) |
| 1309 | if err != nil { |
| 1310 | return nil, err |
| 1311 | } |
| 1312 | defer rows.Close() |
| 1313 | var out []ReleaseAsset |
| 1314 | for rows.Next() { |
| 1315 | var a ReleaseAsset |
| 1316 | if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil { |
| 1317 | return nil, err |
| 1318 | } |
| 1319 | out = append(out, a) |
| 1320 | } |
| 1321 | return out, rows.Err() |
| 1322 | } |
| 1323 | |
| 1324 | func trim(s string, n int) string { |
| 1325 | s = string([]rune(s)) |
| 1326 | if len([]rune(s)) > n { |
| 1327 | return string([]rune(s)[:n]) |
| 1328 | } |
| 1329 | return s |
| 1330 | } |
| 1331 | |
| 1332 | func containsUnique(err error) bool { |
| 1333 | return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique")))) |
| 1334 | } |
| 1335 | |
| 1336 | func contains(s, sub string) bool { |
| 1337 | return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0))) |
| 1338 | } |
| 1339 | |
| 1340 | func indexOf(s, sub string) int { |
| 1341 | for i := 0; i+len(sub) <= len(s); i++ { |
| 1342 | if s[i:i+len(sub)] == sub { |
| 1343 | return i |
| 1344 | } |
| 1345 | } |
| 1346 | return -1 |
| 1347 | } |