Gogs/internal/database/pull.go

package database

import (
	"context"
	"fmt"
	"os"
	"path/filepath"
	"time"

	"github.com/cockroachdb/errors"
	"github.com/unknwon/com"
	"gorm.io/gorm"
	log "unknwon.dev/clog/v2"

	"github.com/gogs/git-module"
	api "github.com/gogs/go-gogs-client"

	"gogs.io/gogs/internal/conf"
	"gogs.io/gogs/internal/errutil"
	"gogs.io/gogs/internal/osutil"
	"gogs.io/gogs/internal/process"
	"gogs.io/gogs/internal/sync"
)

var PullRequestQueue = sync.NewUniqueQueue(1000)

type PullRequestType int

const (
	PullRequestTypeGogs PullRequestType = iota
	PullRequestTypeGit
)

type PullRequestStatus int

const (
	PullRequestStatusConflict PullRequestStatus = iota
	PullRequestStatusChecking
	PullRequestStatusMergeable
)

// PullRequest represents relation between pull request and repositories.
type PullRequest struct {
	ID     int64 `gorm:"primaryKey"`
	Type   PullRequestType
	Status PullRequestStatus

	IssueID int64  `xorm:"INDEX" gorm:"index"`
	Issue   *Issue `xorm:"-" json:"-" gorm:"-"`
	Index   int64

	HeadRepoID   int64
	HeadRepo     *Repository `xorm:"-" json:"-" gorm:"-"`
	BaseRepoID   int64
	BaseRepo     *Repository `xorm:"-" json:"-" gorm:"-"`
	HeadUserName string
	HeadBranch   string
	BaseBranch   string
	MergeBase    string `xorm:"VARCHAR(40)" gorm:"type:VARCHAR(40)"`

	HasMerged      bool
	MergedCommitID string `xorm:"VARCHAR(40)" gorm:"type:VARCHAR(40)"`
	MergerID       int64
	Merger         *User     `xorm:"-" json:"-" gorm:"-"`
	Merged         time.Time `xorm:"-" json:"-" gorm:"-"`
	MergedUnix     int64
}

func (pr *PullRequest) BeforeUpdate() {
	pr.MergedUnix = pr.Merged.Unix()
}

// Note: don't try to get Issue because will end up recursive querying.
func (pr *PullRequest) AfterFind(tx *gorm.DB) error {
	if pr.HasMerged {
		pr.Merged = time.Unix(pr.MergedUnix, 0).Local()
	}
	return nil
}

// Note: don't try to get Issue because will end up recursive querying.
func (pr *PullRequest) loadAttributes(db *gorm.DB) (err error) {
	if pr.HeadRepo == nil {
		pr.HeadRepo, err = getRepositoryByID(db, pr.HeadRepoID)
		if err != nil && !IsErrRepoNotExist(err) {
			return errors.Newf("get head repository by ID: %v", err)
		}
	}

	if pr.BaseRepo == nil {
		pr.BaseRepo, err = getRepositoryByID(db, pr.BaseRepoID)
		if err != nil {
			return errors.Newf("get base repository by ID: %v", err)
		}
	}

	if pr.HasMerged && pr.Merger == nil {
		pr.Merger, err = getUserByID(db, pr.MergerID)
		if IsErrUserNotExist(err) {
			pr.MergerID = -1
			pr.Merger = NewGhostUser()
		} else if err != nil {
			return errors.Newf("get merger by ID: %v", err)
		}
	}

	return nil
}

func (pr *PullRequest) LoadAttributes() error {
	return pr.loadAttributes(db)
}

func (pr *PullRequest) LoadIssue() (err error) {
	if pr.Issue != nil {
		return nil
	}

	pr.Issue, err = GetIssueByID(pr.IssueID)
	return err
}

