package server import ( "context" "net/http" "os/exec" "strings" "gitlab.com/Timfa/bluegit/internal/ci" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" ) // planPipeline leest blue-ci-cd.yml en kiest de jobs. // Een ontbrekend bestand geeft geen jobs en geen fout. // broken is een kapot bestand; de aanroeper bewaart dan een mislukte pipeline. func (s *Server) planPipeline(ctx context.Context, repo store.Repo, sha, ref, source, before string, mr *ci.MRInfo) (string, []store.NewJob, error) { dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) raw, err := gitShow(ctx, s.Git, dir, sha, "blue-ci-cd.yml") if err != nil || len(raw) == 0 { return "", nil, nil } read := func(path string) ([]byte, error) { return gitShow(ctx, s.Git, dir, sha, path) } spec, err := ci.ParseIn(raw, read) if err != nil { return "", nil, err } name, kind := ci.SplitRef(ref) title := strings.TrimSpace(gitOne(ctx, s.Git, dir, "log", "-1", "--format=%s", sha)) files := gitLines(ctx, s.Git, dir, "ls-tree", "-r", "--name-only", sha) changed := changedFiles(ctx, s.Git, dir, sha, before, files) base := strings.TrimRight(s.Cfg.BaseURL, "/") stamp, _ := gitrepo.CommitterTimestamp(ctx, s.Git, dir, sha) env := ci.Variables(ci.Ref{ SHA: sha, FullRef: ref, Name: name, Kind: kind, Title: title, Timestamp: stamp, DefaultBranch: repo.DefaultBranch, Source: source, ProjectPath: repo.FullPath(), ProjectURL: base + "/" + repo.FullPath(), APIURL: base + "/api/v1", MR: mr, }) ev := ci.Eval{Env: env, Changed: changed, Files: files} allow, err := spec.Allow(ev) if err != nil { return "", nil, err } if !allow { return title, nil, nil } active, err := spec.Select(ev) if err != nil { return "", nil, err } var jobs []store.NewJob for i, j := range active { vars := map[string]string{} for k, v := range spec.Variables { vars[k] = v } for k, v := range j.Variables { vars[k] = v } needs := j.Needs if needs == nil { needs = []string{} } paths := j.Artifacts.Paths if paths == nil { paths = []string{} } var services []store.Service for _, svc := range j.Services { services = append(services, store.Service{ Name: svc.Name, Alias: svc.Alias, Command: svc.Command, Entrypoint: svc.Entrypoint, Variables: svc.Variables, }) } jobs = append(jobs, store.NewJob{ Name: j.Name, Stage: j.Stage, Position: i, Image: j.Image, Before: strings.Join(j.Before, "\n"), Script: strings.Join(j.Script, "\n"), After: strings.Join(j.After, "\n"), Needs: needs, Optional: j.Optional, NeedsSet: j.NeedsSet, Variables: vars, ArtifactPaths: paths, ArtifactExpire: j.Artifacts.ExpireIn, AllowFailure: j.AllowFailure, When: j.When, Timeout: j.Timeout, Tags: j.Tags, CachePaths: j.Cache.Paths, CacheKey: j.Cache.Key, ResourceGroup: j.ResourceGroup, RetryMax: j.Retry.Max, RetryWhen: j.Retry.When, Services: services, Environment: j.Environment.Name, EnvironmentURL: j.Environment.URL, Interruptible: j.Interruptible, }) } return title, jobs, nil } func gitShow(ctx context.Context, gitBin, dir, sha, path string) ([]byte, error) { if path == "" || strings.Contains(path, "..") || strings.HasPrefix(path, "/") { return nil, i18n.E("ci.err.rel", path) } return exec.CommandContext(ctx, gitBin, "-C", dir, "show", sha+":"+path).Output() } func (s *Server) startMergeRequestPipelines(ctx context.Context, repo store.Repo, sha, branch, actor, before string) { mrs, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch) if err != nil { return } for _, mr := range mrs { s.startOneMergePipeline(ctx, repo, sha, actor, before, mr) } } // rerunMergeRequestsOnTarget start een nieuwe merge-request-pipeline op de // broncommit wanneer de doelbranch zelf een push krijgt. func (s *Server) rerunMergeRequestsOnTarget(ctx context.Context, repo store.Repo, branch, actor string) { mrs, err := s.Store.OpenMergeRequestsByTarget(ctx, repo.ID, branch) if err != nil { return } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) for _, mr := range mrs { sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.SourceBranch) if sha == "" { continue } s.startOneMergePipeline(ctx, repo, sha, actor, "", mr) } } func (s *Server) startOneMergePipeline(ctx context.Context, repo store.Repo, sha, actor, before string, mr store.MergeRequest) { dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) base := strings.TrimRight(s.Cfg.BaseURL, "/") info := &ci.MRInfo{ ID: mr.ID, IID: mr.Number, Title: mr.Title, SourceBranch: mr.SourceBranch, TargetBranch: mr.TargetBranch, ProjectPath: repo.FullPath(), ProjectURL: base + "/" + repo.FullPath(), TargetSHA: gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.TargetBranch), } s.startPipeline(ctx, repo, sha, "refs/heads/"+mr.SourceBranch, actor, "merge_request_event", before, info) } // mergeBlocks zijn de vertaalde redenen waarom mergen nog niet mag. // Een pipeline is verplicht zodra blue-ci-cd.yml jobs voor deze merge request kiest. func (s *Server) mergeBlocks(r *http.Request, repo store.Repo, mr store.MergeRequest) []string { if mr.Status != "open" { return nil } var blocks []string if mr.Draft { blocks = append(blocks, s.tr(r, "mr.block.draft")) } if s.Cfg.CI.Enabled && s.StoragePath() != "" { blocks = append(blocks, s.pipelineBlocks(r, repo, mr)...) } blocks = append(blocks, s.reviewBlocks(r, repo, mr)...) if s.StoragePath() != "" { dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if conflict, known := s.branchConflict(r.Context(), dir, mr.TargetBranch, mr.SourceBranch); known && conflict { blocks = append(blocks, s.tr(r, "mr.block.conflict")) } } return blocks } func (s *Server) branchConflict(ctx context.Context, dir, target, source string) (conflict, known bool) { if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+target) == "" { return false, false } if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+source) == "" { return false, false } conflict, err := gitrepo.Conflicts(ctx, s.Git, dir, "refs/heads/"+target, "refs/heads/"+source) if err != nil { return false, false } return conflict, true } func (s *Server) pipelineBlocks(r *http.Request, repo store.Repo, mr store.MergeRequest) []string { ctx := r.Context() dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.SourceBranch) required := false if sha != "" { info := &ci.MRInfo{ ID: mr.ID, IID: mr.Number, Title: mr.Title, SourceBranch: mr.SourceBranch, TargetBranch: mr.TargetBranch, ProjectPath: repo.FullPath(), } _, jobs, broken := s.planPipeline(ctx, repo, sha, "refs/heads/"+mr.SourceBranch, "merge_request_event", "", info) required = broken != nil || len(jobs) > 0 } p, err := s.Store.LatestMergePipeline(ctx, repo.ID, mr.ID) if store.IsNotFound(err) { if required { return []string{s.tr(r, "mr.block.waiting")} } return nil } if err != nil { return []string{s.tr(r, "mr.block.waiting")} } jobs, err := s.Store.JobsByPipeline(ctx, p.ID) if err != nil { return []string{s.tr(r, "mr.block.waiting")} } switch store.PipelineBlocksMerge(jobs) { case "running": return []string{s.tr(r, "mr.block.running")} case "failed": return []string{s.tr(r, "mr.block.failed")} case "waiting": if required { return []string{s.tr(r, "mr.block.waiting")} } } return nil } func (s *Server) fillMRPipeline(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest) { p, err := s.Store.LatestMergePipeline(r.Context(), repo.ID, mr.ID) if err != nil { return } row := s.pipeRow(r, s.langOf(r), repo, p, map[string]store.User{}, s.queueRanks(r.Context())) v.MRPipe = &row }