From 0fbb8c8826771e92e890fb1c72b356d3e62c7b01 Mon Sep 17 00:00:00 2001
From: Unknwon <u@gogs.io>
Date: Sat, 24 Oct 2015 03:36:47 -0400
Subject: New push to head repo of head branch: regenerate patch and retest
apply
---
models/issue.go | 13 +-
models/pull.go | 345 ++++++++++++++++++++++++++++++++++++++++++++----------
models/repo.go | 30 ++++-
models/update.go | 23 ++--
models/webhook.go | 75 +++++++-----
5 files changed, 374 insertions(+), 112 deletions(-)
(limited to 'models')
diff --git a/models/issue.go b/models/issue.go
index 0b14c583..1cefa42f 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 142739b7..d8bff019 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 ae1e9b74..7d242df2 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 645b58c4..0cf62db4 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 75380d17..7b6d7826 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
}
}
}
--
cgit v1.2.3