// This method assumes following fields have been assigned with valid values:
// Required - Issue, BaseRepo
// Optional - HeadRepo, Merger
func (pr *PullRequest) APIFormat() *api.PullRequest {
	// In case of head repo has been deleted.
	var apiHeadRepo *api.Repository
	if pr.HeadRepo == nil {
		apiHeadRepo = &api.Repository{
			Name: "deleted",
		}
	} else {
		apiHeadRepo = pr.HeadRepo.APIFormatLegacy(nil)
	}

	apiIssue := pr.Issue.APIFormat()
	apiPullRequest := &api.PullRequest{
		ID:         pr.ID,
		Index:      pr.Index,
		Poster:     apiIssue.Poster,
		Title:      apiIssue.Title,
		Body:       apiIssue.Body,
		Labels:     apiIssue.Labels,
		Milestone:  apiIssue.Milestone,
		Assignee:   apiIssue.Assignee,
		State:      apiIssue.State,
		Comments:   apiIssue.Comments,
		HeadBranch: pr.HeadBranch,
		HeadRepo:   apiHeadRepo,
		BaseBranch: pr.BaseBranch,
		BaseRepo:   pr.BaseRepo.APIFormatLegacy(nil),
		HTMLURL:    pr.Issue.HTMLURL(),
		HasMerged:  pr.HasMerged,
	}

	if pr.Status != PullRequestStatusChecking {
		mergeable := pr.Status != PullRequestStatusConflict
		apiPullRequest.Mergeable = &mergeable
	}
	if pr.HasMerged {
		apiPullRequest.Merged = &pr.Merged
		apiPullRequest.MergedCommitID = &pr.MergedCommitID
		apiPullRequest.MergedBy = pr.Merger.APIFormat()
	}

	return apiPullRequest
}

// IsChecking returns true if this pull request is still checking conflict.
func (pr *PullRequest) IsChecking() bool {
	return pr.Status == PullRequestStatusChecking
}

// CanAutoMerge returns true if this pull request can be merged automatically.
func (pr *PullRequest) CanAutoMerge() bool {
	return pr.Status == PullRequestStatusMergeable
}

// MergeStyle represents the approach to merge commits into base branch.
type MergeStyle string

const (
	MergeStyleRegular MergeStyle = "create_merge_commit"
	MergeStyleRebase  MergeStyle = "rebase_before_merging"
)

