// Copyright 2019 The Gitea Authors. All rights reserved.// SPDX-License-Identifier: MIT package pull import (	"context"	"fmt"	"io"	"regexp"	"strings"	"time" 	"forgejo.org/models"	"forgejo.org/models/db"	git_model "forgejo.org/models/git"	issues_model "forgejo.org/models/issues"	repo_model "forgejo.org/models/repo"	user_model "forgejo.org/models/user"	"forgejo.org/modules/base"	"forgejo.org/modules/container"	"forgejo.org/modules/git"	"forgejo.org/modules/gitrepo"	"forgejo.org/modules/graceful"	"forgejo.org/modules/json"	"forgejo.org/modules/log"	"forgejo.org/modules/process"	repo_module "forgejo.org/modules/repository"	"forgejo.org/modules/setting"	"forgejo.org/modules/sync"	gitea_context "forgejo.org/services/context"	issue_service "forgejo.org/services/issue"	notify_service "forgejo.org/services/notify") // TODO: use clustered lock (unique queue? or *abuse* cache)var pullWorkingPool = sync.NewExclusivePool() // NewPullRequest creates new pull request with labels for repository.func NewPullRequest(ctx context.Context, repo *repo_model.Repository, issue *issues_model.Issue, labelIDs []int64, uuids []string, pr *issues_model.PullRequest, assigneeIDs []int64) error {	// Check if the doer is not blocked by the repository's owner.	if user_model.IsBlocked(ctx, repo.OwnerID, issue.PosterID) {		return user_model.ErrBlockedByUser	} 	testPatchCtx, err := testPatch(ctx, pr)	defer testPatchCtx.close()	if err != nil {		return fmt.Errorf("testPatch: %w", err)	} 	divergence, err := git.GetDivergingCommits(ctx, testPatchCtx.gitRepo.Path, testPatchCtx.baseRev, testPatchCtx.headRev, testPatchCtx.env)	if err != nil {		return fmt.Errorf("GetDivergingCommits: %w", err)	}	pr.CommitsAhead = divergence.Ahead	pr.CommitsBehind = divergence.Behind 	assigneeCommentMap := make(map[int64]*issues_model.Comment) 	// add first push codes comment	baseGitRepo, err := gitrepo.OpenRepository(ctx, pr.BaseRepo)	if err != nil {		return err	}	defer baseGitRepo.Close() 	var reviewNotifers []*issue_service.ReviewRequestNotifier	if err := db.WithTx(ctx, func(ctx context.Context) error {		if err := issues_model.NewPullRequest(ctx, repo, issue, labelIDs, uuids, pr); err != nil {			return err		} 		for _, assigneeID := range assigneeIDs {			comment, err := issue_service.AddAssigneeIfNotAssigned(ctx, issue, issue.Poster, assigneeID, false)			if err != nil {				return err			}			assigneeCommentMap[assigneeID] = comment		} 		pr.Issue = issue		issue.PullRequest = pr 		if pr.Flow == issues_model.PullRequestFlowGithub {			err = PushToBaseRepo(ctx, pr)		} else {			err = UpdateRef(ctx, pr)		}		if err != nil {			return err		} 		compareInfo, err := baseGitRepo.GetCompareInfo(pr.BaseRepo.RepoPath(),			git.BranchPrefix+pr.BaseBranch, pr.GetGitRefName(), false, false)		if err != nil {			return err		}		if len(compareInfo.Commits) == 0 {			return nil		} 		data := issues_model.PushActionContent{IsForcePush: false}		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())		} 		dataJSON, err := json.Marshal(data)		if err != nil {			return err		} 		ops := &issues_model.CreateCommentOptions{			Type:        issues_model.CommentTypePullRequestPush,			Doer:        issue.Poster,			Repo:        repo,			Issue:       pr.Issue,			IsForcePush: false,			Content:     string(dataJSON),		} 		if _, err = issues_model.CreateComment(ctx, ops); err != nil {			return err		} 		if !pr.IsWorkInProgress(ctx) {			reviewNotifers, err = issue_service.PullRequestCodeOwnersReview(ctx, issue, pr)			if err != nil {				return err			}		}		return nil	}); err != nil {		// cleanup: this will only remove the reference, the real commit will be clean up when next GC		if err1 := baseGitRepo.RemoveReference(pr.GetGitRefName()); err1 != nil {			log.Error("RemoveReference: %v", err1)		}		return err	}	baseGitRepo.Close() // close immediately to avoid notifications will open the repository again 	issue_service.ReviewRequestNotify(ctx, issue, issue.Poster, reviewNotifers) 	mentions, err := issues_model.FindAndUpdateIssueMentions(ctx, issue, issue.Poster, issue.Content)	if err != nil {		return err	}	notify_service.NewPullRequest(ctx, pr, mentions)	if len(issue.Labels) > 0 {		notify_service.IssueChangeLabels(ctx, issue.Poster, issue, issue.Labels, nil)	}	if issue.Milestone != nil {		notify_service.IssueChangeMilestone(ctx, issue.Poster, issue, 0)	}	for _, assigneeID := range assigneeIDs {		assignee, err := user_model.GetUserByID(ctx, assigneeID)		if err != nil {			return ErrDependenciesLeft		}		notify_service.IssueChangeAssignee(ctx, issue.Poster, issue, assignee, false, assigneeCommentMap[assigneeID])	} 	return nil} // ChangeTargetBranch changes the target branch of this pull request, as the given user.func ChangeTargetBranch(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.User, targetBranch string) (err error) {	pullWorkingPool.CheckIn(fmt.Sprint(pr.ID))	defer pullWorkingPool.CheckOut(fmt.Sprint(pr.ID)) 	// Current target branch is already the same	if pr.BaseBranch == targetBranch {		return nil	} 	if pr.Issue.IsClosed {		return issues_model.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	branchesEqual, err := IsHeadEqualWithBranch(ctx, pr, targetBranch)	if err != nil {		return err	}	if branchesEqual {		return git_model.ErrBranchesEqual{			HeadBranchName: pr.HeadBranch,			BaseBranchName: targetBranch,		}	} 	// Check if pull request for the new target branch already exists	existingPr, err := issues_model.GetUnmergedPullRequest(ctx, pr.HeadRepoID, pr.BaseRepoID, pr.HeadBranch, targetBranch, issues_model.PullRequestFlowGithub)	if existingPr != nil {		return issues_model.ErrPullRequestAlreadyExists{			ID:         existingPr.ID,			IssueID:    existingPr.Index,			HeadRepoID: existingPr.HeadRepoID,			BaseRepoID: existingPr.BaseRepoID,			HeadBranch: existingPr.HeadBranch,			BaseBranch: existingPr.BaseBranch,		}	}	if err != nil && !issues_model.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 == issues_model.PullRequestStatusChecking {		pr.Status = issues_model.PullRequestStatusMergeable	} 	// Update Commit Divergence	divergence, err := GetDiverging(ctx, pr)	if err != nil {		return err	}	pr.CommitsAhead = divergence.Ahead	pr.CommitsBehind = divergence.Behind 	if err := pr.UpdateColsIfNotMerged(ctx, "merge_base", "status", "conflicted_files", "changed_protected_files", "base_branch", "commits_ahead", "commits_behind"); err != nil {		return err	} 	// Create comment	options := &issues_model.CreateCommentOptions{		Type:   issues_model.CommentTypeChangeTargetBranch,		Doer:   doer,		Repo:   pr.Issue.Repo,		Issue:  pr.Issue,		OldRef: oldBranch,		NewRef: targetBranch,	}	if _, err = issues_model.CreateComment(ctx, options); err != nil {		return fmt.Errorf("CreateChangeTargetBranchComment: %w", err)	} 	return nil} func checkForInvalidation(ctx context.Context, requests issues_model.PullRequestList, repoID int64, doer *user_model.User, branch string) error {	repo, err := repo_model.GetRepositoryByID(ctx, repoID)	if err != nil {		return fmt.Errorf("GetRepositoryByIDCtx: %w", err)	}	gitRepo, err := gitrepo.OpenRepository(ctx, repo)	if err != nil {		return fmt.Errorf("gitrepo.OpenRepository: %w", err)	}	go func() {		// FIXME: graceful: We need to tell the manager we're doing something...		err := InvalidateCodeComments(ctx, requests, doer, gitRepo, branch)		if err != nil {			log.Error("PullRequestList.InvalidateCodeComments: %v", err)		}		gitRepo.Close()	}()	return nil} // AddTestPullRequestTask adds new test tasks by given head/base repository and head/base branch,// and generate new patch for testing as needed.func AddTestPullRequestTask(ctx context.Context, doer *user_model.User, repoID int64, branch string, isSync bool, oldCommitID, newCommitID string, timeNano int64) {	description := fmt.Sprintf("AddTestPullRequestTask [head_repo_id: %d, head_branch: %s]: only pull requests created before nano time %d will be considered", repoID, branch, timeNano)	log.Trace(description)	go graceful.GetManager().RunWithShutdownContext(func(shutdownCtx context.Context) {		// make it a process to allow for cancellation (especially during integration tests where no global shutdown happens)		ctx, _, finished := process.GetManager().AddContext(shutdownCtx, description)		defer finished()		// There is no sensible way to shut this down ":-("		// If you don't let it run all the way then you will lose data		// TODO: graceful: TestPullRequest needs to become a queue! 		TestPullRequest(ctx, doer, repoID, timeNano, branch, isSync, oldCommitID, newCommitID)	})} func TestPullRequest(ctx context.Context, doer *user_model.User, repoID, olderThan int64, branch string, isSync bool, oldCommitID, newCommitID string) {	// Only consider PR that are older than olderThan, which is the time at	// which the newCommitID was added to repoID.	//	// * commit C is pushed	// * the git hook queues AddTestPullRequestTask for processing and returns with success	// * TestPullRequest is not called yet	// * a pull request P with commit C as the head is created	// * TestPullRequest runs and ignores P because it was created after the commit was received	//	// In other words, a PR must not be updated based on events that happened before it existed	prs, err := issues_model.GetUnmergedPullRequestsByHeadInfoMax(ctx, repoID, olderThan, branch)	if err != nil {		log.Error("Find pull requests [head_repo_id: %d, head_branch: %s]: %v", repoID, branch, err)		return	} 	for _, pr := range prs {		log.Trace("Updating PR[id=%d,index=%d]: composing new test task", pr.ID, pr.Index)		if pr.Flow == issues_model.PullRequestFlowGithub {			if err := PushToBaseRepo(ctx, pr); err != nil {				log.Error("PushToBaseRepo: %v", err)				continue			}		} else {			continue		} 		AddToTaskQueue(ctx, pr)		comment, err := CreatePushPullComment(ctx, doer, pr, oldCommitID, newCommitID)		if err == nil && comment != nil {			notify_service.PullRequestPushCommits(ctx, doer, pr, comment)		}	} 	if isSync {		requests := issues_model.PullRequestList(prs)		if err = requests.LoadAttributes(ctx); err != nil {			log.Error("PullRequestList.LoadAttributes: %v", err)		}		if invalidationErr := checkForInvalidation(ctx, requests, repoID, doer, branch); invalidationErr != nil {			log.Error("checkForInvalidation: %v", invalidationErr)		}		if err == nil {			for _, pr := range prs {				ValidatePullRequest(ctx, pr, newCommitID, oldCommitID, doer)				notify_service.PullRequestSynchronized(ctx, doer, pr)			}		}	} 	log.Trace("TestPullRequest [base_repo_id: %d, base_branch: %s]: finding pull requests", repoID, branch)	prs, err = issues_model.GetUnmergedPullRequestsByBaseInfo(ctx, 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 {		divergence, err := GetDiverging(ctx, pr)		if err != nil {			if git_model.IsErrBranchNotExist(err) && !git.IsBranchExist(ctx, pr.HeadRepo.RepoPath(), pr.HeadBranch) {				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)			}		} else {			err = pr.UpdateCommitDivergence(ctx, divergence.Ahead, divergence.Behind)			if err != nil {				log.Error("UpdateCommitDivergence: %v", err)			}		}		AddToTaskQueue(ctx, pr)	}} // Mark old reviews as stale if diff to mergebase has changed.// Dismiss all approval reviews if protected branch rule item enabled.// Update commit divergence.func ValidatePullRequest(ctx context.Context, pr *issues_model.PullRequest, newCommitID, oldCommitID string, doer *user_model.User) {	objectFormat := git.ObjectFormatFromName(pr.BaseRepo.ObjectFormatName)	if newCommitID == "" || newCommitID == objectFormat.EmptyObjectID().String() {		return	} 	testPatchCtx, err := getTestPatchCtx(ctx, pr, true)	defer testPatchCtx.close()	if err != nil {		log.Error("testPatchCtx: %v", err)		return	} 	changed, err := testPatchCtx.gitRepo.CheckIfDiffDiffers(testPatchCtx.baseRev, oldCommitID, newCommitID, testPatchCtx.env)	if err != nil {		log.Error("CheckIfDiffDiffers: %v", err)	}	if changed {		if err := issues_model.MarkReviewsAsStale(ctx, pr.IssueID); err != nil {			log.Error("MarkReviewsAsStale: %v", err)		} 		pb, err := git_model.GetFirstMatchProtectedBranchRule(ctx, pr.BaseRepoID, pr.BaseBranch)		if err != nil {			log.Error("GetFirstMatchProtectedBranchRule: %v", err)		}		if pb != nil && pb.DismissStaleApprovals {			if err := DismissApprovalReviews(ctx, doer, pr); err != nil {				log.Error("DismissApprovalReviews: %v", err)			}		}	}	if err := issues_model.MarkReviewsAsNotStale(ctx, pr.IssueID, newCommitID); err != nil {		log.Error("MarkReviewsAsNotStale: %v", err)	} 	divergence, err := git.GetDivergingCommits(ctx, testPatchCtx.gitRepo.Path, testPatchCtx.baseRev, testPatchCtx.headRev, testPatchCtx.env)	if err != nil {		log.Error("GetDivergingCommits: %v", err)	} else {		err = pr.UpdateCommitDivergence(ctx, divergence.Ahead, divergence.Behind)		if err != nil {			log.Error("UpdateCommitDivergence: %v", err)		}	}} // PushToBaseRepo pushes commits from branches of head repository to// corresponding branches of base repository.// FIXME: Only push branches that are actually updates?func PushToBaseRepo(ctx context.Context, pr *issues_model.PullRequest) (err error) {	return pushToBaseRepoHelper(ctx, pr, "")} func pushToBaseRepoHelper(ctx context.Context, pr *issues_model.PullRequest, prefixHeadBranch string) (err error) {	log.Trace("PushToBaseRepo[%d]: pushing commits to base repo '%s'", pr.BaseRepoID, pr.GetGitRefName()) 	if err := pr.LoadHeadRepo(ctx); err != nil {		log.Error("Unable to load head repository for PR[%d] Error: %v", pr.ID, err)		return err	}	headRepoPath := pr.HeadRepo.RepoPath() 	if err := pr.LoadBaseRepo(ctx); err != nil {		log.Error("Unable to load base repository for PR[%d] Error: %v", pr.ID, err)		return err	}	baseRepoPath := pr.BaseRepo.RepoPath() 	if err = pr.LoadIssue(ctx); err != nil {		return fmt.Errorf("unable to load issue %d for pr %d: %w", pr.IssueID, pr.ID, err)	}	if err = pr.Issue.LoadPoster(ctx); err != nil {		return fmt.Errorf("unable to load poster %d for pr %d: %w", pr.Issue.PosterID, pr.ID, err)	} 	gitRefName := pr.GetGitRefName() 	if err := git.Push(ctx, headRepoPath, git.PushOptions{		Remote: baseRepoPath,		Branch: prefixHeadBranch + pr.HeadBranch + ":" + gitRefName,		Force:  true,		// Use InternalPushingEnvironment here because we know that pre-receive and post-receive do not run on a refs/pulls/...		Env: repo_module.InternalPushingEnvironment(pr.Issue.Poster, pr.BaseRepo),	}); err != nil {		if git.IsErrPushOutOfDate(err) {			// This should not happen as we're using force!			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)			return err		} else if git.IsErrPushRejected(err) {			rejectErr := err.(*git.ErrPushRejected)			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)			return err		} else if git.IsErrMoreThanOne(err) {			if prefixHeadBranch != "" {				log.Info("Can't push with %s%s", prefixHeadBranch, pr.HeadBranch)				return err			}			log.Info("Retrying to push with %s%s", git.BranchPrefix, pr.HeadBranch)			err = pushToBaseRepoHelper(ctx, pr, git.BranchPrefix)			return err		}		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 %w", pr.HeadRepo.FullName(), pr.HeadBranch, pr.BaseRepo.FullName(), gitRefName, err)	} 	return nil} // UpdateRef update refs/pull/id/head directly for agit flow pull requestfunc UpdateRef(ctx context.Context, pr *issues_model.PullRequest) (err error) {	log.Trace("UpdateRef[%d]: upgate pull request ref in base repo '%s'", pr.ID, pr.GetGitRefName())	if err := pr.LoadBaseRepo(ctx); err != nil {		log.Error("Unable to load base repository for PR[%d] Error: %v", pr.ID, err)		return err	} 	_, _, err = git.NewCommand(ctx, "update-ref").AddDynamicArguments(pr.GetGitRefName(), pr.HeadCommitID).RunStdString(&git.RunOpts{Dir: pr.BaseRepo.RepoPath()})	if err != nil {

Lines 1–500 of 975. Load more