BlueGit

timfa bluegit

Files

bluegit / internal / server / ops_ci.go

ops_ci.go

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