New push to head repo of head branch: regenerate patch and retest apply

cmd/serve.go

@@ -200,32 +200,34 @@ func runServ(c *cli.Context) {
 	}
 
 	if requestedMode == models.ACCESS_MODE_WRITE {
-		tasks, err := models.GetUpdateTasksByUuid(uuid)
+		task, err := models.GetUpdateTaskByUUID(uuid)
 		if err != nil {
-			log.GitLogger.Fatal(2, "GetUpdateTasksByUuid: %v", err)
+			log.GitLogger.Fatal(2, "GetUpdateTaskByUUID: %v", err)
 		}
 
-		for _, task := range tasks {
-			err = models.Update(task.RefName, task.OldCommitId, task.NewCommitId,
-				user.Name, repoUserName, repoName, user.Id)
-			if err != nil {
-				log.GitLogger.Error(2, "Failed to update: %v", err)
-			}
+		if err = models.Update(task.RefName, task.OldCommitID, task.NewCommitID,
+			user.Name, repoUserName, repoName, user.Id); err != nil {
+			log.GitLogger.Error(2, "Update: %v", err)
 		}
 
-		if err = models.DelUpdateTasksByUuid(uuid); err != nil {
-			log.GitLogger.Fatal(2, "DelUpdateTasksByUuid: %v", err)
+		if err = models.DeleteUpdateTaskByUUID(uuid); err != nil {
+			log.GitLogger.Fatal(2, "DeleteUpdateTaskByUUID: %v", err)
 		}
-	}
 
-	// Send deliver hook request.
-	reqURL := setting.AppUrl + repoUserName + "/" + repoName + "/hooks/trigger"
-	resp, err := httplib.Head(reqURL).Response()
-	if err == nil {
-		resp.Body.Close()
-		log.GitLogger.Trace("Trigger hook: %s", reqURL)
-	} else {
-		log.GitLogger.Error(2, "Fail to trigger hook: %v", err)
+		// Ask for running deliver hook and test pull request tasks.
+		reqURL := setting.AppUrl + repoUserName + "/" + repoName + "/tasks/trigger?branch=" +
+			strings.TrimPrefix(task.RefName, "refs/heads/")
+		log.GitLogger.Trace("Trigger task: %s", reqURL)
+
+		resp, err := httplib.Head(reqURL).Response()
+		if err == nil {
+			resp.Body.Close()
+			if resp.StatusCode/100 != 2 {
+				log.GitLogger.Error(2, "Fail to trigger task: not 2xx response code")
+			}
+		} else {
+			log.GitLogger.Error(2, "Fail to trigger task: %v", err)
+		}
 	}
 
 	// Update user key activity.

cmd/update.go

@@ -45,13 +45,13 @@ func runUpdate(c *cli.Context) {
 	uuid := os.Getenv("uuid")
 
 	task := models.UpdateTask{
-		Uuid:        uuid,
+		UUID:        uuid,
 		RefName:     args[0],
-		OldCommitId: args[1],
-		NewCommitId: args[2],
+		OldCommitID: args[1],
+		NewCommitID: args[2],
 	}
 
 	if err := models.AddUpdateTask(&task); err != nil {
-		log.GitLogger.Fatal(2, err.Error())
+		log.GitLogger.Fatal(2, "AddUpdateTask: %v", err)
 	}
 }

cmd/web.go

@@ -545,8 +545,8 @@ func runWeb(ctx *cli.Context) {
 		}, ignSignIn, middleware.RepoAssignment(true, true), middleware.RepoRef())
 
 		m.Group("/:reponame", func() {
-			m.Any("/*", ignSignInAndCsrf, repo.Http)
-			m.Head("/hooks/trigger", repo.TriggerHook)
+			m.Any("/*", ignSignInAndCsrf, repo.HTTP)
+			m.Head("/tasks/trigger", repo.TriggerTask)
 		})
 	})
 	// ***** END: Repository *****

conf/locale/locale_en-US.ini

@@ -498,6 +498,7 @@ pulls.reopen_to_merge = Please reopen this pull request to perform merge operati
 pulls.merged = Merged
 pulls.has_merged = This pull request has been merged successfully!
 pulls.data_broken = Data of this pull request has been broken due to deletion of fork information.
+pulls.is_checking = The conflit checking is still in progress, please refresh page in few moments.
 pulls.can_auto_merge_desc = You can perform auto-merge operation on this pull request.
 pulls.cannot_auto_merge_desc = You can't perform auto-merge operation because there are conflicts between commits.
 pulls.cannot_auto_merge_helper = Please use command line tool to solve it.

gogs.go

@@ -17,7 +17,7 @@ import (
 	"github.com/gogits/gogs/modules/setting"
 )
 
