BlueGit

timfa bluegit

Files

bluegit / internal / store / pipeline_retry.go

pipeline_retry.go

pipeline_retry.go 4.8 KiB Download Raw
1package store
2
3import "context"
4
5// ClonePipeline maakt een nieuwe pipeline op dezelfde commit, ref, bron
6// en merge-requestkoppeling. De jobs beginnen opnieuw. Een geslaagde
7// job van de oude pipeline blijft daar staan.
8func (s *Store) ClonePipeline(ctx context.Context, repoID, id int64) (int64, error) {
9 p, err := s.PipelineByID(ctx, repoID, id)
10 if err != nil {
11 return 0, err
12 }
13 jobs, err := s.JobsByPipeline(ctx, id)
14 if err != nil {
15 return 0, err
16 }
17 tx, err := s.db.BeginTx(ctx, nil)
18 if err != nil {
19 return 0, err
20 }
21 defer func() { _ = tx.Rollback() }()
22 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, actor, commit_title, created_at, mr_id, target_sha)
23 VALUES (?, ?, ?, 'queued', ?, ?, ?, ?, ?, ?)`,
24 p.RepoID, p.CommitSHA, p.Ref, p.Source, p.Actor, p.CommitTitle, now(), p.MRID, p.TargetSHA)
25 if err != nil {
26 return 0, err
27 }
28 newID, _ := res.LastInsertId()
29 if err := insertPipelineJobs(ctx, tx, newID, p.RepoID, jobsToNew(jobs)); err != nil {
30 return 0, err
31 }
32 if err := tx.Commit(); err != nil {
33 return 0, err
34 }
35 return newID, nil
36}
37
38// RetryFailedJobs zet mislukte jobs terug in de wachtrij, plus de jobs
39// die daardoor niets deden: overgeslagen of nooit gestarte jobs die via
40// needs of een latere stage van een mislukte job afhangen.
41// Geslaagde jobs blijven. false betekent dat er geen mislukte job is.
42func (s *Store) RetryFailedJobs(ctx context.Context, pipelineID int64) (bool, error) {
43 jobs, err := s.JobsByPipeline(ctx, pipelineID)
44 if err != nil {
45 return false, err
46 }
47 plan := retryPlan(jobs)
48 if plan == nil {
49 return false, nil
50 }
51 tx, err := s.db.BeginTx(ctx, nil)
52 if err != nil {
53 return false, err
54 }
55 defer func() { _ = tx.Rollback() }()
56 for id, status := range plan {
57 if _, err := tx.ExecContext(ctx, `UPDATE jobs SET status = ?, log = '', attempt = 0, finished_at = NULL, started_at = NULL WHERE id = ? AND pipeline_id = ?`, status, id, pipelineID); err != nil {
58 return false, err
59 }
60 }
61 if err := tx.Commit(); err != nil {
62 return false, err
63 }
64 if _, err := s.RefreshPipelineStatus(ctx, pipelineID); err != nil {
65 return false, err
66 }
67 return true, nil
68}
69
70func jobsToNew(jobs []Job) []NewJob {
71 out := make([]NewJob, len(jobs))
72 for i, j := range jobs {
73 out[i] = NewJob{
74 Name: j.Name, Stage: j.Stage, Position: j.Position,
75 Image: j.Image, Before: j.Before, Script: j.Script, After: j.After,
76 Needs: j.Needs, Optional: j.Optional, NeedsSet: j.NeedsSet,
77 Variables: j.Variables, ArtifactPaths: j.ArtifactPaths, ArtifactExpire: j.ArtifactExpire,
78 AllowFailure: j.AllowFailure, When: j.When, Timeout: j.Timeout,
79 Tags: j.Tags, CachePaths: j.CachePaths, CacheKey: j.CacheKey,
80 ResourceGroup: j.ResourceGroup, RetryMax: j.RetryMax, RetryWhen: j.RetryWhen,
81 Services: j.Services, Environment: j.Environment, EnvironmentURL: j.EnvironmentURL,
82 Interruptible: j.Interruptible, DoNotInterrupt: j.DoNotInterrupt,
83 }
84 }
85 return out
86}
87
88// retryPlan kiest per job de nieuwe status.
89// nil betekent dat geen enkele job de status failed heeft.
90func retryPlan(jobs []Job) map[int64]string {
91 failed := map[int]bool{}
92 hasFailed := false
93 for i, j := range jobs {
94 if j.Status == "failed" {
95 failed[i] = true
96 hasFailed = true
97 }
98 }
99 if !hasFailed {
100 return nil
101 }
102 preds := predecessorIndexes(jobs)
103 down := map[int]bool{}
104 for {
105 moved := false
106 for i, j := range jobs {
107 if failed[i] || down[i] || !jobIdle(j.Status) {
108 continue
109 }
110 for _, p := range preds[i] {
111 if failed[p] || down[p] {
112 down[i] = true
113 moved = true
114 break
115 }
116 }
117 }
118 if !moved {
119 break
120 }
121 }
122 out := make(map[int64]string, len(failed)+len(down))
123 for i, j := range jobs {
124 switch {
125 case failed[i]:
126 out[j.ID] = "queued"
127 case down[i]:
128 if j.When == "manual" {
129 out[j.ID] = "manual"
130 } else {
131 out[j.ID] = "queued"
132 }
133 }
134 }
135 return out
136}
137
138// jobIdle is een job die nog niet gedraaid heeft of is overgeslagen.
139func jobIdle(status string) bool {
140 switch status {
141 case "skipped", "created", "pending", "queued", "manual", "":
142 return true
143 default:
144 return false
145 }
146}
147
148// predecessorIndexes volgt needs als die gezet zijn, ook bij een lege lijst.
149// Zonder needs zijn alle jobs in eerdere stages de voorgangers.
150func predecessorIndexes(jobs []Job) [][]int {
151 byName := map[string][]int{}
152 stagePos := map[string]int{}
153 order := 0
154 for i, j := range jobs {
155 byName[j.Name] = append(byName[j.Name], i)
156 if _, ok := stagePos[j.Stage]; !ok {
157 stagePos[j.Stage] = order
158 order++
159 }
160 }
161 out := make([][]int, len(jobs))
162 for i, j := range jobs {
163 if j.NeedsSet {
164 for _, n := range j.Needs {
165 out[i] = append(out[i], byName[n]...)
166 }
167 continue
168 }
169 my := stagePos[j.Stage]
170 for k, other := range jobs {
171 if k != i && stagePos[other.Stage] < my {
172 out[i] = append(out[i], k)
173 }
174 }
175 }
176 return out
177}