BlueGit

timfa bluegit

Files

bluegit / internal / server / ops_ci.go

ops_ci.go

ops_ci.go 11.6 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "os"
7 "path/filepath"
8 "strconv"
9 "strings"
10
11 "gitlab.com/Timfa/bluegit/internal/access"
12 "gitlab.com/Timfa/bluegit/internal/gitrepo"
13 "gitlab.com/Timfa/bluegit/internal/i18n"
14 "gitlab.com/Timfa/bluegit/internal/names"
15 "gitlab.com/Timfa/bluegit/internal/store"
16)
17
18func (s *Server) opRunPipeline(ctx context.Context, user store.User, repo store.Repo, ref, source string) (int64, error) {
19 role, err := s.repoRole(ctx, user, repo)
20 if err != nil {
21 return 0, err
22 }
23 if !role.CanWriteCode() {
24 return 0, fail(403, i18n.E("err.forbidden"))
25 }
26 if repo.CIPaused {
27 return 0, fail(409, i18n.E("err.ciPaused"))
28 }
29 ref = safeRev(ref, repo.DefaultBranch)
30 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
31 sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", ref+"^{commit}")
32 if sha == "" {
33 return 0, fail(400, i18n.E("err.branchMissing"))
34 }
35 if source == "" {
36 source = "api"
37 }
38 id := s.startPipeline(ctx, repo, sha, "refs/heads/"+ref, user.Username, source, "", nil)
39 return id, nil
40}
41
42func (s *Server) opJobAction(ctx context.Context, user store.User, repo store.Repo, pipeID, jobID int64, action string) (store.Job, error) {
43 return s.opJobActionForce(ctx, user, repo, pipeID, jobID, action, false)
44}
45
46// opJobActionForce: force is nodig om een lopende doNotInterrupt-job te annuleren.
47func (s *Server) opJobActionForce(ctx context.Context, user store.User, repo store.Repo, pipeID, jobID int64, action string, force bool) (store.Job, error) {
48 role, err := s.repoRole(ctx, user, repo)
49 if err != nil {
50 return store.Job{}, err
51 }
52 if !role.CanWriteCode() {
53 return store.Job{}, fail(403, i18n.E("err.forbidden"))
54 }
55 p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)
56 if err != nil {
57 return store.Job{}, notFound(err)
58 }
59 jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)
60 var job store.Job
61 found := false
62 for _, j := range jobs {
63 if j.ID == jobID {
64 job = j
65 found = true
66 break
67 }
68 }
69 if !found {
70 return store.Job{}, fail(404, i18n.E("err.notFound"))
71 }
72 if (action == "play" || action == "retry") && expiredManualJob(job) {
73 return store.Job{}, fail(409, i18n.E("err.jobExpired", job.Name))
74 }
75 switch action {
76 case "play":
77 ok, err := s.Store.QueueJob(ctx, job.ID)
78 if err != nil {
79 return store.Job{}, fail(400, err)
80 }
81 if !ok {
82 return store.Job{}, fail(409, i18n.E("err.jobState"))
83 }
84 case "retry":
85 ok, err := s.Store.RetryJob(ctx, job.ID)
86 if err != nil {
87 return store.Job{}, fail(400, err)
88 }
89 if !ok {
90 return store.Job{}, fail(409, i18n.E("err.jobState"))
91 }
92 case "cancel":
93 if job.Status == "running" && job.DoNotInterrupt && !force {
94 return store.Job{}, fail(409, i18n.E("err.doNotInterrupt", job.Name))
95 }
96 ok, err := s.Store.CancelJob(ctx, job.ID)
97 if err != nil {
98 return store.Job{}, fail(400, err)
99 }
100 if !ok {
101 return store.Job{}, fail(409, i18n.E("err.jobState"))
102 }
103 if s.Runner != nil {
104 s.Runner.Interrupt([]int64{job.ID})
105 }
106 _, _ = s.Store.RefreshPipelineStatus(ctx, p.ID)
107 default:
108 return store.Job{}, fail(400, i18n.E("err.jobState"))
109 }
110 jobs, _ = s.Store.JobsByPipeline(ctx, p.ID)
111 for _, j := range jobs {
112 if j.ID == jobID {
113 return j, nil
114 }
115 }
116 return job, nil
117}
118
119func retryPipelineMode(mode string) string {
120 mode = strings.TrimSpace(mode)
121 if mode == "" {
122 return "failed"
123 }
124 return mode
125}
126
127func (s *Server) opRetryPipeline(ctx context.Context, user store.User, repo store.Repo, pipeID int64, mode string) (int64, error) {
128 mode = retryPipelineMode(mode)
129 role, err := s.repoRole(ctx, user, repo)
130 if err != nil {
131 return 0, err
132 }
133 if !role.CanWriteCode() {
134 return 0, fail(403, i18n.E("err.forbidden"))
135 }
136 p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)
137 if err != nil {
138 return 0, notFound(err)
139 }
140 if mode == "all" || mode == "failed" {
141 // Opnieuw starten kan alleen als er minstens één job gefaald is
142 // (ook runner_system_failure); zelfde regel als de knop in de UI.
143 jobs, err := s.Store.JobsByPipeline(ctx, p.ID)
144 if err != nil {
145 return 0, err
146 }
147 if !jobsFailed(jobs) {
148 return 0, fail(409, i18n.E("err.pipeNoFailed"))
149 }
150 }
151 switch mode {
152 case "all":
153 id, err := s.Store.ClonePipeline(ctx, repo.ID, p.ID)
154 if err != nil {
155 if store.IsNotFound(err) {
156 return 0, notFound(err)
157 }
158 return 0, fail(400, err)
159 }
160 return id, nil
161 case "failed":
162 ok, err := s.Store.RetryFailedJobs(ctx, p.ID)
163 if err != nil {
164 return 0, fail(400, err)
165 }
166 if !ok {
167 return 0, fail(409, i18n.E("err.pipeNoFailed"))
168 }
169 return p.ID, nil
170 default:
171 return 0, fail(400, i18n.E("err.pipeRetryMode"))
172 }
173}
174
175func (s *Server) opCancelPipeline(ctx context.Context, user store.User, repo store.Repo, pipeID int64, force bool) error {
176 role, err := s.repoRole(ctx, user, repo)
177 if err != nil {
178 return err
179 }
180 if !role.CanWriteCode() {
181 return fail(403, i18n.E("err.forbidden"))
182 }
183 p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)
184 if err != nil {
185 return notFound(err)
186 }
187 jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)
188 if prot := store.ProtectedRunning(jobs); len(prot) > 0 && !force {
189 return fail(409, i18n.E("err.doNotInterrupt", jobNames(prot)))
190 }
191 var running []int64
192 for _, j := range jobs {
193 if j.Status == "queued" || j.Status == "running" || j.Status == "manual" || j.Status == "pending" || j.Status == "created" {
194 ok, _ := s.Store.CancelJob(ctx, j.ID)
195 if ok && (j.Status == "running" || j.Status == "queued") {
196 running = append(running, j.ID)
197 }
198 }
199 }
200 if s.Runner != nil {
201 s.Runner.Interrupt(running)
202 }
203 _, _ = s.Store.RefreshPipelineStatus(ctx, p.ID)
204 return nil
205}
206
207func (s *Server) opLintCI(r *http.Request, repo store.Repo, body, ref string) (map[string]any, error) {
208 if len(body) > ciMaxBytes {
209 return nil, fail(400, i18n.E("edit.fail"))
210 }
211 ref = safeRev(ref, repo.DefaultBranch)
212 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
213 model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref))
214 lines := make([]string, len(model.Rows))
215 var bad []int
216 for i, row := range model.Rows {
217 lines[i] = string(row.HTML)
218 if row.Bad {
219 bad = append(bad, row.N)
220 }
221 }
222 return map[string]any{
223 "status": model.Status, "statusClass": model.Class, "errors": model.Errors,
224 "warnings": model.Warnings, "issues": model.Issues, "lines": lines, "bad": bad,
225 }, nil
226}
227
228func (s *Server) opSaveCI(ctx context.Context, user store.User, repo store.Repo, base, branch, message, body string, openMR bool) (string, int64, error) {
229 role, err := s.repoRole(ctx, user, repo)
230 if err != nil {
231 return "", 0, err
232 }
233 base = safeRev(base, repo.DefaultBranch)
234 if !validBranchName(branch) {
235 return "", 0, fail(400, i18n.E("edit.badBranch"))
236 }
237 if len(body) > ciMaxBytes {
238 return "", 0, fail(400, i18n.E("edit.fail"))
239 }
240 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
241 if openMR && (branch == base || access.BranchProtected(patterns, branch)) {
242 return "", 0, fail(400, i18n.E("edit.badBranch"))
243 }
244 sha, err := s.opWriteFiles(ctx, user, repo, role, branch, base, message, "", map[string]string{ciFile: body}, nil)
245 if err != nil {
246 return "", 0, err
247 }
248 if !openMR {
249 return sha, 0, nil
250 }
251 existing, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch)
252 if err != nil {
253 return sha, 0, fail(400, err)
254 }
255 if len(existing) > 0 {
256 return sha, existing[0].Number, nil
257 }
258 mr, err := s.opCreateMR(ctx, user, repo, message, "", branch, base, false)
259 if err != nil {
260 return sha, 0, err
261 }
262 return sha, mr.Number, nil
263}
264
265func (s *Server) opPublishRelease(ctx context.Context, repo store.Repo, author store.User, job store.Job, req releaseRequest) (int64, error) {
266 if s.StoragePath() == "" {
267 return 0, fail(503, i18n.E("err.noStorage"))
268 }
269 if err := names.ValidTag(req.Tag); err != nil {
270 return 0, fail(400, err)
271 }
272 if !safeSHA(req.Commit) {
273 return 0, fail(400, i18n.E("err.commitAbsent"))
274 }
275 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
276 if !gitrepo.HasCommit(ctx, s.Git, dir, req.Commit) {
277 return 0, fail(400, i18n.E("err.commitMissing"))
278 }
279 var replace *store.Release
280 if gitrepo.HasTag(ctx, s.Git, dir, req.Tag) {
281 if !req.Replace {
282 return 0, fail(409, i18n.E("err.tagExists", req.Tag))
283 }
284 rel, err := s.checkReplace(ctx, repo, job, req.Tag)
285 if err != nil {
286 return 0, err
287 }
288 replace = &rel
289 }
290 if req.Name == "" {
291 req.Name = req.Tag
292 }
293 if job.ID == 0 && len(req.Assets) > 0 {
294 return 0, fail(400, i18n.E("err.assetsJob"))
295 }
296 type srcAsset struct {
297 name, src string
298 size int64
299 }
300 var srcs []srcAsset
301 for _, a := range req.Assets {
302 if a.Name == "" {
303 a.Name = filepath.Base(a.Path)
304 }
305 if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" {
306 return 0, fail(400, i18n.E("err.assetName"))
307 }
308 src, err := s.Store.ArtifactPath(ctx, job.PipelineID, a.Job, a.Path)
309 if err != nil {
310 return 0, fail(400, i18n.E("err.artifactMissing", a.Job, a.Path))
311 }
312 info, err := os.Stat(src)
313 if err != nil {
314 return 0, fail(400, i18n.E("err.assetDisk"))
315 }
316 srcs = append(srcs, srcAsset{a.Name, src, info.Size()})
317 }
318 // Pas na alle controles: oude release, assets en tag weg.
319 if replace != nil {
320 if err := s.doReplace(ctx, repo, job, *replace, req.Commit); err != nil {
321 return 0, err
322 }
323 }
324 var assets []store.ReleaseAsset
325 for _, sa := range srcs {
326 a := struct{ Name string }{sa.name}
327 src := sa.src
328 dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name)
329 if err := copyRelease(src, dst); err != nil {
330 return 0, fail(500, i18n.E("err.assetCopy"))
331 }
332 assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: sa.size})
333 }
334 if err := s.postReceive(ctx, repo, author, dir, func() error {
335 name, email := gitrepo.FallbackName, gitrepo.FallbackEmail
336 if author.Username != "" {
337 name, email = author.Username, userEmail(author.Username)
338 } else if job.ID != 0 {
339 if p, err := s.Store.PipelineByID(ctx, repo.ID, job.PipelineID); err == nil && p.Actor != "" {
340 name, email = p.Actor, userEmail(p.Actor)
341 }
342 }
343 return gitrepo.Tag(ctx, s.Git, dir, req.Tag, req.Commit, req.Name, name, email)
344 }); err != nil {
345 return 0, fail(400, i18n.E("err.tagFail", err.Error()))
346 }
347 authorID := author.ID
348 id, err := s.Store.CreateRelease(ctx, repo.ID, req.Tag, req.Commit, req.Name, req.Body, authorID, job.ID, assets)
349 if err != nil {
350 return 0, fail(400, err)
351 }
352 s.Dispatch(repo.ID, s.releaseEvent(repo, req.Tag, req.Name, req.Commit, assets))
353 return id, nil
354}
355
356func (s *Server) opCIFile(ctx context.Context, repo store.Repo, ref string) (string, error) {
357 ref = safeRev(ref, repo.DefaultBranch)
358 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
359 body := gitOne(ctx, s.Git, dir, "show", ref+":"+ciFile)
360 return body, nil
361}
362
363// jobNames noemt jobs als "a", "b" voor meldingen.
364func jobNames(jobs []store.Job) string {
365 names := make([]string, 0, len(jobs))
366 for _, j := range jobs {
367 names = append(names, strconv.Quote(j.Name))
368 }
369 return strings.Join(names, ", ")
370}
371
372// forceParam leest force=true|1 uit query of formulier.
373func forceParam(r *http.Request) bool {
374 v := r.URL.Query().Get("force")
375 if v == "" {
376 v = r.FormValue("force")
377 }
378 return v == "true" || v == "1"
379}
380
381// revokeRunner trekt een aparte runner in, behalve als hij een lopende
382// doNotInterrupt-job heeft en force uit staat.
383func (s *Server) revokeRunner(ctx context.Context, kind string, owner, id int64, force bool) error {
384 if prot, _ := s.Store.RunningProtectedJobs(ctx, 0, id); len(prot) > 0 && !force {
385 return fail(409, i18n.E("err.dniRunnerRevoke", jobNames(prot)))
386 }
387 return s.Store.RevokeRunner(ctx, kind, owner, id)
388}
389
390func (s *Server) revokeErr(r *http.Request, err error) string {
391 if statusOf(err) == http.StatusConflict {
392 return i18n.Text(s.langOf(r), err)
393 }
394 return s.tr(r, "runner.missing")
395}