mirror of
https://github.com/go-gitea/gitea
synced 2024-08-28 13:05:19 +02:00
The branch this is force pushing to is the head branch in the head repo, so it should be checking if that is protected, not the base.
185 lines
5.1 KiB
Go
185 lines
5.1 KiB
Go
// Copyright 2020 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package pull
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"code.gitea.io/gitea/models"
|
|
git_model "code.gitea.io/gitea/models/git"
|
|
issues_model "code.gitea.io/gitea/models/issues"
|
|
access_model "code.gitea.io/gitea/models/perm/access"
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
|
"code.gitea.io/gitea/models/unit"
|
|
user_model "code.gitea.io/gitea/models/user"
|
|
"code.gitea.io/gitea/modules/git"
|
|
"code.gitea.io/gitea/modules/log"
|
|
repo_module "code.gitea.io/gitea/modules/repository"
|
|
)
|
|
|
|
// Update updates pull request with base branch.
|
|
func Update(ctx context.Context, pull *issues_model.PullRequest, doer *user_model.User, message string, rebase bool) error {
|
|
var (
|
|
pr *issues_model.PullRequest
|
|
style repo_model.MergeStyle
|
|
)
|
|
|
|
pullWorkingPool.CheckIn(fmt.Sprint(pull.ID))
|
|
defer pullWorkingPool.CheckOut(fmt.Sprint(pull.ID))
|
|
|
|
if rebase {
|
|
pr = pull
|
|
style = repo_model.MergeStyleRebaseUpdate
|
|
} else {
|
|
// use merge functions but switch repo's and branch's
|
|
pr = &issues_model.PullRequest{
|
|
HeadRepoID: pull.BaseRepoID,
|
|
BaseRepoID: pull.HeadRepoID,
|
|
HeadBranch: pull.BaseBranch,
|
|
BaseBranch: pull.HeadBranch,
|
|
}
|
|
style = repo_model.MergeStyleMerge
|
|
}
|
|
|
|
if pull.Flow == issues_model.PullRequestFlowAGit {
|
|
// TODO: Not support update agit flow pull request's head branch
|
|
return fmt.Errorf("Not support update agit flow pull request's head branch")
|
|
}
|
|
|
|
if err := pr.LoadHeadRepo(ctx); err != nil {
|
|
log.Error("LoadHeadRepo: %v", err)
|
|
return fmt.Errorf("LoadHeadRepo: %w", err)
|
|
} else if err = pr.LoadBaseRepo(ctx); err != nil {
|
|
log.Error("LoadBaseRepo: %v", err)
|
|
return fmt.Errorf("LoadBaseRepo: %w", err)
|
|
}
|
|
|
|
diffCount, err := GetDiverging(ctx, pull)
|
|
if err != nil {
|
|
return err
|
|
} else if diffCount.Behind == 0 {
|
|
return fmt.Errorf("HeadBranch of PR %d is up to date", pull.Index)
|
|
}
|
|
|
|
_, err = rawMerge(ctx, pr, doer, style, "", message)
|
|
|
|
defer func() {
|
|
if rebase {
|
|
go AddTestPullRequestTask(doer, pr.BaseRepo.ID, pr.BaseBranch, false, "", "")
|
|
return
|
|
}
|
|
go AddTestPullRequestTask(doer, pr.HeadRepo.ID, pr.HeadBranch, false, "", "")
|
|
}()
|
|
|
|
return err
|
|
}
|
|
|
|
// IsUserAllowedToUpdate check if user is allowed to update PR with given permissions and branch protections
|
|
func IsUserAllowedToUpdate(ctx context.Context, pull *issues_model.PullRequest, user *user_model.User) (mergeAllowed, rebaseAllowed bool, err error) {
|
|
if pull.Flow == issues_model.PullRequestFlowAGit {
|
|
return false, false, nil
|
|
}
|
|
|
|
if user == nil {
|
|
return false, false, nil
|
|
}
|
|
headRepoPerm, err := access_model.GetUserRepoPermission(ctx, pull.HeadRepo, user)
|
|
if err != nil {
|
|
if repo_model.IsErrUnitTypeNotExist(err) {
|
|
return false, false, nil
|
|
}
|
|
return false, false, err
|
|
}
|
|
|
|
if err := pull.LoadBaseRepo(ctx); err != nil {
|
|
return false, false, err
|
|
}
|
|
|
|
pr := &issues_model.PullRequest{
|
|
HeadRepoID: pull.BaseRepoID,
|
|
HeadRepo: pull.BaseRepo,
|
|
BaseRepoID: pull.HeadRepoID,
|
|
BaseRepo: pull.HeadRepo,
|
|
HeadBranch: pull.BaseBranch,
|
|
BaseBranch: pull.HeadBranch,
|
|
}
|
|
|
|
pb, err := git_model.GetFirstMatchProtectedBranchRule(ctx, pr.BaseRepoID, pr.BaseBranch)
|
|
if err != nil {
|
|
return false, false, err
|
|
}
|
|
|
|
// can't do rebase on protected branch because need force push
|
|
if pb == nil {
|
|
if err := pr.LoadBaseRepo(ctx); err != nil {
|
|
return false, false, err
|
|
}
|
|
prUnit, err := pr.BaseRepo.GetUnit(ctx, unit.TypePullRequests)
|
|
if err != nil {
|
|
if repo_model.IsErrUnitTypeNotExist(err) {
|
|
return false, false, nil
|
|
}
|
|
log.Error("pr.BaseRepo.GetUnit(unit.TypePullRequests): %v", err)
|
|
return false, false, err
|
|
}
|
|
rebaseAllowed = prUnit.PullRequestsConfig().AllowRebaseUpdate
|
|
}
|
|
|
|
// Update function need push permission
|
|
if pb != nil {
|
|
pb.Repo = pull.BaseRepo
|
|
if !pb.CanUserPush(ctx, user) {
|
|
return false, false, nil
|
|
}
|
|
}
|
|
|
|
baseRepoPerm, err := access_model.GetUserRepoPermission(ctx, pull.BaseRepo, user)
|
|
if err != nil {
|
|
return false, false, err
|
|
}
|
|
|
|
mergeAllowed, err = IsUserAllowedToMerge(ctx, pr, headRepoPerm, user)
|
|
if err != nil {
|
|
return false, false, err
|
|
}
|
|
|
|
if pull.AllowMaintainerEdit {
|
|
mergeAllowedMaintainer, err := IsUserAllowedToMerge(ctx, pr, baseRepoPerm, user)
|
|
if err != nil {
|
|
return false, false, err
|
|
}
|
|
|
|
mergeAllowed = mergeAllowed || mergeAllowedMaintainer
|
|
}
|
|
|
|
return mergeAllowed, rebaseAllowed, nil
|
|
}
|
|
|
|
// GetDiverging determines how many commits a PR is ahead or behind the PR base branch
|
|
func GetDiverging(ctx context.Context, pr *issues_model.PullRequest) (*git.DivergeObject, error) {
|
|
log.Trace("GetDiverging[%d]: compare commits", pr.ID)
|
|
if err := pr.LoadBaseRepo(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := pr.LoadHeadRepo(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tmpRepo, err := createTemporaryRepo(ctx, pr)
|
|
if err != nil {
|
|
if !models.IsErrBranchDoesNotExist(err) {
|
|
log.Error("CreateTemporaryRepo: %v", err)
|
|
}
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
if err := repo_module.RemoveTemporaryPath(tmpRepo); err != nil {
|
|
log.Error("Merge: RemoveTemporaryPath: %s", err)
|
|
}
|
|
}()
|
|
|
|
diff, err := git.GetDivergingCommits(ctx, tmpRepo, "base", "tracking")
|
|
return &diff, err
|
|
}
|