package server import ( "context" "net/http" "os" "path/filepath" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/names" "gitlab.com/Timfa/bluegit/internal/store" ) func (s *Server) opRunPipeline(ctx context.Context, user store.User, repo store.Repo, ref, source string) (int64, error) { role, err := s.repoRole(ctx, user, repo) if err != nil { return 0, err } if !role.CanWriteCode() { return 0, fail(403, i18n.E("err.forbidden")) } ref = safeRev(ref, repo.DefaultBranch) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", ref+"^{commit}") if sha == "" { return 0, fail(400, i18n.E("err.branchMissing")) } if source == "" { source = "api" } id := s.startPipeline(ctx, repo, sha, "refs/heads/"+ref, user.Username, source, "", nil) return id, nil } func (s *Server) opJobAction(ctx context.Context, user store.User, repo store.Repo, pipeID, jobID int64, action string) (store.Job, error) { return s.opJobActionForce(ctx, user, repo, pipeID, jobID, action, false) } // opJobActionForce: force is nodig om een lopende doNotInterrupt-job te annuleren. func (s *Server) opJobActionForce(ctx context.Context, user store.User, repo store.Repo, pipeID, jobID int64, action string, force bool) (store.Job, error) { role, err := s.repoRole(ctx, user, repo) if err != nil { return store.Job{}, err } if !role.CanWriteCode() { return store.Job{}, fail(403, i18n.E("err.forbidden")) } p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID) if err != nil { return store.Job{}, notFound(err) } jobs, _ := s.Store.JobsByPipeline(ctx, p.ID) var job store.Job found := false for _, j := range jobs { if j.ID == jobID { job = j found = true break } } if !found { return store.Job{}, fail(404, i18n.E("err.notFound")) } if (action == "play" || action == "retry") && expiredManualJob(job) { return store.Job{}, fail(409, i18n.E("err.jobExpired", job.Name)) } switch action { case "play": ok, err := s.Store.QueueJob(ctx, job.ID) if err != nil { return store.Job{}, fail(400, err) } if !ok { return store.Job{}, fail(409, i18n.E("err.jobState")) } case "retry": ok, err := s.Store.RetryJob(ctx, job.ID) if err != nil { return store.Job{}, fail(400, err) } if !ok { return store.Job{}, fail(409, i18n.E("err.jobState")) } case "cancel": if job.Status == "running" && job.DoNotInterrupt && !force { return store.Job{}, fail(409, i18n.E("err.doNotInterrupt", job.Name)) } ok, err := s.Store.CancelJob(ctx, job.ID) if err != nil { return store.Job{}, fail(400, err) } if !ok { return store.Job{}, fail(409, i18n.E("err.jobState")) } if s.Runner != nil { s.Runner.Interrupt([]int64{job.ID}) } _, _ = s.Store.RefreshPipelineStatus(ctx, p.ID) default: return store.Job{}, fail(400, i18n.E("err.jobState")) } jobs, _ = s.Store.JobsByPipeline(ctx, p.ID) for _, j := range jobs { if j.ID == jobID { return j, nil } } return job, nil } func (s *Server) opRetryPipeline(ctx context.Context, user store.User, repo store.Repo, pipeID int64, mode string) (int64, error) { role, err := s.repoRole(ctx, user, repo) if err != nil { return 0, err } if !role.CanWriteCode() { return 0, fail(403, i18n.E("err.forbidden")) } p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID) if err != nil { return 0, notFound(err) } if mode == "all" || mode == "failed" { // Opnieuw starten kan alleen als er minstens één job gefaald is // (ook runner_system_failure); zelfde regel als de knop in de UI. jobs, err := s.Store.JobsByPipeline(ctx, p.ID) if err != nil { return 0, err } if !jobsFailed(jobs) { return 0, fail(409, i18n.E("err.pipeNoFailed")) } } switch mode { case "all": id, err := s.Store.ClonePipeline(ctx, repo.ID, p.ID) if err != nil { if store.IsNotFound(err) { return 0, notFound(err) } return 0, fail(400, err) } return id, nil case "failed": ok, err := s.Store.RetryFailedJobs(ctx, p.ID) if err != nil { return 0, fail(400, err) } if !ok { return 0, fail(409, i18n.E("err.pipeNoFailed")) } return p.ID, nil default: return 0, fail(400, i18n.E("err.pipeRetryMode")) } } func (s *Server) opCancelPipeline(ctx context.Context, user store.User, repo store.Repo, pipeID int64, force bool) error { role, err := s.repoRole(ctx, user, repo) if err != nil { return err } if !role.CanWriteCode() { return fail(403, i18n.E("err.forbidden")) } p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID) if err != nil { return notFound(err) } jobs, _ := s.Store.JobsByPipeline(ctx, p.ID) if prot := store.ProtectedRunning(jobs); len(prot) > 0 && !force { return fail(409, i18n.E("err.doNotInterrupt", jobNames(prot))) } var running []int64 for _, j := range jobs { if j.Status == "queued" || j.Status == "running" || j.Status == "manual" || j.Status == "pending" || j.Status == "created" { ok, _ := s.Store.CancelJob(ctx, j.ID) if ok && (j.Status == "running" || j.Status == "queued") { running = append(running, j.ID) } } } if s.Runner != nil { s.Runner.Interrupt(running) } _, _ = s.Store.RefreshPipelineStatus(ctx, p.ID) return nil } func (s *Server) opLintCI(r *http.Request, repo store.Repo, body, ref string) (map[string]any, error) { if len(body) > ciMaxBytes { return nil, fail(400, i18n.E("edit.fail")) } ref = safeRev(ref, repo.DefaultBranch) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref)) lines := make([]string, len(model.Rows)) var bad []int for i, row := range model.Rows { lines[i] = string(row.HTML) if row.Bad { bad = append(bad, row.N) } } return map[string]any{ "status": model.Status, "statusClass": model.Class, "errors": model.Errors, "warnings": model.Warnings, "issues": model.Issues, "lines": lines, "bad": bad, }, nil } func (s *Server) opSaveCI(ctx context.Context, user store.User, repo store.Repo, base, branch, message, body string, openMR bool) (string, int64, error) { role, err := s.repoRole(ctx, user, repo) if err != nil { return "", 0, err } base = safeRev(base, repo.DefaultBranch) if !validBranchName(branch) { return "", 0, fail(400, i18n.E("edit.badBranch")) } if len(body) > ciMaxBytes { return "", 0, fail(400, i18n.E("edit.fail")) } patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID) if openMR && (branch == base || access.BranchProtected(patterns, branch)) { return "", 0, fail(400, i18n.E("edit.badBranch")) } sha, err := s.opWriteFiles(ctx, user, repo, role, branch, base, message, "", map[string]string{ciFile: body}, nil) if err != nil { return "", 0, err } if !openMR { return sha, 0, nil } existing, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch) if err != nil { return sha, 0, fail(400, err) } if len(existing) > 0 { return sha, existing[0].Number, nil } mr, err := s.opCreateMR(ctx, user, repo, message, "", branch, base, false) if err != nil { return sha, 0, err } return sha, mr.Number, nil } func (s *Server) opPublishRelease(ctx context.Context, repo store.Repo, author store.User, job store.Job, req releaseRequest) (int64, error) { if s.StoragePath() == "" { return 0, fail(503, i18n.E("err.noStorage")) } if err := names.ValidTag(req.Tag); err != nil { return 0, fail(400, err) } if !safeSHA(req.Commit) { return 0, fail(400, i18n.E("err.commitAbsent")) } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if !gitrepo.HasCommit(ctx, s.Git, dir, req.Commit) { return 0, fail(400, i18n.E("err.commitMissing")) } var replace *store.Release if gitrepo.HasTag(ctx, s.Git, dir, req.Tag) { if !req.Replace { return 0, fail(409, i18n.E("err.tagExists", req.Tag)) } rel, err := s.checkReplace(ctx, repo, job, req.Tag) if err != nil { return 0, err } replace = &rel } if req.Name == "" { req.Name = req.Tag } if job.ID == 0 && len(req.Assets) > 0 { return 0, fail(400, i18n.E("err.assetsJob")) } type srcAsset struct { name, src string size int64 } var srcs []srcAsset for _, a := range req.Assets { if a.Name == "" { a.Name = filepath.Base(a.Path) } if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" { return 0, fail(400, i18n.E("err.assetName")) } src, err := s.Store.ArtifactPath(ctx, job.PipelineID, a.Job, a.Path) if err != nil { return 0, fail(400, i18n.E("err.artifactMissing", a.Job, a.Path)) } info, err := os.Stat(src) if err != nil { return 0, fail(400, i18n.E("err.assetDisk")) } srcs = append(srcs, srcAsset{a.Name, src, info.Size()}) } // Pas na alle controles: oude release, assets en tag weg. if replace != nil { if err := s.doReplace(ctx, repo, job, *replace, req.Commit); err != nil { return 0, err } } var assets []store.ReleaseAsset for _, sa := range srcs { a := struct{ Name string }{sa.name} src := sa.src dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name) if err := copyRelease(src, dst); err != nil { return 0, fail(500, i18n.E("err.assetCopy")) } assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: sa.size}) } if err := s.postReceive(ctx, repo, author, dir, func() error { name, email := gitrepo.FallbackName, gitrepo.FallbackEmail if author.Username != "" { name, email = author.Username, userEmail(author.Username) } else if job.ID != 0 { if p, err := s.Store.PipelineByID(ctx, repo.ID, job.PipelineID); err == nil && p.Actor != "" { name, email = p.Actor, userEmail(p.Actor) } } return gitrepo.Tag(ctx, s.Git, dir, req.Tag, req.Commit, req.Name, name, email) }); err != nil { return 0, fail(400, i18n.E("err.tagFail", err.Error())) } authorID := author.ID id, err := s.Store.CreateRelease(ctx, repo.ID, req.Tag, req.Commit, req.Name, req.Body, authorID, job.ID, assets) if err != nil { return 0, fail(400, err) } s.Dispatch(repo.ID, s.releaseEvent(repo, req.Tag, req.Name, req.Commit, assets)) return id, nil } func (s *Server) opCIFile(ctx context.Context, repo store.Repo, ref string) (string, error) { ref = safeRev(ref, repo.DefaultBranch) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) body := gitOne(ctx, s.Git, dir, "show", ref+":"+ciFile) return body, nil } // jobNames noemt jobs als "a", "b" voor meldingen. func jobNames(jobs []store.Job) string { names := make([]string, 0, len(jobs)) for _, j := range jobs { names = append(names, strconv.Quote(j.Name)) } return strings.Join(names, ", ") } // forceParam leest force=true|1 uit query of formulier. func forceParam(r *http.Request) bool { v := r.URL.Query().Get("force") if v == "" { v = r.FormValue("force") } return v == "true" || v == "1" } // revokeRunner trekt een aparte runner in, behalve als hij een lopende // doNotInterrupt-job heeft en force uit staat. func (s *Server) revokeRunner(ctx context.Context, kind string, owner, id int64, force bool) error { if prot, _ := s.Store.RunningProtectedJobs(ctx, 0, id); len(prot) > 0 && !force { return fail(409, i18n.E("err.dniRunnerRevoke", jobNames(prot))) } return s.Store.RevokeRunner(ctx, kind, owner, id) } func (s *Server) revokeErr(r *http.Request, err error) string { if statusOf(err) == http.StatusConflict { return i18n.Text(s.langOf(r), err) } return s.tr(r, "runner.missing") }