// Merge merges pull request to base repository.
// FIXME: add repoWorkingPull make sure two merges does not happen at same time.
func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository, mergeStyle MergeStyle, commitDescription string) (err error) {
	ctx := context.TODO()

	defer func() {
		go HookQueue.Add(pr.BaseRepo.ID)
		go AddTestPullRequestTask(doer, pr.BaseRepo.ID, pr.BaseBranch, false)
	}()

	return db.Transaction(func(tx *gorm.DB) error {
		if err := pr.Issue.changeStatus(tx, doer, pr.Issue.Repo, true); err != nil {
			return errors.Newf("Issue.changeStatus: %v", err)
		}

		headRepoPath := RepoPath(pr.HeadUserName, pr.HeadRepo.Name)
		headGitRepo, err := git.Open(headRepoPath)
		if err != nil {
			return errors.Newf("open repository: %v", err)
		}

		// Create temporary directory to store temporary copy of the base repository,
		// and clean it up when operation finished regardless of succeed or not.
		tmpBasePath := filepath.Join(conf.Server.AppDataPath, "tmp", "repos", com.ToStr(time.Now().Nanosecond())+".git")
		if err = os.MkdirAll(filepath.Dir(tmpBasePath), os.ModePerm); err != nil {
			return err
		}
		defer func() {
			_ = os.RemoveAll(filepath.Dir(tmpBasePath))
		}()

		// Clone the base repository to the defined temporary directory,
		// and checks out to base branch directly.
		var stderr string
		if _, stderr, err = process.ExecTimeout(5*time.Minute,
			fmt.Sprintf("PullRequest.Merge (git clone): %s", tmpBasePath),
			"git", "clone", "-b", pr.BaseBranch, baseGitRepo.Path(), tmpBasePath); err != nil {
			return errors.Newf("git clone: %s", stderr)
		}

		// Add remote which points to the head repository.
		if _, stderr, err = process.ExecDir(-1, tmpBasePath,
			fmt.Sprintf("PullRequest.Merge (git remote add): %s", tmpBasePath),
			"git", "remote", "add", "head_repo", headRepoPath); err != nil {
			return errors.Newf("git remote add [%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
		}

		// Fetch information from head repository to the temporary copy.
		if _, stderr, err = process.ExecDir(-1, tmpBasePath,
			fmt.Sprintf("PullRequest.Merge (git fetch): %s", tmpBasePath),
			"git", "fetch", "head_repo"); err != nil {
			return errors.Newf("git fetch [%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
		}

		remoteHeadBranch := "head_repo/" + pr.HeadBranch

		// Check if merge style is allowed, reset to default style if not
		if mergeStyle == MergeStyleRebase && !pr.BaseRepo.PullsAllowRebase {
			mergeStyle = MergeStyleRegular
		}

		switch mergeStyle {
		case MergeStyleRegular: // Create merge commit

			// Merge changes from head branch.
			if _, stderr, err = process.ExecDir(-1, tmpBasePath,
				fmt.Sprintf("PullRequest.Merge (git merge --no-ff --no-commit): %s", tmpBasePath),
				"git", "merge", "--no-ff", "--no-commit", remoteHeadBranch); err != nil {
				return errors.Newf("git merge --no-ff --no-commit [%s]: %v - %s", tmpBasePath, err, stderr)
			}

			// Create a merge commit for the base branch.
			if _, stderr, err = process.ExecDir(-1, tmpBasePath,
				fmt.Sprintf("PullRequest.Merge (git merge): %s", tmpBasePath),
				"git", "commit", fmt.Sprintf("--author='%s <%s>'", doer.DisplayName(), doer.Email),
				"-m", fmt.Sprintf("Merge branch '%s' of %s/%s into %s", pr.HeadBranch, pr.HeadUserName, pr.HeadRepo.Name, pr.BaseBranch),
				"-m", commitDescription); err != nil {
				return errors.Newf("git commit [%s]: %v - %s", tmpBasePath, err, stderr)
			}

		case MergeStyleRebase: // Rebase before merging

			// Rebase head branch based on base branch, this creates a non-branch commit state.
			if _, stderr, err = process.ExecDir(-1, tmpBasePath,
				fmt.Sprintf("PullRequest.Merge (git rebase): %s", tmpBasePath),
				"git", "rebase", "--quiet", pr.BaseBranch, remoteHeadBranch); err != nil {
				return errors.Newf("git rebase [%s on %s]: %s", remoteHeadBranch, pr.BaseBranch, stderr)
			}

			// Name non-branch commit state to a new temporary branch in order to save changes.
			tmpBranch := com.ToStr(time.Now().UnixNano(), 10)
			if _, stderr, err = process.ExecDir(-1, tmpBasePath,
				fmt.Sprintf("PullRequest.Merge (git checkout): %s", tmpBasePath),
				"git", "checkout", "-b", tmpBranch); err != nil {
				return errors.Newf("git checkout '%s': %s", tmpBranch, stderr)
			}

			// Check out the base branch to be operated on.
			if _, stderr, err = process.ExecDir(-1, tmpBasePath,
				fmt.Sprintf("PullRequest.Merge (git checkout): %s", tmpBasePath),
				"git", "checkout", pr.BaseBranch); err != nil {
				return errors.Newf("git checkout '%s': %s", pr.BaseBranch, stderr)
			}

			// Merge changes from temporary branch to the base branch.
			if _, stderr, err = process.ExecDir(-1, tmpBasePath,
				fmt.Sprintf("PullRequest.Merge (git merge): %s", tmpBasePath),
				"git", "merge", tmpBranch); err != nil {
				return errors.Newf("git merge [%s]: %v - %s", tmpBasePath, err, stderr)
			}

		default:
			return errors.Newf("unknown merge style: %s", mergeStyle)
		}

		// Push changes on base branch to upstream.
		if _, stderr, err = process.ExecDir(-1, tmpBasePath,
			fmt.Sprintf("PullRequest.Merge (git push): %s", tmpBasePath),
			"git", "push", baseGitRepo.Path(), pr.BaseBranch); err != nil {
			return errors.Newf("git push: %s", stderr)
		}

		pr.MergedCommitID, err = headGitRepo.BranchCommitID(pr.HeadBranch)
		if err != nil {
			return errors.Newf("get head branch %q commit ID: %v", pr.HeadBranch, err)
		}

		pr.HasMerged = true
		pr.Merged = time.Now()
		pr.MergerID = doer.ID
		if err := tx.Model(&PullRequest{}).Where("id = ?", pr.ID).Updates(pr).Error; err != nil {
			return errors.Newf("update pull request: %v", err)
		}

		if err = Handle.Actions().MergePullRequest(ctx, doer, pr.Issue.Repo.Owner, pr.Issue.Repo, pr.Issue); err != nil {
			log.Error("Failed to create action for merge pull request, pull_request_id: %d, error: %v", pr.ID, err)
		}

		// Reload pull request information.
		if err = pr.LoadAttributes(); err != nil {
			log.Error("LoadAttributes: %v", err)
			return nil
		}
		if err = PrepareWebhooks(pr.Issue.Repo, HookEventTypePullRequest, &api.PullRequestPayload{
			Action:      api.HOOK_ISSUE_CLOSED,
			Index:       pr.Index,
			PullRequest: pr.APIFormat(),
			Repository:  pr.Issue.Repo.APIFormatLegacy(nil),
			Sender:      doer.APIFormat(),
		}); err != nil {
			log.Error("PrepareWebhooks: %v", err)
			return nil
		}

		commits, err := headGitRepo.RevList([]string{pr.MergeBase + "..." + pr.MergedCommitID})
		if err != nil {
			log.Error("Failed to list commits [merge_base: %s, merged_commit_id: %s]: %v", pr.MergeBase, pr.MergedCommitID, err)
			return nil
		}

		// NOTE: It is possible that head branch is not fully sync with base branch
		// for merge commits, so we need to get latest head commit and append merge
		// commit manually to avoid strange diff commits produced.
		mergeCommit, err := baseGitRepo.BranchCommit(pr.BaseBranch)
		if err != nil {
			log.Error("Failed to get base branch %q commit: %v", pr.BaseBranch, err)
			return nil
		}
		if mergeStyle == MergeStyleRegular {
			commits = append([]*git.Commit{mergeCommit}, commits...)
		}

		pcs, err := CommitsToPushCommits(commits).APIFormat(ctx, Handle.Users(), pr.BaseRepo.RepoPath(), pr.BaseRepo.HTMLURL())
		if err != nil {
			log.Error("Failed to convert to API payload commits: %v", err)
			return nil
		}

		p := &api.PushPayload{
			Ref:        git.RefsHeads + pr.BaseBranch,
			Before:     pr.MergeBase,
			After:      mergeCommit.ID.String(),
			CompareURL: conf.Server.ExternalURL + pr.BaseRepo.ComposeCompareURL(pr.MergeBase, pr.MergedCommitID),
			Commits:    pcs,
			Repo:       pr.BaseRepo.APIFormatLegacy(nil),
			Pusher:     pr.HeadRepo.MustOwner().APIFormat(),
			Sender:     doer.APIFormat(),
		}
		if err = PrepareWebhooks(pr.BaseRepo, HookEventTypePush, p); err != nil {
			log.Error("Failed to prepare webhooks: %v", err)
			return nil
		}
		return nil
	})
}

// testPatch checks if patch can be merged to base repository without conflict.
// FIXME: make a mechanism to clean up stable local copies.
func (pr *PullRequest) testPatch() (err error) {
	if pr.BaseRepo == nil {
		pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
		if err != nil {
			return errors.Newf("GetRepositoryByID: %v", err)
		}
	}

	patchPath, err := pr.BaseRepo.PatchPath(pr.Index)
	if err != nil {
		return errors.Newf("BaseRepo.PatchPath: %v", err)
	}

	// Fast fail if patch does not exist, this assumes data is corrupted.
	if !osutil.IsFile(patchPath) {
		log.Trace("PullRequest[%d].testPatch: ignored corrupted data", pr.ID)
		return nil
	}

	repoWorkingPool.CheckIn(com.ToStr(pr.BaseRepoID))
	defer repoWorkingPool.CheckOut(com.ToStr(pr.BaseRepoID))

	log.Trace("PullRequest[%d].testPatch (patchPath): %s", pr.ID, patchPath)

	if err := pr.BaseRepo.UpdateLocalCopyBranch(pr.BaseBranch); err != nil {
		return errors.Newf("UpdateLocalCopy [%d]: %v", pr.BaseRepoID, err)
	}

	args := []string{"apply", "--check"}
	if pr.BaseRepo.PullsIgnoreWhitespace {
		args = append(args, "--ignore-whitespace")
	}
	args = append(args, patchPath)

	pr.Status = PullRequestStatusChecking
	_, stderr, err := process.ExecDir(-1, pr.BaseRepo.LocalCopyPath(),
		fmt.Sprintf("testPatch (git apply --check): %d", pr.BaseRepo.ID),
		"git", args...)
	if err != nil {
		log.Trace("PullRequest[%d].testPatch (apply): has conflict\n%s", pr.ID, stderr)
		pr.Status = PullRequestStatusConflict
		return nil
	}
	return nil
}

// NewPullRequest creates new pull request with labels for repository.
func NewPullRequest(repo *Repository, pull *Issue, labelIDs []int64, uuids []string, pr *PullRequest, patch []byte) (err error) {
	err = db.Transaction(func(tx *gorm.DB) error {
		if err := newIssue(tx, NewIssueOptions{
			Repo:        repo,
			Issue:       pull,
			LableIDs:    labelIDs,
			Attachments: uuids,
			IsPull:      true,
		}); err != nil {
			return errors.Newf("newIssue: %v", err)
		}

		pr.Index = pull.Index
		if err := repo.SavePatch(pr.Index, patch); err != nil {
			return errors.Newf("SavePatch: %v", err)
		}

		pr.BaseRepo = repo
		if err := pr.testPatch(); err != nil {
			return errors.Newf("testPatch: %v", err)
		}
		// No conflict appears after test means mergeable.
		if pr.Status == PullRequestStatusChecking {
			pr.Status = PullRequestStatusMergeable
		}

		pr.IssueID = pull.ID
		if err := tx.Create(pr).Error; err != nil {
			return errors.Newf("insert pull repo: %v", err)
		}

		return nil
	})
	if err != nil {
		return err
	}

	if err = NotifyWatchers(&Action{
		ActUserID:    pull.Poster.ID,
		ActUserName:  pull.Poster.Name,
		OpType:       ActionCreatePullRequest,
		Content:      fmt.Sprintf("%d|%s", pull.Index, pull.Title),
		RepoID:       repo.ID,
		RepoUserName: repo.Owner.Name,
		RepoName:     repo.Name,
		IsPrivate:    repo.IsPrivate,
	}); err != nil {
		log.Error("NotifyWatchers: %v", err)
	}
	if err = pull.MailParticipants(); err != nil {
		log.Error("MailParticipants: %v", err)
	}

	pr.Issue = pull
	pull.PullRequest = pr
	if err = PrepareWebhooks(repo, HookEventTypePullRequest, &api.PullRequestPayload{
		Action:      api.HOOK_ISSUE_OPENED,
		Index:       pull.Index,
		PullRequest: pr.APIFormat(),
		Repository:  repo.APIFormatLegacy(nil),
		Sender:      pull.Poster.APIFormat(),
	}); err != nil {
		log.Error("PrepareWebhooks: %v", err)
	}

	return nil
}

// GetUnmergedPullRequest returns a pull request that is open and has not been merged
// by given head/base and repo/branch.
func GetUnmergedPullRequest(headRepoID, baseRepoID int64, headBranch, baseBranch string) (*PullRequest, error) {
	pr := new(PullRequest)
	err := db.Joins("INNER JOIN issue ON issue.id = pull_request.issue_id").
		Where("pull_request.head_repo_id = ? AND pull_request.head_branch = ? AND pull_request.base_repo_id = ? AND pull_request.base_branch = ? AND pull_request.has_merged = ? AND issue.is_closed = ?",
			headRepoID, headBranch, baseRepoID, baseBranch, false, false).
		First(pr).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrPullRequestNotExist{args: map[string]any{
				"headRepoID": headRepoID,
				"baseRepoID": baseRepoID,
				"headBranch": headBranch,
				"baseBranch": baseBranch,
			}}
		}
		return nil, err
	}

	return pr, nil
}

