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

5 files changed, 374 insertions, 112 deletions

diff --git a/models/issue.go b/models/issue.go
index 0b14c5838a..1cefa42f5a 100644
--- a/models/issue.go
+++ b/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
diff --git a/models/pull.go b/models/pull.go
index 142739b77f..d8bff01998 100644
--- a/models/pull.go
+++ b/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()
+}
diff --git a/models/repo.go b/models/repo.go
index ae1e9b7497..7d242df22f 100644
--- a/models/repo.go
+++ b/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,
diff --git a/models/update.go b/models/update.go
index 645b58c4c5..0cf62db418 100644
--- a/models/update.go
+++ b/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
 }
 
diff --git a/models/webhook.go b/models/webhook.go
index 75380d17c1..7b6d7826e7 100644
--- a/models/webhook.go
+++ b/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
 			}
 		}
 	}