2019-09-26 20:22:36 -04:00
// Copyright 2019 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package pull
import (
2020-01-08 20:47:45 -05:00
"bufio"
"bytes"
2019-12-15 04:51:28 -05:00
"context"
2019-09-26 20:22:36 -04:00
"fmt"
2022-01-19 18:26:57 -05:00
"io"
2021-06-25 13:01:43 -04:00
"regexp"
2020-01-08 20:47:45 -05:00
"strings"
"time"
2019-09-26 20:22:36 -04:00
"code.gitea.io/gitea/models"
2021-09-19 07:49:59 -04:00
"code.gitea.io/gitea/models/db"
2021-12-09 20:27:50 -05:00
repo_model "code.gitea.io/gitea/models/repo"
2021-11-24 04:49:20 -05:00
user_model "code.gitea.io/gitea/models/user"
2019-10-14 23:28:40 -04:00
"code.gitea.io/gitea/modules/git"
2019-12-15 04:51:28 -05:00
"code.gitea.io/gitea/modules/graceful"
2021-07-24 12:03:58 -04:00
"code.gitea.io/gitea/modules/json"
2019-09-26 20:22:36 -04:00
"code.gitea.io/gitea/modules/log"
2019-11-03 15:59:09 -05:00
"code.gitea.io/gitea/modules/notification"
2022-01-19 18:26:57 -05:00
"code.gitea.io/gitea/modules/process"
2020-04-10 07:26:37 -04:00
"code.gitea.io/gitea/modules/setting"
2019-10-28 12:45:43 -04:00
issue_service "code.gitea.io/gitea/services/issue"
2019-09-26 20:22:36 -04:00
)
// NewPullRequest creates new pull request with labels for repository.
2022-01-19 18:26:57 -05:00
func NewPullRequest ( ctx context . Context , repo * repo_model . Repository , pull * models . Issue , labelIDs [ ] int64 , uuids [ ] string , pr * models . PullRequest , assigneeIDs [ ] int64 ) error {
2019-12-13 17:21:06 -05:00
if err := TestPatch ( pr ) ; err != nil {
return err
}
2022-01-19 18:26:57 -05:00
divergence , err := GetDiverging ( ctx , pr )
2020-04-14 09:53:34 -04:00
if err != nil {
return err
}
pr . CommitsAhead = divergence . Ahead
pr . CommitsBehind = divergence . Behind
2022-01-19 18:26:57 -05:00
if err := models . NewPullRequest ( ctx , repo , pull , labelIDs , uuids , pr ) ; err != nil {
2019-09-26 20:22:36 -04:00
return err
}
2019-10-28 12:45:43 -04:00
for _ , assigneeID := range assigneeIDs {
if err := issue_service . AddAssigneeIfNotAssigned ( pull , pull . Poster , assigneeID ) ; err != nil {
return err
}
}
2019-09-26 20:22:36 -04:00
pr . Issue = pull
pull . PullRequest = pr
2019-11-03 15:59:09 -05:00
2022-01-19 18:26:57 -05:00
// Now - even if the request context has been cancelled as the PR has been created
// in the db and there is no way to cancel that transaction we have to proceed - therefore
// create new context and work from there
prCtx , _ , finished := process . GetManager ( ) . AddContext ( graceful . GetManager ( ) . HammerContext ( ) , fmt . Sprintf ( "NewPullRequest: %s:%d" , repo . FullName ( ) , pr . Index ) )
defer finished ( )
2021-07-28 05:42:56 -04:00
if pr . Flow == models . PullRequestFlowGithub {
2022-01-19 18:26:57 -05:00
err = PushToBaseRepo ( prCtx , pr )
2021-07-28 05:42:56 -04:00
} else {
2022-01-19 18:26:57 -05:00
err = UpdateRef ( prCtx , pr )
2021-07-28 05:42:56 -04:00
}
if err != nil {
2019-12-14 22:28:51 -05:00
return err
}
2021-09-23 11:45:36 -04:00
mentions , err := pull . FindAndUpdateIssueMentions ( db . DefaultContext , pull . Poster , pull . Content )
2021-01-02 12:04:02 -05:00
if err != nil {
return err
}
notification . NotifyNewPullRequest ( pr , mentions )
2021-01-17 09:15:57 -05:00
if len ( pull . Labels ) > 0 {
notification . NotifyIssueChangeLabels ( pull . Poster , pull , pull . Labels , nil )
}
if pull . Milestone != nil {
notification . NotifyIssueChangeMilestone ( pull . Poster , pull , 0 )
}
2019-09-26 20:22:36 -04:00
2020-05-20 08:47:24 -04:00
// add first push codes comment
2022-01-19 18:26:57 -05:00
baseGitRepo , err := git . OpenRepositoryCtx ( prCtx , pr . BaseRepo . RepoPath ( ) )
2020-05-20 08:47:24 -04:00
if err != nil {
return err
}
defer baseGitRepo . Close ( )
compareInfo , err := baseGitRepo . GetCompareInfo ( pr . BaseRepo . RepoPath ( ) ,
2022-01-18 02:45:43 -05:00
git . BranchPrefix + pr . BaseBranch , pr . GetGitRefName ( ) , false , false )
2020-05-20 08:47:24 -04:00
if err != nil {
return err
}
2021-08-09 14:08:51 -04:00
if len ( compareInfo . Commits ) > 0 {
2020-05-20 08:47:24 -04:00
data := models . PushActionContent { IsForcePush : false }
2021-08-09 14:08:51 -04:00
data . CommitIDs = make ( [ ] string , 0 , len ( compareInfo . Commits ) )
for i := len ( compareInfo . Commits ) - 1 ; i >= 0 ; i -- {
data . CommitIDs = append ( data . CommitIDs , compareInfo . Commits [ i ] . ID . String ( ) )
2020-05-20 08:47:24 -04:00
}
dataJSON , err := json . Marshal ( data )
if err != nil {
return err
}
ops := & models . CreateCommentOptions {
Type : models . CommentTypePullPush ,
Doer : pull . Poster ,
Repo : repo ,
Issue : pr . Issue ,
IsForcePush : false ,
Content : string ( dataJSON ) ,
}
_ , _ = models . CreateComment ( ops )
}
2019-09-26 20:22:36 -04:00
return nil
}
2019-10-14 23:28:40 -04:00
2019-12-16 01:20:25 -05:00
// ChangeTargetBranch changes the target branch of this pull request, as the given user.
2022-01-19 18:26:57 -05:00
func ChangeTargetBranch ( ctx context . Context , pr * models . PullRequest , doer * user_model . User , targetBranch string ) ( err error ) {
2019-12-16 01:20:25 -05:00
// Current target branch is already the same
if pr . BaseBranch == targetBranch {
return nil
}
if pr . Issue . IsClosed {
return models . ErrIssueIsClosed {
ID : pr . Issue . ID ,
RepoID : pr . Issue . RepoID ,
Index : pr . Issue . Index ,
}
}
if pr . HasMerged {
return models . ErrPullRequestHasMerged {
ID : pr . ID ,
IssueID : pr . Index ,
HeadRepoID : pr . HeadRepoID ,
BaseRepoID : pr . BaseRepoID ,
HeadBranch : pr . HeadBranch ,
BaseBranch : pr . BaseBranch ,
}
}
// Check if branches are equal
2022-01-19 18:26:57 -05:00
branchesEqual , err := IsHeadEqualWithBranch ( ctx , pr , targetBranch )
2019-12-16 01:20:25 -05:00
if err != nil {
return err
}
if branchesEqual {
return models . ErrBranchesEqual {
HeadBranchName : pr . HeadBranch ,
BaseBranchName : targetBranch ,
}
}
// Check if pull request for the new target branch already exists
2021-07-28 05:42:56 -04:00
existingPr , err := models . GetUnmergedPullRequest ( pr . HeadRepoID , pr . BaseRepoID , pr . HeadBranch , targetBranch , models . PullRequestFlowGithub )
2019-12-16 01:20:25 -05:00
if existingPr != nil {
return models . ErrPullRequestAlreadyExists {
ID : existingPr . ID ,
IssueID : existingPr . Index ,
HeadRepoID : existingPr . HeadRepoID ,
BaseRepoID : existingPr . BaseRepoID ,
HeadBranch : existingPr . HeadBranch ,
BaseBranch : existingPr . BaseBranch ,
}
}
if err != nil && ! models . IsErrPullRequestNotExist ( err ) {
return err
}
// Set new target branch
oldBranch := pr . BaseBranch
pr . BaseBranch = targetBranch
// Refresh patch
if err := TestPatch ( pr ) ; err != nil {
return err
}
// Update target branch, PR diff and status
// This is the same as checkAndUpdateStatus in check service, but also updates base_branch
if pr . Status == models . PullRequestStatusChecking {
pr . Status = models . PullRequestStatusMergeable
}
2020-06-16 13:52:33 -04:00
// Update Commit Divergence
2022-01-19 18:26:57 -05:00
divergence , err := GetDiverging ( ctx , pr )
2020-06-16 13:52:33 -04:00
if err != nil {
return err
}
pr . CommitsAhead = divergence . Ahead
pr . CommitsBehind = divergence . Behind
2020-10-13 14:50:57 -04:00
if err := pr . UpdateColsIfNotMerged ( "merge_base" , "status" , "conflicted_files" , "changed_protected_files" , "base_branch" , "commits_ahead" , "commits_behind" ) ; err != nil {
2019-12-16 01:20:25 -05:00
return err
}
// Create comment
options := & models . CreateCommentOptions {
Type : models . CommentTypeChangeTargetBranch ,
Doer : doer ,
Repo : pr . Issue . Repo ,
Issue : pr . Issue ,
OldRef : oldBranch ,
NewRef : targetBranch ,
}
if _ , err = models . CreateComment ( options ) ; err != nil {
return fmt . Errorf ( "CreateChangeTargetBranchComment: %v" , err )
}
return nil
}
2022-01-19 18:26:57 -05:00
func checkForInvalidation ( ctx context . Context , requests models . PullRequestList , repoID int64 , doer * user_model . User , branch string ) error {
2021-12-09 20:27:50 -05:00
repo , err := repo_model . GetRepositoryByID ( repoID )
2019-10-14 23:28:40 -04:00
if err != nil {
return fmt . Errorf ( "GetRepositoryByID: %v" , err )
}
2022-01-19 18:26:57 -05:00
gitRepo , err := git . OpenRepositoryCtx ( ctx , repo . RepoPath ( ) )
2019-10-14 23:28:40 -04:00
if err != nil {
return fmt . Errorf ( "git.OpenRepository: %v" , err )
}
go func ( ) {
2019-12-15 04:51:28 -05:00
// FIXME: graceful: We need to tell the manager we're doing something...
2019-10-14 23:28:40 -04:00
err := requests . InvalidateCodeComments ( doer , gitRepo , branch )
if err != nil {
log . Error ( "PullRequestList.InvalidateCodeComments: %v" , err )
}
2019-11-13 02:01:19 -05:00
gitRepo . Close ( )
2019-10-14 23:28:40 -04:00
} ( )
return nil
}
// AddTestPullRequestTask adds new test tasks by given head/base repository and head/base branch,
// and generate new patch for testing as needed.
2021-11-24 04:49:20 -05:00
func AddTestPullRequestTask ( doer * user_model . User , repoID int64 , branch string , isSync bool , oldCommitID , newCommitID string ) {
2019-10-14 23:28:40 -04:00
log . Trace ( "AddTestPullRequestTask [head_repo_id: %d, head_branch: %s]: finding pull requests" , repoID , branch )
2019-12-15 04:51:28 -05:00
graceful . GetManager ( ) . RunWithShutdownContext ( func ( ctx context . Context ) {
// There is no sensible way to shut this down ":-("
// If you don't let it run all the way then you will lose data
// FIXME: graceful: AddTestPullRequestTask needs to become a queue!
2019-10-14 23:28:40 -04:00
2019-12-15 04:51:28 -05:00
prs , err := models . GetUnmergedPullRequestsByHeadInfo ( repoID , branch )
if err != nil {
log . Error ( "Find pull requests [head_repo_id: %d, head_branch: %s]: %v" , repoID , branch , err )
return
2019-10-14 23:28:40 -04:00
}
2019-12-15 04:51:28 -05:00
if isSync {
requests := models . PullRequestList ( prs )
if err = requests . LoadAttributes ( ) ; err != nil {
log . Error ( "PullRequestList.LoadAttributes: %v" , err )
}
2022-01-19 18:26:57 -05:00
if invalidationErr := checkForInvalidation ( ctx , requests , repoID , doer , branch ) ; invalidationErr != nil {
2019-12-15 04:51:28 -05:00
log . Error ( "checkForInvalidation: %v" , invalidationErr )
}
if err == nil {
for _ , pr := range prs {
2020-01-08 20:47:45 -05:00
if newCommitID != "" && newCommitID != git . EmptySHA {
2022-01-19 18:26:57 -05:00
changed , err := checkIfPRContentChanged ( ctx , pr , oldCommitID , newCommitID )
2020-01-08 20:47:45 -05:00
if err != nil {
log . Error ( "checkIfPRContentChanged: %v" , err )
}
if changed {
// Mark old reviews as stale if diff to mergebase has changed
if err := models . MarkReviewsAsStale ( pr . IssueID ) ; err != nil {
log . Error ( "MarkReviewsAsStale: %v" , err )
}
}
if err := models . MarkReviewsAsNotStale ( pr . IssueID , newCommitID ) ; err != nil {
log . Error ( "MarkReviewsAsNotStale: %v" , err )
}
2022-01-19 18:26:57 -05:00
divergence , err := GetDiverging ( ctx , pr )
2020-04-14 09:53:34 -04:00
if err != nil {
log . Error ( "GetDiverging: %v" , err )
} else {
err = pr . UpdateCommitDivergence ( divergence . Ahead , divergence . Behind )
if err != nil {
log . Error ( "UpdateCommitDivergence: %v" , err )
}
}
2020-01-08 20:47:45 -05:00
}
2019-12-15 04:51:28 -05:00
pr . Issue . PullRequest = pr
notification . NotifyPullRequestSynchronized ( doer , pr )
}
2019-10-14 23:28:40 -04:00
}
}
2020-05-20 08:47:24 -04:00
for _ , pr := range prs {
2020-09-14 23:32:31 -04:00
log . Trace ( "Updating PR[%d]: composing new test task" , pr . ID )
2021-07-28 05:42:56 -04:00
if pr . Flow == models . PullRequestFlowGithub {
2022-01-19 18:26:57 -05:00
if err := PushToBaseRepo ( ctx , pr ) ; err != nil {
2021-07-28 05:42:56 -04:00
log . Error ( "PushToBaseRepo: %v" , err )
continue
}
} else {
2020-09-14 23:32:31 -04:00
continue
}
AddToTaskQueue ( pr )
2022-01-19 18:26:57 -05:00
comment , err := models . CreatePushPullComment ( ctx , doer , pr , oldCommitID , newCommitID )
2020-05-20 08:47:24 -04:00
if err == nil && comment != nil {
notification . NotifyPullRequestPushCommits ( doer , pr , comment )
}
}
2019-10-14 23:28:40 -04:00
2019-12-15 04:51:28 -05:00
log . Trace ( "AddTestPullRequestTask [base_repo_id: %d, base_branch: %s]: finding pull requests" , repoID , branch )
prs , err = models . GetUnmergedPullRequestsByBaseInfo ( repoID , branch )
if err != nil {
log . Error ( "Find pull requests [base_repo_id: %d, base_branch: %s]: %v" , repoID , branch , err )
return
}
for _ , pr := range prs {
2022-01-19 18:26:57 -05:00
divergence , err := GetDiverging ( ctx , pr )
2020-04-14 09:53:34 -04:00
if err != nil {
2021-11-30 15:06:32 -05:00
if models . IsErrBranchDoesNotExist ( err ) && ! git . IsBranchExist ( ctx , pr . HeadRepo . RepoPath ( ) , pr . HeadBranch ) {
2021-07-12 19:26:25 -04:00
log . Warn ( "Cannot test PR %s/%d: head_branch %s no longer exists" , pr . BaseRepo . Name , pr . IssueID , pr . HeadBranch )
} else {
log . Error ( "GetDiverging: %v" , err )
}
2020-04-14 09:53:34 -04:00
} else {
err = pr . UpdateCommitDivergence ( divergence . Ahead , divergence . Behind )
if err != nil {
log . Error ( "UpdateCommitDivergence: %v" , err )
}
}
2019-12-15 04:51:28 -05:00
AddToTaskQueue ( pr )
}
} )
2019-10-14 23:28:40 -04:00
}
2019-12-14 22:28:51 -05:00
2020-01-08 20:47:45 -05:00
// checkIfPRContentChanged checks if diff to target branch has changed by push
// A commit can be considered to leave the PR untouched if the patch/diff with its merge base is unchanged
2022-01-19 18:26:57 -05:00
func checkIfPRContentChanged ( ctx context . Context , pr * models . PullRequest , oldCommitID , newCommitID string ) ( hasChanged bool , err error ) {
2020-03-02 17:31:55 -05:00
if err = pr . LoadHeadRepo ( ) ; err != nil {
return false , fmt . Errorf ( "LoadHeadRepo: %v" , err )
2020-01-08 20:47:45 -05:00
} else if pr . HeadRepo == nil {
// corrupt data assumed changed
return true , nil
}
2020-03-02 17:31:55 -05:00
if err = pr . LoadBaseRepo ( ) ; err != nil {
return false , fmt . Errorf ( "LoadBaseRepo: %v" , err )
2020-01-08 20:47:45 -05:00
}
2022-01-19 18:26:57 -05:00
headGitRepo , err := git . OpenRepositoryCtx ( ctx , pr . HeadRepo . RepoPath ( ) )
2020-01-08 20:47:45 -05:00
if err != nil {
return false , fmt . Errorf ( "OpenRepository: %v" , err )
}
defer headGitRepo . Close ( )
// Add a temporary remote.
2020-12-25 04:59:32 -05:00
tmpRemote := "checkIfPRContentChanged-" + fmt . Sprint ( time . Now ( ) . UnixNano ( ) )
2020-01-12 04:36:21 -05:00
if err = headGitRepo . AddRemote ( tmpRemote , pr . BaseRepo . RepoPath ( ) , true ) ; err != nil {
2020-01-08 20:47:45 -05:00
return false , fmt . Errorf ( "AddRemote: %s/%s-%s: %v" , pr . HeadRepo . OwnerName , pr . HeadRepo . Name , tmpRemote , err )
}
defer func ( ) {
if err := headGitRepo . RemoveRemote ( tmpRemote ) ; err != nil {
log . Error ( "checkIfPRContentChanged: RemoveRemote: %s/%s-%s: %v" , pr . HeadRepo . OwnerName , pr . HeadRepo . Name , tmpRemote , err )
}
} ( )
// To synchronize repo and get a base ref
_ , base , err := headGitRepo . GetMergeBase ( tmpRemote , pr . BaseBranch , pr . HeadBranch )
if err != nil {
return false , fmt . Errorf ( "GetMergeBase: %v" , err )
}
diffBefore := & bytes . Buffer { }
diffAfter := & bytes . Buffer { }
if err := headGitRepo . GetDiffFromMergeBase ( base , oldCommitID , diffBefore ) ; err != nil {
// If old commit not found, assume changed.
log . Debug ( "GetDiffFromMergeBase: %v" , err )
return true , nil
}
if err := headGitRepo . GetDiffFromMergeBase ( base , newCommitID , diffAfter ) ; err != nil {
// New commit should be found
return false , fmt . Errorf ( "GetDiffFromMergeBase: %v" , err )
}
diffBeforeLines := bufio . NewScanner ( diffBefore )
diffAfterLines := bufio . NewScanner ( diffAfter )
for diffBeforeLines . Scan ( ) && diffAfterLines . Scan ( ) {
if strings . HasPrefix ( diffBeforeLines . Text ( ) , "index" ) && strings . HasPrefix ( diffAfterLines . Text ( ) , "index" ) {
// file hashes can change without the diff changing
continue
} else if strings . HasPrefix ( diffBeforeLines . Text ( ) , "@@" ) && strings . HasPrefix ( diffAfterLines . Text ( ) , "@@" ) {
// the location of the difference may change
continue
} else if ! bytes . Equal ( diffBeforeLines . Bytes ( ) , diffAfterLines . Bytes ( ) ) {
return true , nil
}
}
if diffBeforeLines . Scan ( ) || diffAfterLines . Scan ( ) {
// Diffs not of equal length
return true , nil
}
return false , nil
}
2019-12-14 22:28:51 -05:00
// PushToBaseRepo pushes commits from branches of head repository to
// corresponding branches of base repository.
// FIXME: Only push branches that are actually updates?
2022-01-19 18:26:57 -05:00
func PushToBaseRepo ( ctx context . Context , pr * models . PullRequest ) ( err error ) {
return pushToBaseRepoHelper ( ctx , pr , "" )
2021-06-23 17:08:26 -04:00
}
2022-01-19 18:26:57 -05:00
func pushToBaseRepoHelper ( ctx context . Context , pr * models . PullRequest , prefixHeadBranch string ) ( err error ) {
2019-12-14 22:28:51 -05:00
log . Trace ( "PushToBaseRepo[%d]: pushing commits to base repo '%s'" , pr . BaseRepoID , pr . GetGitRefName ( ) )
2020-02-21 13:18:13 -05:00
if err := pr . LoadHeadRepo ( ) ; err != nil {
log . Error ( "Unable to load head repository for PR[%d] Error: %v" , pr . ID , err )
return err
}
2019-12-14 22:28:51 -05:00
headRepoPath := pr . HeadRepo . RepoPath ( )
2020-01-28 05:23:58 -05:00
2020-02-21 13:18:13 -05:00
if err := pr . LoadBaseRepo ( ) ; err != nil {
log . Error ( "Unable to load base repository for PR[%d] Error: %v" , pr . ID , err )
return err
}
2020-09-14 23:32:31 -04:00
baseRepoPath := pr . BaseRepo . RepoPath ( )
2019-12-14 22:28:51 -05:00
2019-12-27 16:15:04 -05:00
if err = pr . LoadIssue ( ) ; err != nil {
return fmt . Errorf ( "unable to load issue %d for pr %d: %v" , pr . IssueID , pr . ID , err )
}
if err = pr . Issue . LoadPoster ( ) ; err != nil {
return fmt . Errorf ( "unable to load poster %d for pr %d: %v" , pr . Issue . PosterID , pr . ID , err )
}
2020-09-14 23:32:31 -04:00
gitRefName := pr . GetGitRefName ( )
2022-01-19 18:26:57 -05:00
if err := git . Push ( ctx , headRepoPath , git . PushOptions {
2020-09-14 23:32:31 -04:00
Remote : baseRepoPath ,
2021-06-23 17:08:26 -04:00
Branch : prefixHeadBranch + pr . HeadBranch + ":" + gitRefName ,
2019-12-14 22:28:51 -05:00
Force : true ,
2019-12-27 16:15:04 -05:00
// Use InternalPushingEnvironment here because we know that pre-receive and post-receive do not run on a refs/pulls/...
Env : models . InternalPushingEnvironment ( pr . Issue . Poster , pr . BaseRepo ) ,
2019-12-14 22:28:51 -05:00
} ) ; err != nil {
2020-06-08 14:07:41 -04:00
if git . IsErrPushOutOfDate ( err ) {
// This should not happen as we're using force!
2020-09-14 23:32:31 -04:00
log . Error ( "Unable to push PR head for %s#%d (%-v:%s) due to ErrPushOfDate: %v" , pr . BaseRepo . FullName ( ) , pr . Index , pr . BaseRepo , gitRefName , err )
2020-06-08 14:07:41 -04:00
return err
} else if git . IsErrPushRejected ( err ) {
rejectErr := err . ( * git . ErrPushRejected )
2020-09-14 23:32:31 -04:00
log . Info ( "Unable to push PR head for %s#%d (%-v:%s) due to rejection:\nStdout: %s\nStderr: %s\nError: %v" , pr . BaseRepo . FullName ( ) , pr . Index , pr . BaseRepo , gitRefName , rejectErr . StdOut , rejectErr . StdErr , rejectErr . Err )
2020-06-08 14:07:41 -04:00
return err
2021-06-23 17:08:26 -04:00
} else if git . IsErrMoreThanOne ( err ) {
if prefixHeadBranch != "" {
log . Info ( "Can't push with %s%s" , prefixHeadBranch , pr . HeadBranch )
return err
}
2022-01-19 18:26:57 -05:00
log . Info ( "Retrying to push with %s%s" , git . BranchPrefix , pr . HeadBranch )
err = pushToBaseRepoHelper ( ctx , pr , git . BranchPrefix )
2021-06-23 17:08:26 -04:00
return err
2020-06-08 14:07:41 -04:00
}
2020-09-14 23:32:31 -04:00
log . Error ( "Unable to push PR head for %s#%d (%-v:%s) due to Error: %v" , pr . BaseRepo . FullName ( ) , pr . Index , pr . BaseRepo , gitRefName , err )
return fmt . Errorf ( "Push: %s:%s %s:%s %v" , pr . HeadRepo . FullName ( ) , pr . HeadBranch , pr . BaseRepo . FullName ( ) , gitRefName , err )
2019-12-14 22:28:51 -05:00
}
return nil
}
2020-01-24 21:48:22 -05:00
2021-07-28 05:42:56 -04:00
// UpdateRef update refs/pull/id/head directly for agit flow pull request
2022-01-19 18:26:57 -05:00
func UpdateRef ( ctx context . Context , pr * models . PullRequest ) ( err error ) {
2021-07-28 05:42:56 -04:00
log . Trace ( "UpdateRef[%d]: upgate pull request ref in base repo '%s'" , pr . ID , pr . GetGitRefName ( ) )
if err := pr . LoadBaseRepo ( ) ; err != nil {
log . Error ( "Unable to load base repository for PR[%d] Error: %v" , pr . ID , err )
return err
}
2022-01-19 18:26:57 -05:00
_ , err = git . NewCommandContext ( ctx , "update-ref" , pr . GetGitRefName ( ) , pr . HeadCommitID ) . RunInDir ( pr . BaseRepo . RepoPath ( ) )
2021-07-28 05:42:56 -04:00
if err != nil {
log . Error ( "Unable to update ref in base repository for PR[%d] Error: %v" , pr . ID , err )
}
return err
}
2020-01-24 21:48:22 -05:00
type errlist [ ] error
func ( errs errlist ) Error ( ) string {
if len ( errs ) > 0 {
var buf strings . Builder
for i , err := range errs {
if i > 0 {
buf . WriteString ( ", " )
}
buf . WriteString ( err . Error ( ) )
}
return buf . String ( )
}
return ""
}
// CloseBranchPulls close all the pull requests who's head branch is the branch
2021-11-24 04:49:20 -05:00
func CloseBranchPulls ( doer * user_model . User , repoID int64 , branch string ) error {
2020-01-24 21:48:22 -05:00
prs , err := models . GetUnmergedPullRequestsByHeadInfo ( repoID , branch )
if err != nil {
return err
}
prs2 , err := models . GetUnmergedPullRequestsByBaseInfo ( repoID , branch )
if err != nil {
return err
}
prs = append ( prs , prs2 ... )
if err := models . PullRequestList ( prs ) . LoadAttributes ( ) ; err != nil {
return err
}
var errs errlist
for _ , pr := range prs {
2022-01-18 18:26:42 -05:00
if err = issue_service . ChangeStatus ( pr . Issue , doer , true ) ; err != nil && ! models . IsErrPullWasClosed ( err ) && ! models . IsErrDependenciesLeft ( err ) {
2020-01-24 21:48:22 -05:00
errs = append ( errs , err )
}
}
if len ( errs ) > 0 {
return errs
}
return nil
}
2021-03-01 12:39:44 -05:00
// CloseRepoBranchesPulls close all pull requests which head branches are in the given repository, but only whose base repo is not in the given repository
2022-01-19 18:26:57 -05:00
func CloseRepoBranchesPulls ( ctx context . Context , doer * user_model . User , repo * repo_model . Repository ) error {
branches , _ , err := git . GetBranchesByPath ( ctx , repo . RepoPath ( ) , 0 , 0 )
2020-01-24 21:48:22 -05:00
if err != nil {
return err
}
var errs errlist
for _ , branch := range branches {
prs , err := models . GetUnmergedPullRequestsByHeadInfo ( repo . ID , branch . Name )
if err != nil {
return err
}
if err = models . PullRequestList ( prs ) . LoadAttributes ( ) ; err != nil {
return err
}
for _ , pr := range prs {
2021-03-01 12:39:44 -05:00
// If the base repository for this pr is this repository there is no need to close it
// as it is going to be deleted anyway
if pr . BaseRepoID == repo . ID {
continue
}
2020-02-01 06:24:26 -05:00
if err = issue_service . ChangeStatus ( pr . Issue , doer , true ) ; err != nil && ! models . IsErrPullWasClosed ( err ) {
2020-01-24 21:48:22 -05:00
errs = append ( errs , err )
}
}
}
if len ( errs ) > 0 {
return errs
}
return nil
}
2020-04-10 07:26:37 -04:00
2021-06-25 13:01:43 -04:00
var commitMessageTrailersPattern = regexp . MustCompile ( ` (?:^|\n\n)(?:[\w-]+[ \t]*:[^\n]+\n*(?:[ \t]+[^\n]+\n*)*)+$ ` )
2020-12-21 11:46:14 -05:00
// GetSquashMergeCommitMessages returns the commit messages between head and merge base (if there is one)
2022-01-19 18:26:57 -05:00
func GetSquashMergeCommitMessages ( ctx context . Context , pr * models . PullRequest ) string {
2020-04-10 07:26:37 -04:00
if err := pr . LoadIssue ( ) ; err != nil {
log . Error ( "Cannot load issue %d for PR id %d: Error: %v" , pr . IssueID , pr . ID , err )
return ""
}
if err := pr . Issue . LoadPoster ( ) ; err != nil {
log . Error ( "Cannot load poster %d for pr id %d, index %d Error: %v" , pr . Issue . PosterID , pr . ID , pr . Index , err )
return ""
}
if pr . HeadRepo == nil {
var err error
2021-12-09 20:27:50 -05:00
pr . HeadRepo , err = repo_model . GetRepositoryByID ( pr . HeadRepoID )
2020-04-10 07:26:37 -04:00
if err != nil {
log . Error ( "GetRepositoryById[%d]: %v" , pr . HeadRepoID , err )
return ""
}
}
2022-01-19 18:26:57 -05:00
gitRepo , closer , err := git . RepositoryFromContextOrOpen ( ctx , pr . HeadRepo . RepoPath ( ) )
2020-04-10 07:26:37 -04:00
if err != nil {
log . Error ( "Unable to open head repository: Error: %v" , err )
return ""
}
2022-01-19 18:26:57 -05:00
defer closer . Close ( )
2020-04-10 07:26:37 -04:00
2021-07-28 05:42:56 -04:00
var headCommit * git . Commit
if pr . Flow == models . PullRequestFlowGithub {
headCommit , err = gitRepo . GetBranchCommit ( pr . HeadBranch )
} else {
pr . HeadCommitID , err = gitRepo . GetRefCommitID ( pr . GetGitRefName ( ) )
if err != nil {
log . Error ( "Unable to get head commit: %s Error: %v" , pr . GetGitRefName ( ) , err )
return ""
}
headCommit , err = gitRepo . GetCommit ( pr . HeadCommitID )
}
2020-04-10 07:26:37 -04:00
if err != nil {
log . Error ( "Unable to get head commit: %s Error: %v" , pr . HeadBranch , err )
return ""
}
mergeBase , err := gitRepo . GetCommit ( pr . MergeBase )
if err != nil {
log . Error ( "Unable to get merge base commit: %s Error: %v" , pr . MergeBase , err )
return ""
}
limit := setting . Repository . PullRequest . DefaultMergeMessageCommitsLimit
2021-08-09 14:08:51 -04:00
commits , err := gitRepo . CommitsBetweenLimit ( headCommit , mergeBase , limit , 0 )
2020-04-10 07:26:37 -04:00
if err != nil {
log . Error ( "Unable to get commits between: %s %s Error: %v" , pr . HeadBranch , pr . MergeBase , err )
return ""
}
posterSig := pr . Issue . Poster . NewGitSig ( ) . String ( )
authorsMap := map [ string ] bool { }
2021-08-09 14:08:51 -04:00
authors := make ( [ ] string , 0 , len ( commits ) )
2020-04-10 07:26:37 -04:00
stringBuilder := strings . Builder { }
2020-12-21 11:46:14 -05:00
2021-06-18 18:08:22 -04:00
if ! setting . Repository . PullRequest . PopulateSquashCommentWithCommitMessages {
2021-06-25 13:01:43 -04:00
message := strings . TrimSpace ( pr . Issue . Content )
stringBuilder . WriteString ( message )
2021-06-18 18:08:22 -04:00
if stringBuilder . Len ( ) > 0 {
stringBuilder . WriteRune ( '\n' )
2021-06-25 13:01:43 -04:00
if ! commitMessageTrailersPattern . MatchString ( message ) {
stringBuilder . WriteRune ( '\n' )
}
2021-06-18 18:08:22 -04:00
}
2020-12-21 11:46:14 -05:00
}
2020-11-25 15:08:17 -05:00
// commits list is in reverse chronological order
2021-08-09 14:08:51 -04:00
first := true
for i := len ( commits ) - 1 ; i >= 0 ; i -- {
commit := commits [ i ]
2021-06-18 18:08:22 -04:00
if setting . Repository . PullRequest . PopulateSquashCommentWithCommitMessages {
maxSize := setting . Repository . PullRequest . DefaultMergeMessageSize
if maxSize < 0 || stringBuilder . Len ( ) < maxSize {
var toWrite [ ] byte
2021-08-09 14:08:51 -04:00
if first {
first = false
2021-06-18 18:08:22 -04:00
toWrite = [ ] byte ( strings . TrimPrefix ( commit . CommitMessage , pr . Issue . Title ) )
} else {
toWrite = [ ] byte ( commit . CommitMessage )
}
if len ( toWrite ) > maxSize - stringBuilder . Len ( ) && maxSize > - 1 {
toWrite = append ( toWrite [ : maxSize - stringBuilder . Len ( ) ] , "..." ... )
}
if _ , err := stringBuilder . Write ( toWrite ) ; err != nil {
log . Error ( "Unable to write commit message Error: %v" , err )
return ""
}
if _ , err := stringBuilder . WriteRune ( '\n' ) ; err != nil {
log . Error ( "Unable to write commit message Error: %v" , err )
return ""
}
}
}
2020-04-10 07:26:37 -04:00
authorString := commit . Author . String ( )
if ! authorsMap [ authorString ] && authorString != posterSig {
authors = append ( authors , authorString )
authorsMap [ authorString ] = true
}
}
// Consider collecting the remaining authors
if limit >= 0 && setting . Repository . PullRequest . DefaultMergeMessageAllAuthors {
skip := limit
limit = 30
for {
2021-08-09 14:08:51 -04:00
commits , err := gitRepo . CommitsBetweenLimit ( headCommit , mergeBase , limit , skip )
2020-04-10 07:26:37 -04:00
if err != nil {
log . Error ( "Unable to get commits between: %s %s Error: %v" , pr . HeadBranch , pr . MergeBase , err )
return ""
}
2021-08-09 14:08:51 -04:00
if len ( commits ) == 0 {
2020-04-10 07:26:37 -04:00
break
}
2021-08-09 14:08:51 -04:00
for _ , commit := range commits {
2020-04-10 07:26:37 -04:00
authorString := commit . Author . String ( )
if ! authorsMap [ authorString ] && authorString != posterSig {
authors = append ( authors , authorString )
authorsMap [ authorString ] = true
}
}
2020-11-27 15:00:52 -05:00
skip += limit
2020-04-10 07:26:37 -04:00
}
}
for _ , author := range authors {
if _ , err := stringBuilder . Write ( [ ] byte ( "Co-authored-by: " ) ) ; err != nil {
log . Error ( "Unable to write to string builder Error: %v" , err )
return ""
}
if _ , err := stringBuilder . Write ( [ ] byte ( author ) ) ; err != nil {
log . Error ( "Unable to write to string builder Error: %v" , err )
return ""
}
if _ , err := stringBuilder . WriteRune ( '\n' ) ; err != nil {
log . Error ( "Unable to write to string builder Error: %v" , err )
return ""
}
}
return stringBuilder . String ( )
}
2021-04-15 13:34:43 -04:00
// GetIssuesLastCommitStatus returns a map
2022-01-19 18:26:57 -05:00
func GetIssuesLastCommitStatus ( ctx context . Context , issues models . IssueList ) ( map [ int64 ] * models . CommitStatus , error ) {
2021-04-15 13:34:43 -04:00
if err := issues . LoadPullRequests ( ) ; err != nil {
return nil , err
}
if _ , err := issues . LoadRepositories ( ) ; err != nil {
return nil , err
}
var (
gitRepos = make ( map [ int64 ] * git . Repository )
res = make ( map [ int64 ] * models . CommitStatus )
err error
)
defer func ( ) {
for _ , gitRepo := range gitRepos {
gitRepo . Close ( )
}
} ( )
for _ , issue := range issues {
if ! issue . IsPull {
continue
}
gitRepo , ok := gitRepos [ issue . RepoID ]
if ! ok {
2022-01-19 18:26:57 -05:00
gitRepo , err = git . OpenRepositoryCtx ( ctx , issue . Repo . RepoPath ( ) )
2021-04-15 13:34:43 -04:00
if err != nil {
2021-12-16 14:01:14 -05:00
log . Error ( "Cannot open git repository %-v for issue #%d[%d]. Error: %v" , issue . Repo , issue . Index , issue . ID , err )
continue
2021-04-15 13:34:43 -04:00
}
gitRepos [ issue . RepoID ] = gitRepo
}
status , err := getLastCommitStatus ( gitRepo , issue . PullRequest )
if err != nil {
2021-05-04 08:03:02 -04:00
log . Error ( "getLastCommitStatus: cant get last commit of pull [%d]: %v" , issue . PullRequest . ID , err )
continue
2021-04-15 13:34:43 -04:00
}
res [ issue . PullRequest . ID ] = status
}
return res , nil
}
// getLastCommitStatus get pr's last commit status. PR's last commit status is the head commit id's last commit status
func getLastCommitStatus ( gitRepo * git . Repository , pr * models . PullRequest ) ( status * models . CommitStatus , err error ) {
sha , err := gitRepo . GetRefCommitID ( pr . GetGitRefName ( ) )
2020-04-10 07:26:37 -04:00
if err != nil {
return nil , err
}
2021-12-15 00:39:34 -05:00
statusList , _ , err := models . GetLatestCommitStatus ( pr . BaseRepo . ID , sha , db . ListOptions { } )
2020-04-10 07:26:37 -04:00
if err != nil {
return nil , err
}
2021-04-15 13:34:43 -04:00
return models . CalcCommitStatus ( statusList ) , nil
2020-04-10 07:26:37 -04:00
}
// IsHeadEqualWithBranch returns if the commits of branchName are available in pull request head
2022-01-19 18:26:57 -05:00
func IsHeadEqualWithBranch ( ctx context . Context , pr * models . PullRequest , branchName string ) ( bool , error ) {
2020-04-10 07:26:37 -04:00
var err error
if err = pr . LoadBaseRepo ( ) ; err != nil {
return false , err
}
2022-01-19 18:26:57 -05:00
baseGitRepo , closer , err := git . RepositoryFromContextOrOpen ( ctx , pr . BaseRepo . RepoPath ( ) )
2020-04-10 07:26:37 -04:00
if err != nil {
return false , err
}
2022-01-19 18:26:57 -05:00
defer closer . Close ( )
2021-01-06 14:23:57 -05:00
2020-04-10 07:26:37 -04:00
baseCommit , err := baseGitRepo . GetBranchCommit ( branchName )
if err != nil {
return false , err
}
if err = pr . LoadHeadRepo ( ) ; err != nil {
return false , err
}
2022-01-19 18:26:57 -05:00
var headGitRepo * git . Repository
if pr . HeadRepoID == pr . BaseRepoID {
headGitRepo = baseGitRepo
} else {
var closer io . Closer
headGitRepo , closer , err = git . RepositoryFromContextOrOpen ( ctx , pr . HeadRepo . RepoPath ( ) )
if err != nil {
return false , err
}
defer closer . Close ( )
2020-04-10 07:26:37 -04:00
}
2021-01-06 14:23:57 -05:00
2021-07-28 05:42:56 -04:00
var headCommit * git . Commit
if pr . Flow == models . PullRequestFlowGithub {
headCommit , err = headGitRepo . GetBranchCommit ( pr . HeadBranch )
if err != nil {
return false , err
}
} else {
pr . HeadCommitID , err = baseGitRepo . GetRefCommitID ( pr . GetGitRefName ( ) )
if err != nil {
return false , err
}
if headCommit , err = baseGitRepo . GetCommit ( pr . HeadCommitID ) ; err != nil {
return false , err
}
2020-04-10 07:26:37 -04:00
}
return baseCommit . HasPreviousCommit ( headCommit . ID )
}