// GetUnmergedPullRequestsByHeadInfo returns all pull requests that are open and has not been merged
// by given head information (repo and branch).
func GetUnmergedPullRequestsByHeadInfo(repoID int64, branch string) ([]*PullRequest, error) {
	prs := make([]*PullRequest, 0, 2)
	err := db.Joins("INNER JOIN issue ON issue.id = pull_request.issue_id").
		Where("pull_request.head_repo_id = ? AND pull_request.head_branch = ? AND pull_request.has_merged = ? AND issue.is_closed = ?",
			repoID, branch, false, false).
		Find(&prs).Error
	return prs, err
}

// GetUnmergedPullRequestsByBaseInfo returns all pull requests that are open and has not been merged
// by given base information (repo and branch).
func GetUnmergedPullRequestsByBaseInfo(repoID int64, branch string) ([]*PullRequest, error) {
	prs := make([]*PullRequest, 0, 2)
	err := db.Joins("INNER JOIN issue ON issue.id = pull_request.issue_id").
		Where("pull_request.base_repo_id = ? AND pull_request.base_branch = ? AND pull_request.has_merged = ? AND issue.is_closed = ?",
			repoID, branch, false, false).
		Find(&prs).Error
	return prs, err
}

var _ errutil.NotFound = (*ErrPullRequestNotExist)(nil)

