package server import ( "context" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/ci" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" ) // checkReplace: mag deze job de bestaande release met deze tag vervangen? // Alle regels moeten gelden: // - alleen met een job-token (het eigen project is al gecontroleerd); // - de pipeline draait op een branch, niet op forks/*, en die branch is // niet beschermd (master e.d. dus nooit); // - de tag past niet op een beschermd tagpatroon; // - de pipeline is veroorzaakt door (actor) een maintainer of hoger van // het project (of een instance-admin); // - de bestaande release is door een job gemaakt, in een pipeline op // dezelfde branch. Een release met de hand of van een andere ref blijft. func (s *Server) checkReplace(ctx context.Context, repo store.Repo, job store.Job, tag string) (store.Release, error) { if job.ID == 0 { return store.Release{}, fail(403, i18n.E("err.replaceToken")) } p, err := s.Store.PipelineByID(ctx, repo.ID, job.PipelineID) if err != nil { return store.Release{}, fail(403, i18n.E("err.replaceRef")) } if !strings.HasPrefix(p.Ref, "refs/heads/") { return store.Release{}, fail(403, i18n.E("err.replaceRef")) } branch := strings.TrimPrefix(p.Ref, "refs/heads/") if branch == "" || strings.HasPrefix(branch, ci.ForkBranchPrefix) { return store.Release{}, fail(403, i18n.E("err.replaceRef")) } pat, err := s.Store.ProtectedPatterns(ctx, repo.ID) if err != nil || access.BranchProtected(pat, branch) { return store.Release{}, fail(403, i18n.E("err.replaceRef")) } tpat, err := s.Store.ProtectedTagPatterns(ctx, repo.ID) if err != nil || access.BranchProtected(tpat, tag) { return store.Release{}, fail(403, i18n.E("err.tagProtected", tag)) } if p.Actor == "" { return store.Release{}, fail(403, i18n.E("err.replaceActor")) } actor, err := s.Store.UserByUsername(ctx, p.Actor) if err != nil || actor.ID == 0 { return store.Release{}, fail(403, i18n.E("err.replaceActor")) } if !actor.InstanceAdmin { role, err := s.Store.EffectiveRole(ctx, actor.ID, repo.ID) if err != nil || !role.AtLeast(access.RoleMaintainer) { return store.Release{}, fail(403, i18n.E("err.replaceActor")) } } rel, err := s.Store.ReleaseByTag(ctx, repo.ID, tag) if err != nil { // Alleen een tag, geen release: niet van een job, dus blijven. return store.Release{}, fail(409, i18n.E("err.replaceOrigin", tag)) } jid, err := s.Store.ReleaseJobID(ctx, rel.ID) if err != nil || jid == 0 { return store.Release{}, fail(409, i18n.E("err.replaceOrigin", tag)) } oj, err := s.Store.JobByID(ctx, repo.ID, jid) if err != nil { return store.Release{}, fail(409, i18n.E("err.replaceOrigin", tag)) } op, err := s.Store.PipelineByID(ctx, repo.ID, oj.PipelineID) if err != nil || op.Ref != p.Ref { return store.Release{}, fail(409, i18n.E("err.replaceOrigin", tag)) } return rel, nil } // doReplace verwijdert de oude release, assets en tag, met een auditregel. func (s *Server) doReplace(ctx context.Context, repo store.Repo, job store.Job, rel store.Release, newCommit string) error { paths, err := s.Store.DeleteRelease(ctx, rel.ID) if err != nil { return fail(500, err) } for _, p := range paths { s.removeAssetFile(p) } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if err := gitrepo.DeleteTag(ctx, s.Git, dir, rel.Tag); err != nil { return fail(400, err) } s.refsChanged(repo) actor, ref := "", "" if p, err := s.Store.PipelineByID(ctx, repo.ID, job.PipelineID); err == nil { actor, ref = p.Actor, p.Ref } if s.Log != nil { s.Log.Info("release audit", "action", "replace", "repo", repo.FullPath(), "tag", rel.Tag, "old_commit", rel.CommitSHA, "new_commit", newCommit, "job", job.ID, "pipeline", job.PipelineID, "ref", ref, "actor", actor) } return nil }