package server import ( "context" "net/http" "os" "path/filepath" "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) { 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")) } 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": 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) 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) 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")) } if gitrepo.HasTag(ctx, s.Git, dir, req.Tag) { return 0, fail(409, i18n.E("err.tagExists", req.Tag)) } if req.Name == "" { req.Name = req.Tag } if job.ID == 0 && len(req.Assets) > 0 { return 0, fail(400, i18n.E("err.assetsJob")) } var assets []store.ReleaseAsset 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")) } 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: info.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 }