-const APP_VER = "0.6.16.1023 Beta"
+const APP_VER = "0.6.17.1024 Beta"
 
 func init() {
 	runtime.GOMAXPROCS(runtime.NumCPU())

models/issue.go

@@ -813,23 +813,22 @@ func GetRepoIssueStats(repoID, uid int64, filterMode int, isPull bool) (numOpen
 	return numOpen, numClosed
 }
 
-// updateIssue updates all fields of given issue.
 func updateIssue(e Engine, issue *Issue) error {
 	_, err := e.Id(issue.ID).AllCols().Update(issue)
 	return err
 }
 
-// updateIssueCols update specific fields of given issue.
+// UpdateIssue updates all fields of given issue.
+func UpdateIssue(issue *Issue) error {
+	return updateIssue(x, issue)
+}
+
+// updateIssueCols updates specific fields of given issue.
 func updateIssueCols(e Engine, issue *Issue, cols ...string) error {
 	_, err := e.Id(issue.ID).Cols(cols...).Update(issue)
 	return err
 }
 
-// UpdateIssue updates information of issue.
-func UpdateIssue(issue *Issue) error {
-	return updateIssue(x, issue)
-}
-
 func updateIssueUsersByStatus(e Engine, issueID int64, isClosed bool) error {
 	_, err := e.Exec("UPDATE `issue_user` SET is_closed=? WHERE issue_id=?", isClosed, issueID)
 	return err

models/pull.go

@@ -6,7 +6,6 @@ package models
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path"
 	"strings"
@@ -18,6 +17,7 @@ import (
 	"github.com/gogits/gogs/modules/git"
 	"github.com/gogits/gogs/modules/log"
 	"github.com/gogits/gogs/modules/process"
+	"github.com/gogits/gogs/modules/setting"
 )
 
 type PullRequestType int
@@ -45,45 +45,25 @@ type PullRequest struct {
 	Issue   *Issue `xorm:"-"`
 	Index   int64
 
-	HeadRepoID     int64
-	HeadRepo       *Repository `xorm:"-"`
-	BaseRepoID     int64
-	HeadUserName   string
-	HeadBranch     string
-	BaseBranch     string
-	MergeBase      string `xorm:"VARCHAR(40)"`
-	MergedCommitID string `xorm:"VARCHAR(40)"`
+	HeadRepoID   int64
+	HeadRepo     *Repository `xorm:"-"`
+	BaseRepoID   int64
+	BaseRepo     *Repository `xorm:"-"`
+	HeadUserName string
+	HeadBranch   string
+	BaseBranch   string
+	MergeBase    string `xorm:"VARCHAR(40)"`
 
-	HasMerged bool
-	Merged    time.Time
-	MergerID  int64
-	Merger    *User `xorm:"-"`
+	HasMerged      bool
+	MergedCommitID string `xorm:"VARCHAR(40)"`
+	Merged         time.Time
+	MergerID       int64
+	Merger         *User `xorm:"-"`
 }
 
 // Note: don't try to get Pull because will end up recursive querying.
 func (pr *PullRequest) AfterSet(colName string, _ xorm.Cell) {
-	var err error
 	switch colName {
-	case "head_repo_id":
-		// FIXME: shouldn't show error if it's known that head repository has been removed.
-		pr.HeadRepo, err = GetRepositoryByID(pr.HeadRepoID)
-		if err != nil {
-			log.Error(3, "GetRepositoryByID[%d]: %v", pr.ID, err)
-		}
-	case "merger_id":
-		if !pr.HasMerged {
-			return
-		}
-
-		pr.Merger, err = GetUserByID(pr.MergerID)
-		if err != nil {
-			if IsErrUserNotExist(err) {
-				pr.MergerID = -1
-				pr.Merger = NewFakeUser()
-			} else {
-				log.Error(3, "GetUserByID[%d]: %v", pr.ID, err)
-			}
-		}
 	case "merged":
 		if !pr.HasMerged {
 			return
@@ -93,6 +73,46 @@ func (pr *PullRequest) AfterSet(colName string, _ xorm.Cell) {
 	}
 }
 
+func (pr *PullRequest) GetHeadRepo() (err error) {
+	pr.HeadRepo, err = GetRepositoryByID(pr.HeadRepoID)
+	if err != nil && !IsErrRepoNotExist(err) {
+		return fmt.Errorf("GetRepositoryByID (head): %v", err)
+	}
+	return nil
+}
+
+func (pr *PullRequest) GetBaseRepo() (err error) {
+	if pr.BaseRepo != nil {
+		return nil
+	}
+
+	pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
+	if err != nil {
+		return fmt.Errorf("GetRepositoryByID (base): %v", err)
+	}
+	return nil
+}
+
+func (pr *PullRequest) GetMerger() (err error) {
+	if !pr.HasMerged || pr.Merger != nil {
+		return nil
+	}
+
+	pr.Merger, err = GetUserByID(pr.MergerID)
+	if IsErrUserNotExist(err) {
+		pr.MergerID = -1
+		pr.Merger = NewFakeUser()
+	} else if err != nil {
+		return fmt.Errorf("GetUserByID: %v", err)
+	}
+	return nil
+}
+
+// IsChecking returns true if this pull request is still checking conflict.
+func (pr *PullRequest) IsChecking() bool {
+	return pr.Status == PULL_REQUEST_STATUS_CHECKING
+}
+
 // CanAutoMerge returns true if this pull request can be merged automatically.
 func (pr *PullRequest) CanAutoMerge() bool {
 	return pr.Status == PULL_REQUEST_STATUS_MERGEABLE
@@ -107,7 +127,11 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository) (err error
 	}
 
 	if err = pr.Issue.changeStatus(sess, doer, true); err != nil {
-		return fmt.Errorf("Pull.changeStatus: %v", err)
+		return fmt.Errorf("Issue.changeStatus: %v", err)
+	}
+
+	if err = pr.GetHeadRepo(); err != nil {
+		return fmt.Errorf("GetHeadRepo: %v", err)
 	}
 
 	headRepoPath := RepoPath(pr.HeadUserName, pr.HeadRepo.Name)
@@ -150,11 +174,26 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository) (err error
 		return fmt.Errorf("git checkout: %s", stderr)
 	}
 
-	// Pull commits.
+	// Add head repo remote.
+	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 fmt.Errorf("git remote add[%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
+	}
+
+	// Merge commits.
 	if _, stderr, err = process.ExecDir(-1, tmpBasePath,
-		fmt.Sprintf("PullRequest.Merge(git pull): %s", tmpBasePath),
-		"git", "pull", headRepoPath, pr.HeadBranch); err != nil {
-		return fmt.Errorf("git pull[%s / %s -> %s]: %s", headRepoPath, pr.HeadBranch, tmpBasePath, stderr)
+		fmt.Sprintf("PullRequest.Merge(git fetch): %s", tmpBasePath),
+		"git", "fetch", "head_repo"); err != nil {
+		return fmt.Errorf("git fetch[%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
+	}
+
+	if _, stderr, err = process.ExecDir(-1, tmpBasePath,
+		fmt.Sprintf("PullRequest.Merge(git merge): %s", tmpBasePath),
+		"git", "merge", "--no-ff", "-m",
+		fmt.Sprintf("Merge branch '%s' of %s/%s into %s", pr.HeadBranch, pr.HeadUserName, pr.HeadRepo.Name, pr.BaseBranch),
+		"head_repo/"+pr.HeadBranch); err != nil {
+		return fmt.Errorf("git merge[%s]: %s", tmpBasePath, stderr)
 	}
 
 	// Push back to upstream.
@@ -167,6 +206,41 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository) (err error
 	return sess.Commit()
 }
 
+// testPatch checks if patch can be merged to base repository without conflit.
+func (pr *PullRequest) testPatch() (err error) {
+	if pr.BaseRepo == nil {
+		pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
+		if err != nil {
+			return fmt.Errorf("GetRepositoryByID: %v", err)
+		}
+	}
+
+	patchPath, err := pr.BaseRepo.PatchPath(pr.Index)
+	if err != nil {
+		return fmt.Errorf("BaseRepo.PatchPath: %v", err)
+	}
+
+	log.Trace("PullRequest[%d].testPatch(patchPath): %s", pr.ID, patchPath)
+
+	if err := pr.BaseRepo.UpdateLocalCopy(); err != nil {
+		return fmt.Errorf("UpdateLocalCopy: %v", err)
+	}
+
+	pr.Status = PULL_REQUEST_STATUS_CHECKING
+	_, stderr, err := process.ExecDir(-1, pr.BaseRepo.LocalCopyPath(),
+		fmt.Sprintf("testPatch(git apply --check): %d", pr.BaseRepo.ID),
+		"git", "apply", "--check", patchPath)
+	if err != nil {
+		if strings.Contains(stderr, "patch does not apply") {
+			log.Trace("PullRequest[%d].testPatch(apply): has conflit", pr.ID)
+			pr.Status = PULL_REQUEST_STATUS_CONFLICT
+		} else {
+			return fmt.Errorf("git apply --check: %v - %s", err, stderr)
+		}
+	}
+	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) {
 	sess := x.NewSession()
@@ -195,32 +269,16 @@ func NewPullRequest(repo *Repository, pull *Issue, labelIDs []int64, uuids []str
 		return err
 	}
 
-	// Test apply patch.
-	if err = repo.UpdateLocalCopy(); err != nil {
-		return fmt.Errorf("UpdateLocalCopy: %v", err)
+	if err = repo.SavePatch(pr.Index, patch); err != nil {
+		return fmt.Errorf("SavePatch: %v", err)
 	}
 
-	repoPath, err := repo.RepoPath()
-	if err != nil {
-		return fmt.Errorf("RepoPath: %v", err)
+	pr.BaseRepo = repo
+	if err = pr.testPatch(); err != nil {
+		return fmt.Errorf("testPatch: %v", err)
 	}
-	patchPath := path.Join(repoPath, "pulls", com.ToStr(pull.ID)+".patch")
-
-	os.MkdirAll(path.Dir(patchPath), os.ModePerm)
-	if err = ioutil.WriteFile(patchPath, patch, 0644); err != nil {
-		return fmt.Errorf("save patch: %v", err)
-	}
-
-	pr.Status = PULL_REQUEST_STATUS_MERGEABLE
-	_, stderr, err := process.ExecDir(-1, repo.LocalCopyPath(),
-		fmt.Sprintf("NewPullRequest(git apply --check): %d", repo.ID),
-		"git", "apply", "--check", patchPath)
-	if err != nil {
-		if strings.Contains(stderr, "patch does not apply") {
-			pr.Status = PULL_REQUEST_STATUS_CONFLICT
-		} else {
-			return fmt.Errorf("git apply --check: %v - %s", err, stderr)
-		}
+	if pr.Status == PULL_REQUEST_STATUS_CHECKING {
+		pr.Status = PULL_REQUEST_STATUS_MERGEABLE
 	}
 
 	pr.IssueID = pull.ID
@@ -236,7 +294,6 @@ func NewPullRequest(repo *Repository, pull *Issue, labelIDs []int64, uuids []str
 // by given head/base and repo/branch.
 func GetUnmergedPullRequest(headRepoID, baseRepoID int64, headBranch, baseBranch string) (*PullRequest, error) {
 	pr := new(PullRequest)
-
 	has, err := x.Where("head_repo_id=? AND head_branch=? AND base_repo_id=? AND base_branch=? AND has_merged=? AND issue.is_closed=?",
 		headRepoID, headBranch, baseRepoID, baseBranch, false, false).
 		Join("INNER", "issue", "issue.id=pull_request.issue_id").Get(pr)
@@ -249,6 +306,27 @@ func GetUnmergedPullRequest(headRepoID, baseRepoID int64, headBranch, baseBranch
 	return pr, nil
 }
 
+// GetUnmergedPullRequestsByHeadInfo returnss all pull requests that are open and has not been merged
+// by given head information (repo and branch).
+func GetUnmergedPullRequestsByHeadInfo(headRepoID int64, headBranch string) ([]*PullRequest, error) {
+	prs := make([]*PullRequest, 0, 2)
+	return prs, x.Where("head_repo_id=? AND head_branch=? AND has_merged=? AND issue.is_closed=?",
+		headRepoID, headBranch, false, false).
+		Join("INNER", "issue", "issue.id=pull_request.issue_id").Find(&prs)
+}
+
+// GetPullRequestByID returns a pull request by given ID.
+func GetPullRequestByID(id int64) (*PullRequest, error) {
+	pr := new(PullRequest)
+	has, err := x.Id(id).Get(pr)
+	if err != nil {
+		return nil, err
+	} else if !has {
+		return nil, ErrPullRequestNotExist{id, 0, 0, 0, "", ""}
+	}
+	return pr, nil
+}
+
 // GetPullRequestByIssueID returns pull request by given issue ID.
 func GetPullRequestByIssueID(issueID int64) (*PullRequest, error) {
 	pr := &PullRequest{
@@ -262,3 +340,144 @@ func GetPullRequestByIssueID(issueID int64) (*PullRequest, error) {
 	}
 	return pr, nil
 }
+
+// Update updates all fields of pull request.
+func (pr *PullRequest) Update() error {
+	_, err := x.Id(pr.ID).AllCols().Update(pr)
+	return err
+}
+
+// Update updates specific fields of pull request.
+func (pr *PullRequest) UpdateCols(cols ...string) error {
+	_, err := x.Id(pr.ID).Cols(cols...).Update(pr)
+	return err
+}
+
+var PullRequestQueue = NewUniqueQueue(setting.Repository.PullRequestQueueLength)
+
+// checkAndUpdateStatus checks if pull request is possible to levaing 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 == PULL_REQUEST_STATUS_CHECKING {
+		pr.Status = PULL_REQUEST_STATUS_MERGEABLE
+	}
+
+	// Make sure there is no waiting test to process before levaing the checking status.
+	if !PullRequestQueue.Exist(pr.ID) {
+		if err := pr.UpdateCols("status"); err != nil {
+			log.Error(4, "Update[%d]: %v", pr.ID, err)
+		}
+	}
+}
+
+// AddTestPullRequestTask adds new test tasks by given head repository and head branch,
+// and generate new patch for testing as needed.
+func AddTestPullRequestTask(headRepoID int64, headBranch string) {
+	log.Trace("AddTestPullRequestTask[head_repo_id: %d, head_branch: %s]: finding pull requests", headRepoID, headBranch)
+	prs, err := GetUnmergedPullRequestsByHeadInfo(headRepoID, headBranch)
+	if err != nil {
+		log.Error(4, "Find pull requests[head_repo_id: %d, head_branch: %s]: %v", headRepoID, headBranch, err)
+		return
+	}
+
+	for _, pr := range prs {
+		log.Trace("AddTestPullRequestTask[%d]: composing new test task", pr.ID)
+		if err := pr.GetHeadRepo(); err != nil {
+			log.Error(4, "GetHeadRepo[%d]: %v", pr.ID, err)
+			continue
+		} else if pr.HeadRepo == nil {
+			log.Trace("AddTestPullRequestTask[%d]: ignored cruppted data", pr.ID)
+			continue
+		}
+
+		if err := pr.GetBaseRepo(); err != nil {
+			log.Error(4, "GetBaseRepo[%d]: %v", pr.ID, err)
+			continue
+		}
+
+		headRepoPath, err := pr.HeadRepo.RepoPath()
+		if err != nil {
+			log.Error(4, "HeadRepo.RepoPath[%d]: %v", pr.ID, err)
+			continue
+		}
+
+		headGitRepo, err := git.OpenRepository(headRepoPath)
+		if err != nil {
+			log.Error(4, "OpenRepository[%d]: %v", pr.ID, err)
+			continue
+		}
+
+		// Generate patch.
+		patch, err := headGitRepo.GetPatch(pr.MergeBase, pr.HeadBranch)
+		if err != nil {
+			log.Error(4, "GetPatch[%d]: %v", pr.ID, err)
+			continue
+		}
+
+		if err = pr.BaseRepo.SavePatch(pr.Index, patch); err != nil {
+			log.Error(4, "BaseRepo.SavePatch[%d]: %v", pr.ID, err)
+			continue
+		}
+
+		if !PullRequestQueue.Exist(pr.ID) {
+			go func() {
+				PullRequestQueue.Add(pr.ID)
+				pr.Status = PULL_REQUEST_STATUS_CHECKING
+				if err = pr.UpdateCols("status"); err != nil {
+					log.Error(5, "AddTestPullRequestTask.UpdateCols[%d].(add to queue): %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)
+	x.Iterate(PullRequest{
+		Status: PULL_REQUEST_STATUS_CHECKING,
+	},
+		func(idx int, bean interface{}) error {
+			pr := bean.(*PullRequest)
+
+			if err := pr.GetBaseRepo(); err != nil {
+				log.Error(3, "GetBaseRepo: %v", err)
+				return nil
+			}
+
+			if err := pr.testPatch(); err != nil {
+				log.Error(3, "testPatch: %v", err)
+				return nil
+			}
+			prs = append(prs, pr)
+			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(4, "GetPullRequestByID[%d]: %v", prID, err)
+			continue
+		} else if err = pr.testPatch(); err != nil {
+			log.Error(4, "testPatch[%d]: %v", pr.ID, err)
+			continue
+		}
+
+		pr.checkAndUpdateStatus()
+	}
+}
+
+func InitTestPullRequests() {
+	go TestPullRequests()
+}

models/repo.go

@@ -183,9 +183,11 @@ func (repo *Repository) AfterSet(colName string, _ xorm.Cell) {
 }
 
 func (repo *Repository) getOwner(e Engine) (err error) {
-	if repo.Owner == nil {
-		repo.Owner, err = getUserByID(e, repo.OwnerID)
+	if repo.Owner != nil {
+		return nil
 	}
+
+	repo.Owner, err = getUserByID(e, repo.OwnerID)
 	return err
 }
 
@@ -326,6 +328,30 @@ func (repo *Repository) UpdateLocalCopy() error {
 	return nil
 }
 
+// PatchPath returns corresponding patch file path of repository by given issue ID.
+func (repo *Repository) PatchPath(index int64) (string, error) {
+	if err := repo.GetOwner(); err != nil {
+		return "", err
+	}
+
+	return filepath.Join(RepoPath(repo.Owner.Name, repo.Name), "pulls", com.ToStr(index)+".patch"), nil
+}
+
+// SavePatch saves patch data to corresponding location by given issue ID.
+func (repo *Repository) SavePatch(index int64, patch []byte) error {
+	patchPath, err := repo.PatchPath(index)
+	if err != nil {
+		return fmt.Errorf("PatchPath: %v", err)
+	}
+
+	os.MkdirAll(path.Dir(patchPath), os.ModePerm)
+	if err = ioutil.WriteFile(patchPath, patch, 0644); err != nil {
+		return fmt.Errorf("WriteFile: %v", err)
+	}
+
+	return nil
+}
+
 func isRepositoryExist(e Engine, u *User, repoName string) (bool, error) {
 	has, err := e.Get(&Repository{
 		OwnerID:   u.Id,

models/update.go

@@ -16,11 +16,11 @@ import (
 )
 
 type UpdateTask struct {
-	Id          int64
-	Uuid        string `xorm:"index"`
+	ID          int64  `xorm:"pk autoincr"`
+	UUID        string `xorm:"index"`
 	RefName     string
-	OldCommitId string
-	NewCommitId string
+	OldCommitID string
+	NewCommitID string
 }
 
 func AddUpdateTask(task *UpdateTask) error {
@@ -28,20 +28,21 @@ func AddUpdateTask(task *UpdateTask) error {
 	return err
 }
 
-func GetUpdateTasksByUuid(uuid string) ([]*UpdateTask, error) {
+func GetUpdateTaskByUUID(uuid string) (*UpdateTask, error) {
 	task := &UpdateTask{
-		Uuid: uuid,
+		UUID: uuid,
 	}
-	tasks := make([]*UpdateTask, 0)
-	err := x.Find(&tasks, task)
+	has, err := x.Get(task)
 	if err != nil {
 		return nil, err
+	} else if !has {
+		return nil, fmt.Errorf("task does not exist: %s", uuid)
 	}
-	return tasks, nil
+	return task, nil
 }
 
-func DelUpdateTasksByUuid(uuid string) error {
-	_, err := x.Delete(&UpdateTask{Uuid: uuid})
+func DeleteUpdateTaskByUUID(uuid string) error {
+	_, err := x.Delete(&UpdateTask{UUID: uuid})
 	return err
 }
 

models/webhook.go

@@ -13,6 +13,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/Unknwon/com"
 	"github.com/go-xorm/xorm"
 
 	api "github.com/gogits/go-gogs-client"
@@ -435,39 +436,58 @@ func PrepareWebhooks(repo *Repository, event HookEventType, p api.Payloader) err
 	return nil
 }
 
-type hookQueue struct {
-	// Make sure one repository only occur once in the queue.
-	lock    sync.Mutex
-	repoIDs map[int64]bool
+// UniqueQueue represents a queue that guarantees only one instance of same ID is in the line.
+type UniqueQueue struct {
+	lock sync.Mutex
+	ids  map[string]bool
 
-	queue chan int64
+	queue chan string
 }
 
-func (q *hookQueue) removeRepoID(id int64) {
+func (q *UniqueQueue) Queue() <-chan string {
+	return q.queue
+}
+
+func NewUniqueQueue(queueLength int) *UniqueQueue {
+	if queueLength <= 0 {
+		queueLength = 100
+	}
+
+	return &UniqueQueue{
+		ids:   make(map[string]bool),
+		queue: make(chan string, queueLength),
+	}
+}
+
+func (q *UniqueQueue) Remove(id interface{}) {
 	q.lock.Lock()
 	defer q.lock.Unlock()
-	delete(q.repoIDs, id)
+	delete(q.ids, com.ToStr(id))
 }
 
-func (q *hookQueue) addRepoID(id int64) {
-	q.lock.Lock()
-	if q.repoIDs[id] {
-		q.lock.Unlock()
+func (q *UniqueQueue) Add(id interface{}) {
+	newid := com.ToStr(id)
+
+	if q.Exist(id) {
 		return
 	}
-	q.repoIDs[id] = true
+
+	q.lock.Lock()
+	q.ids[newid] = true
 	q.lock.Unlock()
-	q.queue <- id
+	q.queue <- newid
 }
 
-// AddRepoID adds repository ID to hook delivery queue.
-func (q *hookQueue) AddRepoID(id int64) {
-	go q.addRepoID(id)
+func (q *UniqueQueue) Exist(id interface{}) bool {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	return q.ids[com.ToStr(id)]
 }
 
-var HookQueue *hookQueue
+var HookQueue = NewUniqueQueue(setting.Webhook.QueueLength)
 
-func deliverHook(t *HookTask) {
+func (t *HookTask) deliver() {
 	t.IsDelivered = true
 
 	timeout := time.Duration(setting.Webhook.DeliverTimeout) * time.Second
@@ -549,12 +569,13 @@ func deliverHook(t *HookTask) {
 }
 
 // DeliverHooks checks and delivers undelivered hooks.
+// TODO: shoot more hooks at same time.
 func DeliverHooks() {
 	tasks := make([]*HookTask, 0, 10)
 	x.Where("is_delivered=?", false).Iterate(new(HookTask),
 		func(idx int, bean interface{}) error {
 			t := bean.(*HookTask)
-			deliverHook(t)
+			t.deliver()
 			tasks = append(tasks, t)
 			return nil
 		})
@@ -566,15 +587,10 @@ func DeliverHooks() {
 		}
 	}
 
-	HookQueue = &hookQueue{
-		lock:    sync.Mutex{},
-		repoIDs: make(map[int64]bool),
-		queue:   make(chan int64, setting.Webhook.QueueLength),
-	}
-
 	// Start listening on new hook requests.
-	for repoID := range HookQueue.queue {
-		HookQueue.removeRepoID(repoID)
+	for repoID := range HookQueue.Queue() {
+		log.Trace("DeliverHooks[%v]: processing delivery hooks", repoID)
+		HookQueue.Remove(repoID)
 
 		tasks = make([]*HookTask, 0, 5)
 		if err := x.Where("repo_id=? AND is_delivered=?", repoID, false).Find(&tasks); err != nil {
@@ -582,9 +598,10 @@ func DeliverHooks() {
 			continue
 		}
 		for _, t := range tasks {
-			deliverHook(t)
+			t.deliver()
 			if err := UpdateHookTask(t); err != nil {
-				log.Error(4, "UpdateHookTask(%d): %v", t.ID, err)
+				log.Error(4, "UpdateHookTask[%d]: %v", t.ID, err)
+				continue
 			}
 		}
 	}

modules/setting/setting.go

@@ -86,6 +86,9 @@ var (
 	}
 
 	// Repository settings.
+	Repository struct {
+		PullRequestQueueLength int
+	}
 	RepoRootPath string
 	ScriptType   string
 	AnsiCharset  string
@@ -357,6 +360,7 @@ func NewContext() {
 	homeDir = strings.Replace(homeDir, "\\", "/", -1)
 
 	sec = Cfg.Section("repository")
+	Repository.PullRequestQueueLength = 10000
 	RepoRootPath = sec.Key("ROOT").MustString(path.Join(homeDir, "gogs-repositories"))
 	forcePathSeparator(RepoRootPath)
 	if !filepath.IsAbs(RepoRootPath) {

public/css/gogs.css

@@ -824,6 +824,9 @@ pre.raw {
 .ui .text.purple {
   color: #6e5494!important;
 }
+.ui .text.yellow {
+  color: #FBBD08!important;
+}
 .ui .text.left {
   text-align: left!important;
 }
@@ -1412,7 +1415,7 @@ footer .container .links > *:first-child {
   border: solid 1px #ccc;
   border-bottom-color: #bbb;
   border-radius: 3px;
-  box-shadow: inset 0 -1px 0 #bbbbbb;
+  box-shadow: inset 0 -1px 0 #bbb;
 }
 .markdown .csv-data td,
 .markdown .csv-data th {

public/less/_base.less

@@ -126,6 +126,9 @@ pre {
 		&.purple {
 			color: #6e5494!important;
 		}
+		&.yellow {
+			color: #FBBD08!important;
+		}
 
 		&.left {
 			text-align: left!important;

routers/install.go

@@ -66,6 +66,7 @@ func GlobalInit() {
 		models.HasEngine = true
 		cron.NewContext()
 		models.InitDeliverHooks()
+		models.InitTestPullRequests()
 		log.NewGitLogger(path.Join(setting.LogRootPath, "http.log"))
 	}
 	if models.EnableSQLite3 {

routers/repo/http.go

@@ -34,7 +34,7 @@ func authRequired(ctx *middleware.Context) {
 	ctx.HTML(401, base.TplName("status/401"))
 }
 
-func Http(ctx *middleware.Context) {
+func HTTP(ctx *middleware.Context) {
 	username := ctx.Params(":username")
 	reponame := ctx.Params(":reponame")
 	if strings.HasSuffix(reponame, ".git") {
@@ -195,7 +195,8 @@ func Http(ctx *middleware.Context) {
 
 						// FIXME: handle error.
 						if err = models.Update(refName, oldCommitId, newCommitId, authUsername, username, reponame, authUser.Id); err == nil {
-							models.HookQueue.AddRepoID(repo.ID)
+							go models.HookQueue.Add(repo.ID)
+							go models.AddTestPullRequestTask(repo.ID, strings.TrimPrefix(refName, "refs/heads/"))
 						}
 
 					}

routers/repo/pull.go

@@ -6,6 +6,7 @@ package repo
 
 import (
 	"container/list"
+	"errors"
 	"path"
 	"strings"
 
@@ -148,6 +149,9 @@ func checkPullInfo(ctx *middleware.Context) *models.Issue {
 	if err = issue.GetPoster(); err != nil {
 		ctx.Handle(500, "GetPoster", err)
 		return nil
+	} else if issue.GetHeadRepo(); err != nil {
+		ctx.Handle(500, "GetHeadRepo", err)
+		return nil
 	}
 
 	if ctx.IsSigned {
@@ -166,6 +170,11 @@ func PrepareMergedViewPullInfo(ctx *middleware.Context, pull *models.Issue) {
 
 	var err error
 
+	if err = pull.GetMerger(); err != nil {
+		ctx.Handle(500, "GetMerger", err)
+		return
+	}
+
 	ctx.Data["HeadTarget"] = pull.HeadUserName + "/" + pull.HeadBranch
 	ctx.Data["BaseTarget"] = ctx.Repo.Owner.Name + "/" + pull.BaseBranch
 
@@ -191,6 +200,12 @@ func PrepareViewPullInfo(ctx *middleware.Context, pull *models.Issue) *git.PullR
 		headGitRepo *git.Repository
 		err         error
 	)
+
+	if err = pull.GetHeadRepo(); err != nil {
+		ctx.Handle(500, "GetHeadRepo", err)
+		return nil
+	}
+
 	if pull.HeadRepo != nil {
 		headRepoPath, err := pull.HeadRepo.RepoPath()
 		if err != nil {
@@ -628,3 +643,21 @@ func CompareAndPullRequestPost(ctx *middleware.Context, form auth.CreateIssueFor
 	log.Trace("Pull request created: %d/%d", repo.ID, pull.ID)
 	ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pull.Index))
 }
+
+func TriggerTask(ctx *middleware.Context) {
+	_, repo := parseOwnerAndRepo(ctx)
+	if ctx.Written() {
+		return
+	}
+	branch := ctx.Query("branch")
+	if len(branch) == 0 {
+		ctx.Handle(422, "TriggerTask", errors.New("branch is empty"))
+		return
+	}
+
+	log.Trace("TriggerTask[%d].(new request): %s", repo.ID, branch)
+
+	go models.HookQueue.Add(repo.ID)
+	go models.AddTestPullRequestTask(repo.ID, branch)
+	ctx.Status(202)
+}

routers/repo/setting.go

@@ -564,28 +564,28 @@ func DeleteWebhook(ctx *middleware.Context) {
 	})
 }
 
-func TriggerHook(ctx *middleware.Context) {
-	u, err := models.GetUserByName(ctx.Params(":username"))
+func parseOwnerAndRepo(ctx *middleware.Context) (*models.User, *models.Repository) {
+	owner, err := models.GetUserByName(ctx.Params(":username"))
 	if err != nil {
 		if models.IsErrUserNotExist(err) {
 			ctx.Handle(404, "GetUserByName", err)
 		} else {
 			ctx.Handle(500, "GetUserByName", err)
 		}
-		return
+		return nil, nil
 	}
 
-	repo, err := models.GetRepositoryByName(u.Id, ctx.Params(":reponame"))
+	repo, err := models.GetRepositoryByName(owner.Id, ctx.Params(":reponame"))
 	if err != nil {
 		if models.IsErrRepoNotExist(err) {
 			ctx.Handle(404, "GetRepositoryByName", err)
 		} else {
 			ctx.Handle(500, "GetRepositoryByName", err)
 		}
-		return
+		return nil, nil
 	}
-	models.HookQueue.AddRepoID(repo.ID)
-	ctx.Status(200)
+
+	return owner, repo
 }
 
 func GitHooks(ctx *middleware.Context) {

templates/.VERSION

@@ -1 +1 @@
-0.6.16.1023 Beta
+0.6.17.1024 Beta

templates/repo/issue/view_content.tmpl

@@ -133,7 +133,13 @@
 
   		{{if .Issue.IsPull}}
   		<div class="comment merge box">
-		    <a class="avatar text {{if .Issue.HasMerged}}purple{{else if .Issue.IsClosed}}grey{{else if and .Issue.CanAutoMerge (not .IsPullReuqestBroken)}}green{{else}}red{{end}}">
+		    <a class="avatar text 
+		    {{if .Issue.HasMerged}}purple
+		    {{else if .Issue.IsClosed}}grey
+		    {{else if .IsPullReuqestBroken}}red
+		    {{else if .Issue.IsChecking}}yellow
+		    {{else if .Issue.CanAutoMerge}}green
+		    {{else}}red{{end}}">
 		      <span class="mega-octicon octicon-git-merge"></span>
 		    </a>
 		    <div class="content">
@@ -151,6 +157,11 @@
 		    			<span class="octicon octicon-x"></span>
 		    			{{$.i18n.Tr "repo.pulls.data_broken"}}
 		    		</div>
+		    		{{else if .Issue.IsChecking}}
+		    		<div class="item text yellow">
+		    			<span class="octicon octicon-sync"></span>
+		    			{{$.i18n.Tr "repo.pulls.is_checking"}}
+		    		</div>
 		    		{{else if .Issue.CanAutoMerge}}
 			    		<div class="item text green">
 			    			<span class="octicon octicon-check"></span>