2019-06-22 13:35:34 -04:00
// Copyright 2019 The Gitea Authors.
// All rights reserved.
2022-11-27 13:20:29 -05:00
// SPDX-License-Identifier: MIT
2019-06-22 13:35:34 -04:00
package pull
import (
2022-01-19 18:26:57 -05:00
"context"
2019-06-22 13:35:34 -04:00
"fmt"
2024-07-31 07:55:14 -04:00
"net/url"
2019-06-22 13:35:34 -04:00
"os"
"path/filepath"
2019-10-31 20:30:02 -04:00
"regexp"
2022-05-08 08:32:45 -04:00
"strconv"
2019-06-22 13:35:34 -04:00
"strings"
"code.gitea.io/gitea/models"
2022-05-03 15:46:28 -04:00
"code.gitea.io/gitea/models/db"
2022-06-12 11:51:54 -04:00
git_model "code.gitea.io/gitea/models/git"
2022-06-13 05:37:59 -04:00
issues_model "code.gitea.io/gitea/models/issues"
2022-05-11 06:09:36 -04:00
access_model "code.gitea.io/gitea/models/perm/access"
2021-12-09 20:27:50 -05:00
repo_model "code.gitea.io/gitea/models/repo"
2021-11-09 14:57:58 -05:00
"code.gitea.io/gitea/models/unit"
2021-11-24 04:49:20 -05:00
user_model "code.gitea.io/gitea/models/user"
2019-06-22 13:35:34 -04:00
"code.gitea.io/gitea/modules/cache"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/log"
2019-11-18 08:13:07 -05:00
"code.gitea.io/gitea/modules/references"
2022-05-08 12:46:32 -04:00
repo_module "code.gitea.io/gitea/modules/repository"
2019-06-22 13:35:34 -04:00
"code.gitea.io/gitea/modules/setting"
2019-08-15 10:46:21 -04:00
"code.gitea.io/gitea/modules/timeutil"
2019-11-18 08:13:07 -05:00
issue_service "code.gitea.io/gitea/services/issue"
2023-09-05 14:37:47 -04:00
notify_service "code.gitea.io/gitea/services/notify"
2019-06-22 13:35:34 -04:00
)
2023-05-21 21:01:46 -04:00
// getMergeMessage composes the message used when merging a pull request.
func getMergeMessage ( ctx context . Context , baseGitRepo * git . Repository , pr * issues_model . PullRequest , mergeStyle repo_model . MergeStyle , extraVars map [ string ] string ) ( message , body string , err error ) {
2022-11-19 03:12:33 -05:00
if err := pr . LoadBaseRepo ( ctx ) ; err != nil {
2022-12-29 07:40:20 -05:00
return "" , "" , err
2022-05-08 08:32:45 -04:00
}
2023-03-07 15:07:35 -05:00
if err := pr . LoadHeadRepo ( ctx ) ; err != nil {
return "" , "" , err
2022-05-08 08:32:45 -04:00
}
2022-11-19 03:12:33 -05:00
if err := pr . LoadIssue ( ctx ) ; err != nil {
2022-12-29 07:40:20 -05:00
return "" , "" , err
2022-05-08 08:32:45 -04:00
}
2023-10-17 11:07:23 -04:00
if err := pr . Issue . LoadPoster ( ctx ) ; err != nil {
return "" , "" , err
}
2024-06-06 04:35:04 -04:00
if err := pr . Issue . LoadRepo ( ctx ) ; err != nil {
return "" , "" , err
}
2022-05-08 08:32:45 -04:00
2022-12-09 21:46:31 -05:00
isExternalTracker := pr . BaseRepo . UnitEnabled ( ctx , unit . TypeExternalTracker )
2022-05-08 08:32:45 -04:00
issueReference := "#"
if isExternalTracker {
issueReference = "!"
}
2024-07-31 07:55:14 -04:00
issueURL , err := url . JoinPath ( setting . AppURL , pr . Issue . Link ( ) )
if err != nil {
return "" , "" , err
}
reviewedOn := fmt . Sprintf ( "Reviewed-on: %s" , issueURL )
2024-06-06 04:35:04 -04:00
reviewedBy := pr . GetApprovers ( ctx )
2022-05-08 08:32:45 -04:00
if mergeStyle != "" {
commit , err := baseGitRepo . GetBranchCommit ( pr . BaseRepo . DefaultBranch )
if err != nil {
2022-12-29 07:40:20 -05:00
return "" , "" , err
2022-05-08 08:32:45 -04:00
}
2023-08-25 16:49:17 -04:00
templateFilepathForgejo := fmt . Sprintf ( ".forgejo/default_merge_message/%s_TEMPLATE.md" , strings . ToUpper ( string ( mergeStyle ) ) )
templateFilepathGitea := fmt . Sprintf ( ".gitea/default_merge_message/%s_TEMPLATE.md" , strings . ToUpper ( string ( mergeStyle ) ) )
templateContent , err := commit . GetFileContent ( templateFilepathForgejo , setting . Repository . PullRequest . DefaultMergeMessageSize )
if _ , ok := err . ( git . ErrNotExist ) ; ok {
templateContent , err = commit . GetFileContent ( templateFilepathGitea , setting . Repository . PullRequest . DefaultMergeMessageSize )
}
2022-05-08 08:32:45 -04:00
if err != nil {
if ! git . IsErrNotExist ( err ) {
2022-12-29 07:40:20 -05:00
return "" , "" , err
2022-05-08 08:32:45 -04:00
}
} else {
vars := map [ string ] string {
"BaseRepoOwnerName" : pr . BaseRepo . OwnerName ,
"BaseRepoName" : pr . BaseRepo . Name ,
"BaseBranch" : pr . BaseBranch ,
"HeadRepoOwnerName" : "" ,
"HeadRepoName" : "" ,
"HeadBranch" : pr . HeadBranch ,
"PullRequestTitle" : pr . Issue . Title ,
"PullRequestDescription" : pr . Issue . Content ,
"PullRequestPosterName" : pr . Issue . Poster . Name ,
"PullRequestIndex" : strconv . FormatInt ( pr . Index , 10 ) ,
"PullRequestReference" : fmt . Sprintf ( "%s%d" , issueReference , pr . Index ) ,
2024-06-06 04:35:04 -04:00
"ReviewedOn" : reviewedOn ,
"ReviewedBy" : reviewedBy ,
2022-05-08 08:32:45 -04:00
}
if pr . HeadRepo != nil {
vars [ "HeadRepoOwnerName" ] = pr . HeadRepo . OwnerName
vars [ "HeadRepoName" ] = pr . HeadRepo . Name
}
2023-05-21 21:01:46 -04:00
for extraKey , extraValue := range extraVars {
vars [ extraKey ] = extraValue
}
2022-11-19 03:12:33 -05:00
refs , err := pr . ResolveCrossReferences ( ctx )
2022-05-08 08:32:45 -04:00
if err == nil {
closeIssueIndexes := make ( [ ] string , 0 , len ( refs ) )
closeWord := "close"
if len ( setting . Repository . PullRequest . CloseKeywords ) > 0 {
closeWord = setting . Repository . PullRequest . CloseKeywords [ 0 ]
}
for _ , ref := range refs {
if ref . RefAction == references . XRefActionCloses {
2023-02-08 21:47:52 -05:00
if err := ref . LoadIssue ( ctx ) ; err != nil {
return "" , "" , err
}
2022-05-08 08:32:45 -04:00
closeIssueIndexes = append ( closeIssueIndexes , fmt . Sprintf ( "%s %s%d" , closeWord , issueReference , ref . Issue . Index ) )
}
}
if len ( closeIssueIndexes ) > 0 {
vars [ "ClosingIssues" ] = strings . Join ( closeIssueIndexes , ", " )
} else {
vars [ "ClosingIssues" ] = ""
}
}
2022-12-29 07:40:20 -05:00
message , body = expandDefaultMergeMessage ( templateContent , vars )
return message , body , nil
2022-05-08 08:32:45 -04:00
}
}
2023-07-10 04:12:50 -04:00
if mergeStyle == repo_model . MergeStyleRebase {
// for fast-forward rebase, do not amend the last commit if there is no template
return "" , "" , nil
}
2024-06-06 04:35:04 -04:00
body = fmt . Sprintf ( "%s\n%s" , reviewedOn , reviewedBy )
2022-05-08 08:32:45 -04:00
// Squash merge has a different from other styles.
if mergeStyle == repo_model . MergeStyleSquash {
2024-06-06 04:35:04 -04:00
return fmt . Sprintf ( "%s (%s%d)" , pr . Issue . Title , issueReference , pr . Issue . Index ) , body , nil
2022-05-08 08:32:45 -04:00
}
if pr . BaseRepoID == pr . HeadRepoID {
2024-06-06 04:35:04 -04:00
return fmt . Sprintf ( "Merge pull request '%s' (%s%d) from %s into %s" , pr . Issue . Title , issueReference , pr . Issue . Index , pr . HeadBranch , pr . BaseBranch ) , body , nil
2022-05-08 08:32:45 -04:00
}
if pr . HeadRepo == nil {
2024-06-06 04:35:04 -04:00
return fmt . Sprintf ( "Merge pull request '%s' (%s%d) from <deleted>:%s into %s" , pr . Issue . Title , issueReference , pr . Issue . Index , pr . HeadBranch , pr . BaseBranch ) , body , nil
2022-05-08 08:32:45 -04:00
}
2024-06-06 04:35:04 -04:00
return fmt . Sprintf ( "Merge pull request '%s' (%s%d) from %s:%s into %s" , pr . Issue . Title , issueReference , pr . Issue . Index , pr . HeadRepo . FullName ( ) , pr . HeadBranch , pr . BaseBranch ) , body , nil
2022-12-29 07:40:20 -05:00
}
func expandDefaultMergeMessage ( template string , vars map [ string ] string ) ( message , body string ) {
message = strings . TrimSpace ( template )
if splits := strings . SplitN ( message , "\n" , 2 ) ; len ( splits ) == 2 {
message = splits [ 0 ]
body = strings . TrimSpace ( splits [ 1 ] )
}
mapping := func ( s string ) string { return vars [ s ] }
return os . Expand ( message , mapping ) , os . Expand ( body , mapping )
2022-05-08 08:32:45 -04:00
}
2023-05-21 21:01:46 -04:00
// GetDefaultMergeMessage returns default message used when merging pull request
func GetDefaultMergeMessage ( ctx context . Context , baseGitRepo * git . Repository , pr * issues_model . PullRequest , mergeStyle repo_model . MergeStyle ) ( message , body string , err error ) {
return getMergeMessage ( ctx , baseGitRepo , pr , mergeStyle , nil )
}
2019-06-22 13:35:34 -04:00
// Merge merges pull request to base repository.
2020-01-11 02:29:34 -05:00
// Caller should check PR is ready to be merged (review and status checks)
2022-11-03 11:49:00 -04:00
func Merge ( ctx context . Context , pr * issues_model . PullRequest , doer * user_model . User , baseGitRepo * git . Repository , mergeStyle repo_model . MergeStyle , expectedHeadCommitID , message string , wasAutoMerged bool ) error {
2023-03-07 15:07:35 -05:00
if err := pr . LoadBaseRepo ( ctx ) ; err != nil {
log . Error ( "Unable to load base repo: %v" , err )
return fmt . Errorf ( "unable to load base repo: %w" , err )
} else if err := pr . LoadHeadRepo ( ctx ) ; err != nil {
log . Error ( "Unable to load head repo: %v" , err )
return fmt . Errorf ( "unable to load head repo: %w" , err )
2019-06-22 13:35:34 -04:00
}
2022-05-04 12:06:23 -04:00
pullWorkingPool . CheckIn ( fmt . Sprint ( pr . ID ) )
defer pullWorkingPool . CheckOut ( fmt . Sprint ( pr . ID ) )
2022-12-09 21:46:31 -05:00
prUnit , err := pr . BaseRepo . GetUnit ( ctx , unit . TypePullRequests )
2019-06-22 13:35:34 -04:00
if err != nil {
2021-11-09 14:57:58 -05:00
log . Error ( "pr.BaseRepo.GetUnit(unit.TypePullRequests): %v" , err )
2019-06-22 13:35:34 -04:00
return err
}
prConfig := prUnit . PullRequestsConfig ( )
// Check if merge style is correct and allowed
if ! prConfig . IsMergeStyleAllowed ( mergeStyle ) {
return models . ErrInvalidMergeStyle { ID : pr . BaseRepo . ID , Style : mergeStyle }
}
defer func ( ) {
2024-03-31 09:27:59 -04:00
AddTestPullRequestTask ( ctx , doer , pr . BaseRepo . ID , pr . BaseBranch , false , "" , "" , 0 )
2019-06-22 13:35:34 -04:00
} ( )
2024-05-07 03:36:48 -04:00
_ , err = doMergeAndPush ( ctx , pr , doer , mergeStyle , expectedHeadCommitID , message , repo_module . PushTriggerPRMergeToBase )
2020-01-17 01:03:40 -05:00
if err != nil {
2020-02-09 18:09:31 -05:00
return err
2020-01-17 01:03:40 -05:00
}
2024-05-07 03:36:48 -04:00
// reload pull request because it has been updated by post receive hook
pr , err = issues_model . GetPullRequestByID ( ctx , pr . ID )
if err != nil {
return err
2020-01-17 01:03:40 -05:00
}
2023-07-22 10:14:27 -04:00
if err := pr . LoadIssue ( ctx ) ; err != nil {
2023-03-07 15:07:35 -05:00
log . Error ( "LoadIssue %-v: %v" , pr , err )
2020-02-09 18:09:31 -05:00
}
2023-07-22 10:14:27 -04:00
if err := pr . Issue . LoadRepo ( ctx ) ; err != nil {
2023-03-07 15:07:35 -05:00
log . Error ( "pr.Issue.LoadRepo %-v: %v" , pr , err )
2020-02-09 18:09:31 -05:00
}
2023-07-22 10:14:27 -04:00
if err := pr . Issue . Repo . LoadOwner ( ctx ) ; err != nil {
2023-03-07 15:07:35 -05:00
log . Error ( "LoadOwner for %-v: %v" , pr , err )
2020-02-09 18:09:31 -05:00
}
2022-11-03 11:49:00 -04:00
if wasAutoMerged {
2023-09-05 14:37:47 -04:00
notify_service . AutoMergePullRequest ( ctx , doer , pr )
2022-11-03 11:49:00 -04:00
} else {
2023-09-05 14:37:47 -04:00
notify_service . MergePullRequest ( ctx , doer , pr )
2022-11-03 11:49:00 -04:00
}
2020-01-17 01:03:40 -05:00
// Reset cached commit count
cache . Remove ( pr . Issue . Repo . GetCommitsCountCacheKey ( pr . BaseBranch , true ) )
// Resolve cross references
2023-07-22 10:14:27 -04:00
refs , err := pr . ResolveCrossReferences ( ctx )
2020-01-17 01:03:40 -05:00
if err != nil {
log . Error ( "ResolveCrossReferences: %v" , err )
return nil
}
for _ , ref := range refs {
2023-07-22 10:14:27 -04:00
if err = ref . LoadIssue ( ctx ) ; err != nil {
2020-01-17 01:03:40 -05:00
return err
}
2023-07-22 10:14:27 -04:00
if err = ref . Issue . LoadRepo ( ctx ) ; err != nil {
2020-01-17 01:03:40 -05:00
return err
}
2024-04-22 07:48:42 -04:00
isClosed := ref . RefAction == references . XRefActionCloses
if isClosed != ref . Issue . IsClosed {
if err = issue_service . ChangeStatus ( ctx , ref . Issue , doer , pr . MergedCommitID , isClosed ) ; err != nil {
2022-01-18 18:26:42 -05:00
// Allow ErrDependenciesLeft
2022-06-13 05:37:59 -04:00
if ! issues_model . IsErrDependenciesLeft ( err ) {
2022-01-18 18:26:42 -05:00
return err
}
2020-01-17 01:03:40 -05:00
}
}
}
return nil
}
2023-03-07 15:07:35 -05:00
// doMergeAndPush performs the merge operation without changing any pull information in database and pushes it up to the base repository
2024-06-11 14:47:45 -04:00
func doMergeAndPush ( ctx context . Context , pr * issues_model . PullRequest , doer * user_model . User , mergeStyle repo_model . MergeStyle , expectedHeadCommitID , message string , pushTrigger repo_module . PushTrigger ) ( string , error ) { //nolint:unparam
2019-06-22 13:35:34 -04:00
// Clone base repo.
2023-03-07 15:07:35 -05:00
mergeCtx , cancel , err := createTemporaryRepoForMerge ( ctx , pr , doer , expectedHeadCommitID )
2019-06-22 13:35:34 -04:00
if err != nil {
2020-02-09 18:09:31 -05:00
return "" , err
2019-06-22 13:35:34 -04:00
}
2023-03-07 15:07:35 -05:00
defer cancel ( )
2019-10-16 09:42:42 -04:00
2019-06-22 13:35:34 -04:00
// Merge commits.
switch mergeStyle {
2021-12-09 20:27:50 -05:00
case repo_model . MergeStyleMerge :
2023-03-07 15:07:35 -05:00
if err := doMergeStyleMerge ( mergeCtx , message ) ; err != nil {
2020-02-09 18:09:31 -05:00
return "" , err
2019-06-22 13:35:34 -04:00
}
2023-03-07 15:07:35 -05:00
case repo_model . MergeStyleRebase , repo_model . MergeStyleRebaseMerge :
if err := doMergeStyleRebase ( mergeCtx , mergeStyle , message ) ; err != nil {
2020-02-09 18:09:31 -05:00
return "" , err
2019-06-22 13:35:34 -04:00
}
2021-12-09 20:27:50 -05:00
case repo_model . MergeStyleSquash :
2023-03-07 15:07:35 -05:00
if err := doMergeStyleSquash ( mergeCtx , message ) ; err != nil {
2020-02-09 18:09:31 -05:00
return "" , err
2019-06-22 13:35:34 -04:00
}
2024-02-12 17:37:23 -05:00
case repo_model . MergeStyleFastForwardOnly :
if err := doMergeStyleFastForwardOnly ( mergeCtx ) ; err != nil {
return "" , err
}
2019-06-22 13:35:34 -04:00
default :
2020-02-09 18:09:31 -05:00
return "" , models . ErrInvalidMergeStyle { ID : pr . BaseRepo . ID , Style : mergeStyle }
2019-06-22 13:35:34 -04:00
}
// OK we should cache our current head and origin/headbranch
2023-03-07 15:07:35 -05:00
mergeHeadSHA , err := git . GetFullCommitID ( ctx , mergeCtx . tmpBasePath , "HEAD" )
2019-06-22 13:35:34 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return "" , fmt . Errorf ( "Failed to get full commit id for HEAD: %w" , err )
2019-06-22 13:35:34 -04:00
}
2023-03-07 15:07:35 -05:00
mergeBaseSHA , err := git . GetFullCommitID ( ctx , mergeCtx . tmpBasePath , "original_" + baseBranch )
2019-06-22 13:35:34 -04:00
if err != nil {
2022-10-24 15:29:17 -04:00
return "" , fmt . Errorf ( "Failed to get full commit id for origin/%s: %w" , pr . BaseBranch , err )
2020-02-09 18:09:31 -05:00
}
2023-03-07 15:07:35 -05:00
mergeCommitID , err := git . GetFullCommitID ( ctx , mergeCtx . tmpBasePath , baseBranch )
2020-02-09 18:09:31 -05:00
if err != nil {
2022-10-24 15:29:17 -04:00
return "" , fmt . Errorf ( "Failed to get full commit id for the new merge: %w" , err )
2019-06-22 13:35:34 -04:00
}
// Now it's questionable about where this should go - either after or before the push
// I think in the interests of data safety - failures to push to the lfs should prevent
// the merge as you can always remerge.
if setting . LFS . StartServer {
2023-03-07 15:07:35 -05:00
if err := LFSPush ( ctx , mergeCtx . tmpBasePath , mergeHeadSHA , mergeBaseSHA , pr ) ; err != nil {
2020-02-09 18:09:31 -05:00
return "" , err
2019-06-22 13:35:34 -04:00
}
}
2021-11-24 04:49:20 -05:00
var headUser * user_model . User
2023-02-18 07:11:03 -05:00
err = pr . HeadRepo . LoadOwner ( ctx )
2019-06-30 21:18:13 -04:00
if err != nil {
2021-11-24 04:49:20 -05:00
if ! user_model . IsErrUserNotExist ( err ) {
2023-03-07 15:07:35 -05:00
log . Error ( "Can't find user: %d for head repository in %-v: %v" , pr . HeadRepo . OwnerID , pr , err )
2020-02-09 18:09:31 -05:00
return "" , err
2019-06-30 21:18:13 -04:00
}
2023-03-07 15:07:35 -05:00
log . Warn ( "Can't find user: %d for head repository in %-v - defaulting to doer: %s - %v" , pr . HeadRepo . OwnerID , pr , doer . Name , err )
2019-06-30 21:18:13 -04:00
headUser = doer
2019-10-18 07:13:31 -04:00
} else {
headUser = pr . HeadRepo . Owner
2019-06-30 21:18:13 -04:00
}
2023-03-07 15:07:35 -05:00
mergeCtx . env = repo_module . FullPushingEnvironment (
headUser ,
doer ,
pr . BaseRepo ,
pr . BaseRepo . Name ,
pr . ID ,
)
2024-05-07 03:36:48 -04:00
mergeCtx . env = append ( mergeCtx . env , repo_module . EnvPushTrigger + "=" + string ( pushTrigger ) )
2023-03-07 15:07:35 -05:00
pushCmd := git . NewCommand ( ctx , "push" , "origin" ) . AddDynamicArguments ( baseBranch + ":" + git . BranchPrefix + pr . BaseBranch )
2021-08-31 10:03:45 -04:00
2019-06-22 13:35:34 -04:00
// Push back to upstream.
2024-05-07 03:36:48 -04:00
// This cause an api call to "/api/internal/hook/post-receive/...",
// If it's merge, all db transaction and operations should be there but not here to prevent deadlock.
2023-03-07 15:07:35 -05:00
if err := pushCmd . Run ( mergeCtx . RunOpts ( ) ) ; err != nil {
if strings . Contains ( mergeCtx . errbuf . String ( ) , "non-fast-forward" ) {
2020-03-28 00:13:18 -04:00
return "" , & git . ErrPushOutOfDate {
2023-03-07 15:07:35 -05:00
StdOut : mergeCtx . outbuf . String ( ) ,
StdErr : mergeCtx . errbuf . String ( ) ,
2019-11-10 03:42:51 -05:00
Err : err ,
}
2023-03-07 15:07:35 -05:00
} else if strings . Contains ( mergeCtx . errbuf . String ( ) , "! [remote rejected]" ) {
2020-03-28 00:13:18 -04:00
err := & git . ErrPushRejected {
2023-03-07 15:07:35 -05:00
StdOut : mergeCtx . outbuf . String ( ) ,
StdErr : mergeCtx . errbuf . String ( ) ,
2020-02-22 08:08:48 -05:00
Err : err ,
}
err . GenerateMessage ( )
return "" , err
2019-11-10 03:42:51 -05:00
}
2023-03-07 15:07:35 -05:00
return "" , fmt . Errorf ( "git push: %s" , mergeCtx . errbuf . String ( ) )
2019-06-22 13:35:34 -04:00
}
2023-03-07 15:07:35 -05:00
mergeCtx . outbuf . Reset ( )
mergeCtx . errbuf . Reset ( )
2019-06-22 13:35:34 -04:00
2020-02-09 18:09:31 -05:00
return mergeCommitID , nil
2019-06-22 13:35:34 -04:00
}
2023-03-07 15:07:35 -05:00
func commitAndSignNoAuthor ( ctx * mergeContext , message string ) error {
2023-03-09 10:48:52 -05:00
cmdCommit := git . NewCommand ( ctx , "commit" ) . AddOptionFormat ( "--message=%s" , message )
if ctx . signKeyID == "" {
cmdCommit . AddArguments ( "--no-gpg-sign" )
} else {
cmdCommit . AddOptionFormat ( "-S%s" , ctx . signKeyID )
}
if err := cmdCommit . Run ( ctx . RunOpts ( ) ) ; err != nil {
2023-03-07 15:07:35 -05:00
log . Error ( "git commit %-v: %v\n%s\n%s" , ctx . pr , err , ctx . outbuf . String ( ) , ctx . errbuf . String ( ) )
return fmt . Errorf ( "git commit %v: %w\n%s\n%s" , ctx . pr , err , ctx . outbuf . String ( ) , ctx . errbuf . String ( ) )
2019-11-10 03:42:51 -05:00
}
return nil
}
2023-03-07 15:07:35 -05:00
func runMergeCommand ( ctx * mergeContext , mergeStyle repo_model . MergeStyle , cmd * git . Command ) error {
if err := cmd . Run ( ctx . RunOpts ( ) ) ; err != nil {
2019-11-10 03:42:51 -05:00
// Merge will leave a MERGE_HEAD file in the .git folder if there is a conflict
2023-03-07 15:07:35 -05:00
if _ , statErr := os . Stat ( filepath . Join ( ctx . tmpBasePath , ".git" , "MERGE_HEAD" ) ) ; statErr == nil {
2019-11-10 03:42:51 -05:00
// We have a merge conflict error
2023-03-07 15:07:35 -05:00
log . Debug ( "MergeConflict %-v: %v\n%s\n%s" , ctx . pr , err , ctx . outbuf . String ( ) , ctx . errbuf . String ( ) )
2019-11-10 03:42:51 -05:00
return models . ErrMergeConflicts {
Style : mergeStyle ,
2023-03-07 15:07:35 -05:00
StdOut : ctx . outbuf . String ( ) ,
StdErr : ctx . errbuf . String ( ) ,
2019-11-10 03:42:51 -05:00
Err : err ,
}
2023-03-07 15:07:35 -05:00
} else if strings . Contains ( ctx . errbuf . String ( ) , "refusing to merge unrelated histories" ) {
log . Debug ( "MergeUnrelatedHistories %-v: %v\n%s\n%s" , ctx . pr , err , ctx . outbuf . String ( ) , ctx . errbuf . String ( ) )
2019-11-10 03:42:51 -05:00
return models . ErrMergeUnrelatedHistories {
Style : mergeStyle ,
2023-03-07 15:07:35 -05:00
StdOut : ctx . outbuf . String ( ) ,
StdErr : ctx . errbuf . String ( ) ,
2019-11-10 03:42:51 -05:00
Err : err ,
}
2024-02-12 17:37:23 -05:00
} else if mergeStyle == repo_model . MergeStyleFastForwardOnly && strings . Contains ( ctx . errbuf . String ( ) , "Not possible to fast-forward, aborting" ) {
log . Debug ( "MergeDivergingFastForwardOnly %-v: %v\n%s\n%s" , ctx . pr , err , ctx . outbuf . String ( ) , ctx . errbuf . String ( ) )
return models . ErrMergeDivergingFastForwardOnly {
StdOut : ctx . outbuf . String ( ) ,
StdErr : ctx . errbuf . String ( ) ,
Err : err ,
}
2019-11-10 03:42:51 -05:00
}
2023-03-07 15:07:35 -05:00
log . Error ( "git merge %-v: %v\n%s\n%s" , ctx . pr , err , ctx . outbuf . String ( ) , ctx . errbuf . String ( ) )
return fmt . Errorf ( "git merge %v: %w\n%s\n%s" , ctx . pr , err , ctx . outbuf . String ( ) , ctx . errbuf . String ( ) )
2019-11-10 03:42:51 -05:00
}
2023-03-07 15:07:35 -05:00
ctx . outbuf . Reset ( )
ctx . errbuf . Reset ( )
2019-11-10 03:42:51 -05:00
return nil
}
2019-10-31 20:30:02 -04:00
var escapedSymbols = regexp . MustCompile ( ` ([*[?! \\]) ` )
2020-01-11 02:29:34 -05:00
// IsUserAllowedToMerge check if user is allowed to merge PR with given permissions and branch protections
2022-06-13 05:37:59 -04:00
func IsUserAllowedToMerge ( ctx context . Context , pr * issues_model . PullRequest , p access_model . Permission , user * user_model . User ) ( bool , error ) {
2020-04-14 12:29:31 -04:00
if user == nil {
return false , nil
}
2020-01-11 02:29:34 -05:00
2023-01-16 03:00:22 -05:00
pb , err := git_model . GetFirstMatchProtectedBranchRule ( ctx , pr . BaseRepoID , pr . BaseBranch )
2020-01-11 02:29:34 -05:00
if err != nil {
return false , err
}
2023-01-16 03:00:22 -05:00
if ( p . CanWrite ( unit . TypeCode ) && pb == nil ) || ( pb != nil && git_model . IsUserMergeWhitelisted ( ctx , pb , user . ID , p ) ) {
2020-01-11 02:29:34 -05:00
return true , nil
}
return false , nil
}
2024-03-28 16:41:52 -04:00
// CheckPullBranchProtections checks whether the PR is ready to be merged (reviews and status checks).
// Returns the protected branch rule when `ErrDisallowedToMerge` is returned as error.
func CheckPullBranchProtections ( ctx context . Context , pr * issues_model . PullRequest , skipProtectedFilesCheck bool ) ( protectedBranchRule * git_model . ProtectedBranch , err error ) {
2022-11-19 03:12:33 -05:00
if err = pr . LoadBaseRepo ( ctx ) ; err != nil {
2024-03-28 16:41:52 -04:00
return nil , fmt . Errorf ( "LoadBaseRepo: %w" , err )
2020-03-02 17:31:55 -05:00
}
2023-01-16 03:00:22 -05:00
pb , err := git_model . GetFirstMatchProtectedBranchRule ( ctx , pr . BaseRepoID , pr . BaseBranch )
if err != nil {
2024-03-28 16:41:52 -04:00
return nil , fmt . Errorf ( "LoadProtectedBranch: %v" , err )
2020-01-11 02:29:34 -05:00
}
2023-01-16 03:00:22 -05:00
if pb == nil {
2024-03-28 16:41:52 -04:00
return nil , nil
2020-01-11 02:29:34 -05:00
}
2022-01-19 18:26:57 -05:00
isPass , err := IsPullCommitStatusPass ( ctx , pr )
2020-01-11 02:29:34 -05:00
if err != nil {
2024-03-28 16:41:52 -04:00
return nil , err
2020-01-11 02:29:34 -05:00
}
if ! isPass {
2024-03-28 16:41:52 -04:00
return pb , models . ErrDisallowedToMerge {
2020-01-11 02:29:34 -05:00
Reason : "Not all required status checks successful" ,
}
}
2023-01-16 03:00:22 -05:00
if ! issues_model . HasEnoughApprovals ( ctx , pb , pr ) {
2024-03-28 16:41:52 -04:00
return pb , models . ErrDisallowedToMerge {
2020-01-11 02:29:34 -05:00
Reason : "Does not have enough approvals" ,
}
}
2023-01-16 03:00:22 -05:00
if issues_model . MergeBlockedByRejectedReview ( ctx , pb , pr ) {
2024-03-28 16:41:52 -04:00
return pb , models . ErrDisallowedToMerge {
2020-01-11 02:29:34 -05:00
Reason : "There are requested changes" ,
}
}
2023-01-16 03:00:22 -05:00
if issues_model . MergeBlockedByOfficialReviewRequests ( ctx , pb , pr ) {
2024-03-28 16:41:52 -04:00
return pb , models . ErrDisallowedToMerge {
2020-11-28 14:30:46 -05:00
Reason : "There are official review requests" ,
}
}
2020-01-11 02:29:34 -05:00
2023-01-16 03:00:22 -05:00
if issues_model . MergeBlockedByOutdatedBranch ( pb , pr ) {
2024-03-28 16:41:52 -04:00
return pb , models . ErrDisallowedToMerge {
2020-04-16 21:00:36 -04:00
Reason : "The head branch is behind the base branch" ,
}
}
2020-10-13 14:50:57 -04:00
if skipProtectedFilesCheck {
2024-03-28 16:41:52 -04:00
return nil , nil
2020-10-13 14:50:57 -04:00
}
2023-01-16 03:00:22 -05:00
if pb . MergeBlockedByProtectedFiles ( pr . ChangedProtectedFiles ) {
2024-03-28 16:41:52 -04:00
return pb , models . ErrDisallowedToMerge {
2020-10-13 14:50:57 -04:00
Reason : "Changed protected files" ,
}
}
2024-03-28 16:41:52 -04:00
return nil , nil
2020-01-11 02:29:34 -05:00
}
2021-03-03 22:41:23 -05:00
// MergedManually mark pr as merged manually
2023-10-14 04:37:24 -04:00
func MergedManually ( ctx context . Context , pr * issues_model . PullRequest , doer * user_model . User , baseGitRepo * git . Repository , commitID string ) error {
2022-05-04 12:06:23 -04:00
pullWorkingPool . CheckIn ( fmt . Sprint ( pr . ID ) )
defer pullWorkingPool . CheckOut ( fmt . Sprint ( pr . ID ) )
2023-10-14 04:37:24 -04:00
if err := db . WithTx ( ctx , func ( ctx context . Context ) error {
2023-01-16 03:00:22 -05:00
if err := pr . LoadBaseRepo ( ctx ) ; err != nil {
return err
}
2022-12-09 21:46:31 -05:00
prUnit , err := pr . BaseRepo . GetUnit ( ctx , unit . TypePullRequests )
2022-05-03 15:46:28 -04:00
if err != nil {
return err
}
prConfig := prUnit . PullRequestsConfig ( )
2021-03-03 22:41:23 -05:00
2022-05-03 15:46:28 -04:00
// Check if merge style is correct and allowed
if ! prConfig . IsMergeStyleAllowed ( repo_model . MergeStyleManuallyMerged ) {
return models . ErrInvalidMergeStyle { ID : pr . BaseRepo . ID , Style : repo_model . MergeStyleManuallyMerged }
}
2021-03-03 22:41:23 -05:00
2024-02-24 01:55:19 -05:00
objectFormat := git . ObjectFormatFromName ( pr . BaseRepo . ObjectFormatName )
2023-12-13 16:02:00 -05:00
if len ( commitID ) != objectFormat . FullLength ( ) {
2021-03-03 22:41:23 -05:00
return fmt . Errorf ( "Wrong commit ID" )
}
2022-05-03 15:46:28 -04:00
commit , err := baseGitRepo . GetCommit ( commitID )
if err != nil {
if git . IsErrNotExist ( err ) {
return fmt . Errorf ( "Wrong commit ID" )
}
return err
}
commitID = commit . ID . String ( )
2021-03-03 22:41:23 -05:00
2022-05-03 15:46:28 -04:00
ok , err := baseGitRepo . IsCommitInBranch ( commitID , pr . BaseBranch )
if err != nil {
return err
}
if ! ok {
return fmt . Errorf ( "Wrong commit ID" )
}
2021-03-03 22:41:23 -05:00
2022-05-03 15:46:28 -04:00
pr . MergedCommitID = commitID
pr . MergedUnix = timeutil . TimeStamp ( commit . Author . When . Unix ( ) )
2022-06-13 05:37:59 -04:00
pr . Status = issues_model . PullRequestStatusManuallyMerged
2022-05-03 15:46:28 -04:00
pr . Merger = doer
pr . MergerID = doer . ID
2022-06-20 06:02:49 -04:00
var merged bool
2022-05-03 15:46:28 -04:00
if merged , err = pr . SetMerged ( ctx ) ; err != nil {
return err
} else if ! merged {
return fmt . Errorf ( "SetMerged failed" )
}
return nil
} ) ; err != nil {
return err
2021-03-03 22:41:23 -05:00
}
2023-09-05 14:37:47 -04:00
notify_service . MergePullRequest ( baseGitRepo . Ctx , doer , pr )
2022-05-03 15:46:28 -04:00
log . Info ( "manuallyMerged[%d]: Marked as manually merged into %s/%s by commit id: %s" , pr . ID , pr . BaseRepo . Name , pr . BaseBranch , commitID )
2021-03-03 22:41:23 -05:00
return nil
}