type ErrPullRequestNotExist struct {
	args map[string]any
}

func IsErrPullRequestNotExist(err error) bool {
	_, ok := err.(ErrPullRequestNotExist)
	return ok
}

func (err ErrPullRequestNotExist) Error() string {
	return fmt.Sprintf("pull request does not exist: %v", err.args)
}

func (ErrPullRequestNotExist) NotFound() bool {
	return true
}

func getPullRequestByID(db *gorm.DB, id int64) (*PullRequest, error) {
	pr := new(PullRequest)
	err := db.First(pr, id).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrPullRequestNotExist{args: map[string]any{"pullRequestID": id}}
		}
		return nil, err
	}
	return pr, pr.loadAttributes(db)
}

// GetPullRequestByID returns a pull request by given ID.
func GetPullRequestByID(id int64) (*PullRequest, error) {
	return getPullRequestByID(db, id)
}

func getPullRequestByIssueID(db *gorm.DB, issueID int64) (*PullRequest, error) {
	pr := &PullRequest{}
	err := db.Where("issue_id = ?", issueID).First(pr).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrPullRequestNotExist{args: map[string]any{"issueID": issueID}}
		}
		return nil, err
	}
	return pr, pr.loadAttributes(db)
}

// GetPullRequestByIssueID returns pull request by given issue ID.
func GetPullRequestByIssueID(issueID int64) (*PullRequest, error) {
	return getPullRequestByIssueID(db, issueID)
}

