// Copyright 2019 The Gitea Authors. All rights reserved.// SPDX-License-Identifier: MIT package pull import (	"bytes"	"context"	"fmt"	"io"	"os"	"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"	"forgejo.org/modules/util"	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	} 	prCtx, cancel, err := createTemporaryRepoForPR(ctx, pr)	if err != nil {		if !git_model.IsErrBranchNotExist(err) {			log.Error("CreateTemporaryRepoForPR %-v: %v", pr, err)		}		return err	}	defer cancel() 	if err := testPatch(ctx, prCtx, pr); err != nil {		return err	} 	divergence, err := git.GetDivergingCommits(ctx, prCtx.tmpBasePath, baseBranch, trackingBranch)	if err != nil {		return 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() {		changed, err := checkIfPRContentChanged(ctx, pr, oldCommitID, newCommitID)		if err != nil {			log.Error("checkIfPRContentChanged: %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 := GetDiverging(ctx, pr)		if err != nil {			log.Error("GetDiverging: %v", err)		} else {			err = pr.UpdateCommitDivergence(ctx, divergence.Ahead, divergence.Behind)			if err != nil {				log.Error("UpdateCommitDivergence: %v", err)			}		}	}} // 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 unchangedfunc checkIfPRContentChanged(ctx context.Context, pr *issues_model.PullRequest, oldCommitID, newCommitID string) (hasChanged bool, err error) {	prCtx, cancel, err := createTemporaryRepoForPR(ctx, pr)	if err != nil {		log.Error("CreateTemporaryRepoForPR %-v: %v", pr, err)		return false, err	}	defer cancel() 	tmpRepo, err := git.OpenRepository(ctx, prCtx.tmpBasePath)	if err != nil {		return false, fmt.Errorf("OpenRepository: %w", err)	}	defer tmpRepo.Close() 	// Find the merge-base	_, base, err := tmpRepo.GetMergeBase("", "base", "tracking")	if err != nil {		return false, fmt.Errorf("GetMergeBase: %w", err)	} 	cmd := git.NewCommand(ctx, "diff", "--name-only", "-z").AddDynamicArguments(newCommitID, oldCommitID, base)	stdoutReader, stdoutWriter, err := os.Pipe()	if err != nil {		return false, fmt.Errorf("unable to open pipe for to run diff: %w", err)	} 	stderr := new(bytes.Buffer)	if err := cmd.Run(&git.RunOpts{		Dir:    prCtx.tmpBasePath,		Stdout: stdoutWriter,		Stderr: stderr,		PipelineFunc: func(ctx context.Context, cancel context.CancelFunc) error {			_ = stdoutWriter.Close()			defer func() {				_ = stdoutReader.Close()			}()			return util.IsEmptyReader(stdoutReader)		},	}); err != nil {		if err == util.ErrNotEmpty {			return true, nil		}		err = git.ConcatenateError(err, stderr.String()) 		log.Error("Unable to run diff on %s %s %s in tempRepo for PR[%d]%s/%s...%s/%s: Error: %v",			newCommitID, oldCommitID, base,			pr.ID, pr.BaseRepo.FullName(), pr.BaseBranch, pr.HeadRepo.FullName(), pr.HeadBranch,			err) 		return false, fmt.Errorf("Unable to run git diff --name-only -z %s %s %s: %w", newCommitID, oldCommitID, base, err)	} 	return false, nil} // 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()

Lines 1–500 of 1032. Load more