@@ -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. |
@@ -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) | |||
} | |||
} |
@@ -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 ***** |
@@ -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. |
@@ -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()) |
@@ -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 |
@@ -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() | |||
} |
@@ -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, |
@@ -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 | |||
} | |||
@@ -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 | |||
} | |||
} | |||
} |
@@ -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) { |
@@ -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 { |
@@ -126,6 +126,9 @@ pre { | |||
&.purple { | |||
color: #6e5494!important; | |||
} | |||
&.yellow { | |||
color: #FBBD08!important; | |||
} | |||
&.left { | |||
text-align: left!important; |
@@ -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 { |
@@ -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/")) | |||
} | |||
} |
@@ -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) | |||
} |
@@ -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) { |
@@ -1 +1 @@ | |||
0.6.16.1023 Beta | |||
0.6.17.1024 Beta |
@@ -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> |