// Update updates all fields of pull request.
func (pr *PullRequest) Update() error {
	return db.Model(&PullRequest{}).Where("id = ?", pr.ID).Updates(pr).Error
}

// Update updates specific fields of pull request.
func (pr *PullRequest) UpdateCols(cols ...string) error {
	updates := make(map[string]any)
	for _, col := range cols {
		switch col {
		case "status":
			updates["status"] = pr.Status
		case "merge_base":
			updates["merge_base"] = pr.MergeBase
		case "has_merged":
			updates["has_merged"] = pr.HasMerged
		case "merged_commit_id":
			updates["merged_commit_id"] = pr.MergedCommitID
		case "merger_id":
			updates["merger_id"] = pr.MergerID
		case "merged_unix":
			updates["merged_unix"] = pr.MergedUnix
		}
	}
	return db.Model(&PullRequest{}).Where("id = ?", pr.ID).Updates(updates).Error
}

// UpdatePatch generates and saves a new patch.
func (pr *PullRequest) UpdatePatch() (err error) {
	headGitRepo, err := git.Open(pr.HeadRepo.RepoPath())
	if err != nil {
		return errors.Newf("open repository: %v", err)
	}

	// Add a temporary remote.
	tmpRemote := com.ToStr(time.Now().UnixNano())
	baseRepoPath := RepoPath(pr.BaseRepo.MustOwner().Name, pr.BaseRepo.Name)
	err = headGitRepo.RemoteAdd(tmpRemote, baseRepoPath, git.RemoteAddOptions{Fetch: true})
	if err != nil {
		return errors.Newf("add remote %q [repo_id: %d]: %v", tmpRemote, pr.HeadRepoID, err)
	}
	defer func() {
		if err := headGitRepo.RemoteRemove(tmpRemote); err != nil {
			log.Error("Failed to remove remote %q [repo_id: %d]: %v", tmpRemote, pr.HeadRepoID, err)
		}
	}()

	remoteBranch := "remotes/" + tmpRemote + "/" + pr.BaseBranch
	pr.MergeBase, err = headGitRepo.MergeBase(remoteBranch, pr.HeadBranch)
	if err != nil {
		return errors.Newf("get merge base: %v", err)
	} else if err = pr.Update(); err != nil {
		return errors.Newf("update: %v", err)
	}

	patch, err := headGitRepo.DiffBinary(pr.MergeBase, pr.HeadBranch)
	if err != nil {
		return errors.Newf("get binary patch: %v", err)
	}

	if err = pr.BaseRepo.SavePatch(pr.Index, patch); err != nil {
		return errors.Newf("save patch: %v", err)
	}

	log.Trace("PullRequest[%d].UpdatePatch: patch saved", pr.ID)
	return nil
}

// PushToBaseRepo pushes commits from branches of head repository to
// corresponding branches of base repository.
// FIXME: Only push branches that are actually updates?
func (pr *PullRequest) PushToBaseRepo() (err error) {
	log.Trace("PushToBaseRepo[%d]: pushing commits to base repo 'refs/pull/%d/head'", pr.BaseRepoID, pr.Index)

	headRepoPath := pr.HeadRepo.RepoPath()
	headGitRepo, err := git.Open(headRepoPath)
	if err != nil {
		return errors.Newf("open repository: %v", err)
	}

	tmpRemote := fmt.Sprintf("tmp-pull-%d", pr.ID)
	if err = headGitRepo.RemoteAdd(tmpRemote, pr.BaseRepo.RepoPath()); err != nil {
		return errors.Newf("add remote %q [repo_id: %d]: %v", tmpRemote, pr.HeadRepoID, err)
	}

	// Make sure to remove the remote even if the push fails
	defer func() {
		if err := headGitRepo.RemoteRemove(tmpRemote); err != nil {
			log.Error("Failed to remove remote %q [repo_id: %d]: %v", tmpRemote, pr.HeadRepoID, err)
		}
	}()

	headRefspec := fmt.Sprintf("refs/pull/%d/head", pr.Index)
	headFile := filepath.Join(pr.BaseRepo.RepoPath(), headRefspec)
	if osutil.Exist(headFile) {
		err = os.Remove(headFile)
		if err != nil {
			return errors.Newf("remove head file [repo_id: %d]: %v", pr.BaseRepoID, err)
		}
	}

	err = headGitRepo.Push(tmpRemote, fmt.Sprintf("%s:%s", pr.HeadBranch, headRefspec))
	if err != nil {
		return errors.Newf("push: %v", err)
	}

	return nil
}

// AddToTaskQueue adds itself to pull request test task queue.
func (pr *PullRequest) AddToTaskQueue() {
	go PullRequestQueue.AddFunc(pr.ID, func() {
		pr.Status = PullRequestStatusChecking
		if err := pr.UpdateCols("status"); err != nil {
			log.Error("AddToTaskQueue.UpdateCols[%d].(add to queue): %v", pr.ID, err)
		}
	})
}

type PullRequestList []*PullRequest

func (prs PullRequestList) loadAttributes(db *gorm.DB) (err error) {
	if len(prs) == 0 {
		return nil
	}

	// Load issues
	set := make(map[int64]*Issue)
	for i := range prs {
		set[prs[i].IssueID] = nil
	}
	issueIDs := make([]int64, 0, len(prs))
	for issueID := range set {
		issueIDs = append(issueIDs, issueID)
	}
	issues := make([]*Issue, 0, len(issueIDs))
	if err = db.Where("id IN ?", issueIDs).Find(&issues).Error; err != nil {
		return errors.Newf("find issues: %v", err)
	}
	for i := range issues {
		set[issues[i].ID] = issues[i]
	}
	for i := range prs {
		prs[i].Issue = set[prs[i].IssueID]
	}

	// Load attributes
	for i := range prs {
		if err = prs[i].loadAttributes(db); err != nil {
			return errors.Newf("loadAttributes [%d]: %v", prs[i].ID, err)
		}
	}

	return nil
}

func (prs PullRequestList) LoadAttributes() error {
	return prs.loadAttributes(db)
}

func addHeadRepoTasks(prs []*PullRequest) {
	for _, pr := range prs {
		if pr.HeadRepo == nil {
			log.Trace("addHeadRepoTasks[%d]: missing head repository", pr.ID)
			continue
		}

		log.Trace("addHeadRepoTasks[%d]: composing new test task", pr.ID)
		if err := pr.UpdatePatch(); err != nil {
			log.Error("UpdatePatch: %v", err)
			continue
		} else if err := pr.PushToBaseRepo(); err != nil {
			log.Error("PushToBaseRepo: %v", err)
			continue
		}

		pr.AddToTaskQueue()
	}
}

// AddTestPullRequestTask adds new test tasks by given head/base repository and head/base branch,
// and generate new patch for testing as needed.
func AddTestPullRequestTask(doer *User, repoID int64, branch string, isSync bool) {
	log.Trace("AddTestPullRequestTask [head_repo_id: %d, head_branch: %s]: finding pull requests", repoID, branch)
	prs, err := GetUnmergedPullRequestsByHeadInfo(repoID, branch)
	if err != nil {
		log.Error("Find pull requests [head_repo_id: %d, head_branch: %s]: %v", repoID, branch, err)
		return
	}

	if isSync {
		if err = PullRequestList(prs).LoadAttributes(); err != nil {
			log.Error("PullRequestList.LoadAttributes: %v", err)
		}

		if err == nil {
			for _, pr := range prs {
				pr.Issue.PullRequest = pr
				if err = pr.Issue.LoadAttributes(); err != nil {
					log.Error("LoadAttributes: %v", err)
					continue
				}
				if err = PrepareWebhooks(pr.Issue.Repo, HookEventTypePullRequest, &api.PullRequestPayload{
					Action:      api.HOOK_ISSUE_SYNCHRONIZED,
					Index:       pr.Issue.Index,
					PullRequest: pr.Issue.PullRequest.APIFormat(),
					Repository:  pr.Issue.Repo.APIFormatLegacy(nil),
					Sender:      doer.APIFormat(),
				}); err != nil {
					log.Error("PrepareWebhooks [pull_id: %v]: %v", pr.ID, err)
					continue
				}
			}
		}
	}

	addHeadRepoTasks(prs)

	log.Trace("AddTestPullRequestTask [base_repo_id: %d, base_branch: %s]: finding pull requests", repoID, branch)
	prs, err = 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 {
		pr.AddToTaskQueue()
	}
}

// checkAndUpdateStatus checks if pull request is possible to leaving checking status,
// and set to be either conflict or mergeable.
func (pr *PullRequest) checkAndUpdateStatus() {
	// Status is not changed to conflict means mergeable.
	if pr.Status == PullRequestStatusChecking {
		pr.Status = PullRequestStatusMergeable
	}

	// Make sure there is no waiting test to process before leaving the checking status.
	if !PullRequestQueue.Exist(pr.ID) {
		if err := pr.UpdateCols("status"); err != nil {
			log.Error("Update[%d]: %v", pr.ID, err)
		}
	}
}

// TestPullRequests checks and tests untested patches of pull requests.
// TODO: test more pull requests at same time.
func TestPullRequests() {
	prs := make([]*PullRequest, 0, 10)
	db.Where("status = ?", PullRequestStatusChecking).FindInBatches(&prs, 100, func(tx *gorm.DB, batch int) error {
		for i := range prs {
			pr := prs[i]

			if err := pr.LoadAttributes(); err != nil {
				log.Error("LoadAttributes: %v", err)
				continue
			}

			if err := pr.testPatch(); err != nil {
				log.Error("testPatch: %v", err)
				continue
			}
		}
		return nil
	})

	// Update pull request status.
	for _, pr := range prs {
		pr.checkAndUpdateStatus()
	}

	// Start listening on new test requests.
	for prID := range PullRequestQueue.Queue() {
		log.Trace("TestPullRequests[%v]: processing test task", prID)
		PullRequestQueue.Remove(prID)

		pr, err := GetPullRequestByID(com.StrTo(prID).MustInt64())
		if err != nil {
			log.Error("GetPullRequestByID[%s]: %v", prID, err)
			continue
		} else if err = pr.testPatch(); err != nil {
			log.Error("testPatch[%d]: %v", pr.ID, err)
			continue
		}

		pr.checkAndUpdateStatus()
	}
}

func InitTestPullRequests() {
	go TestPullRequests()
}