Nulo/forgejo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge branch 'dev' of github.com:gogits/gogs into dev

Browse source
This commit is contained in:
Unknown 2014-06-28 15:43:28 -04:00
commit 99713e1180
8 changed files with 171 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
cmd/serve.go
View file

@ -13,6 +13,7 @@ import (
"strings"
"github.com/codegangsta/cli"
"github.com/satori/go.uuid"
"github.com/gogits/gogs/models"
"github.com/gogits/gogs/modules/log"
@ -165,7 +166,9 @@ func runServ(k *cli.Context) {
return
}
models.SetRepoEnvs(user.Id, user.Name, repoName, repoUserName)
//models.SetRepoEnvs(user.Id, user.Name, repoName, repoUserName)
uuid := uuid.NewV4().String()
os.Setenv("uuid", uuid)
gitcmd := exec.Command(verb, repoPath)
gitcmd.Dir = setting.RepoRootPath
@ -177,4 +180,24 @@ func runServ(k *cli.Context) {
println("Gogs: internal error:", err)
log.GitLogger.Fatal("Fail to execute git command: %v", err)
}
if isWrite {
tasks, err := models.GetUpdateTasksByUuid(uuid)
if err != nil {
log.GitLogger.Fatal("Fail to get update task: %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.Fatal("Fail to update: %v", err)
}
}
err = models.DelUpdateTasksByUuid(uuid)
if err != nil {
log.GitLogger.Fatal("Fail to del update task: %v", err)
}
}
}

27
cmd/update.go
View file

@ -6,10 +6,8 @@ package cmd
import (
"os"
"strconv"
"github.com/codegangsta/cli"
"github.com/gogits/gogs/models"
"github.com/gogits/gogs/modules/log"
)
@ -37,12 +35,27 @@ func runUpdate(c *cli.Context) {
log.GitLogger.Fatal("refName is empty, shouldn't use")
}
userName := os.Getenv("userName")
userId, _ := strconv.ParseInt(os.Getenv("userId"), 10, 64)
repoUserName := os.Getenv("repoUserName")
repoName := os.Getenv("repoName")
//userName := os.Getenv("userName")
//userId, _ := strconv.ParseInt(os.Getenv("userId"), 10, 64)
//repoUserName := os.Getenv("repoUserName")
//repoName := os.Getenv("repoName")
uuid := os.Getenv("uuid")
if err := models.Update(args[0], args[1], args[2], userName, repoUserName, repoName, userId); err != nil {
task := models.UpdateTask{
Uuid: uuid,
RefName: args[0],
OldCommitId: args[1],
NewCommitId: args[2],
}
log.GitLogger.Error("%v", task)
if err := models.AddUpdateTask(&task); err != nil {
log.GitLogger.Fatal(err.Error())
}
/*if err := models.Update(args[0], args[1], args[2], userName, repoUserName, repoName, userId); err != nil {
log.GitLogger.Fatal(err.Error())
}*/
//setEnvs(args[0], args[1], args[2], userName, repoUserName, repoName, userId)
}

3
models/models.go
View file

@ -35,7 +35,8 @@ func init() {
tables = append(tables, new(User), new(PublicKey), new(Repository), new(Watch),
new(Action), new(Access), new(Issue), new(Comment), new(Oauth2), new(Follow),
new(Mirror), new(Release), new(LoginSource), new(Webhook), new(IssueUser),
new(Milestone), new(Label), new(HookTask), new(Team), new(OrgUser), new(TeamUser))
new(Milestone), new(Label), new(HookTask), new(Team), new(OrgUser), new(TeamUser),
new(UpdateTask))
}
func LoadModelsConfig() {

2
models/repo.go
View file

@ -302,7 +302,7 @@ func MigrateRepository(u *User, name, desc string, private, mirror bool, url str
// extractGitBareZip extracts git-bare.zip to repository path.
func extractGitBareZip(repoPath string) error {
z, err := zip.Open(path.Join(setting.RepoRootPath, "git-bare.zip"))
z, err := zip.Open(filepath.Join(setting.RepoRootPath, "git-bare.zip"))
if err != nil {
return err
}

82
models/update.go
View file

@ -16,7 +16,39 @@ import (
"github.com/gogits/gogs/modules/log"
)
type UpdateTask struct {
Id int64
Uuid string `xorm:"index"`
RefName string
OldCommitId string
NewCommitId string
}
func AddUpdateTask(task *UpdateTask) error {
_, err := x.Insert(task)
return err
}
func GetUpdateTasksByUuid(uuid string) ([]*UpdateTask, error) {
task := &UpdateTask{
Uuid: uuid,
}
tasks := make([]*UpdateTask, 0)
err := x.Find(&tasks, task)
if err != nil {
return nil, err
}
return tasks, nil
}
func DelUpdateTasksByUuid(uuid string) error {
_, err := x.Delete(&UpdateTask{Uuid: uuid})
return err
}
func Update(refName, oldCommitId, newCommitId, userName, repoUserName, repoName string, userId int64) error {
//fmt.Println(refName, oldCommitId, newCommitId)
//fmt.Println(userName, repoUserName, repoName)
isNew := strings.HasPrefix(oldCommitId, "0000000")
if isNew &&
strings.HasPrefix(newCommitId, "0000000") {
@ -40,6 +72,44 @@ func Update(refName, oldCommitId, newCommitId, userName, repoUserName, repoName
return fmt.Errorf("runUpdate.Open repoId: %v", err)
}
ru, err := GetUserByName(repoUserName)
if err != nil {
return fmt.Errorf("runUpdate.GetUserByName: %v", err)
}
repos, err := GetRepositoryByName(ru.Id, repoName)
if err != nil {
return fmt.Errorf("runUpdate.GetRepositoryByName userId: %v", err)
}
// if tags push
if strings.HasPrefix(refName, "refs/tags/") {
tagName := git.RefEndName(refName)
tag, err := repo.GetTag(tagName)
if err != nil {
log.GitLogger.Fatal("runUpdate.GetTag: %v", err)
}
var actEmail string
if tag.Tagger != nil {
actEmail = tag.Tagger.Email
} else {
cmt, err := tag.Commit()
if err != nil {
log.GitLogger.Fatal("runUpdate.GetTag Commit: %v", err)
}
actEmail = cmt.Committer.Email
}
commit := &base.PushCommits{}
if err = CommitRepoAction(userId, ru.Id, userName, actEmail,
repos.Id, repoUserName, repoName, refName, commit); err != nil {
log.GitLogger.Fatal("runUpdate.models.CommitRepoAction: %s/%s:%v", repoUserName, repoName, err)
}
return err
}
newCommit, err := repo.GetCommit(newCommitId)
if err != nil {
return fmt.Errorf("runUpdate GetCommit of newCommitId: %v", err)
@ -63,21 +133,13 @@ func Update(refName, oldCommitId, newCommitId, userName, repoUserName, repoName
return fmt.Errorf("runUpdate.Commit repoId: %v", err)
}
ru, err := GetUserByName(repoUserName)
if err != nil {
return fmt.Errorf("runUpdate.GetUserByName: %v", err)
}
repos, err := GetRepositoryByName(ru.Id, repoName)
if err != nil {
return fmt.Errorf("runUpdate.GetRepositoryByName userId: %v", err)
}
// if commits push
commits := make([]*base.PushCommit, 0)
var maxCommits = 3
var actEmail string
for e := l.Front(); e != nil; e = e.Next() {
commit := e.Value.(*git.Commit)
if actEmail == "" {
actEmail = commit.Committer.Email
}

2
modules/middleware/context.go
View file

@ -56,8 +56,10 @@ type Context struct {
Repository *models.Repository
Owner *models.User
Commit *git.Commit
Tag *git.Tag
GitRepo *git.Repository
BranchName string
TagName string
CommitId string
RepoLink string
CloneLink struct {

7
modules/middleware/repo.go
View file

@ -185,16 +185,16 @@ func RepoAssignment(redirect bool, args ...bool) martini.Handler {
ctx.Repo.CommitId = ctx.Repo.Commit.Id.String()
} else if gitRepo.IsTagExist(refName) {
ctx.Repo.IsBranch = true
ctx.Repo.IsTag = true
ctx.Repo.BranchName = refName
ctx.Repo.Commit, err = gitRepo.GetCommitOfTag(refName)
ctx.Repo.Tag, err = gitRepo.GetTag(refName)
if err != nil {
ctx.Handle(404, "RepoAssignment invalid tag", nil)
return
}
ctx.Repo.Commit, _ = ctx.Repo.Tag.Commit()
ctx.Repo.CommitId = ctx.Repo.Commit.Id.String()
} else if len(refName) == 40 {
ctx.Repo.IsCommit = true
ctx.Repo.CommitId = refName
@ -244,6 +244,7 @@ func RepoAssignment(redirect bool, args ...bool) martini.Handler {
}
ctx.Data["BranchName"] = ctx.Repo.BranchName
ctx.Data["TagName"] = ctx.Repo.TagName
brs, err := ctx.Repo.GitRepo.GetBranches()
if err != nil {
log.Error("RepoAssignment(GetBranches): %v", err)

60
routers/repo/http.go
View file

@ -7,6 +7,7 @@ package repo
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"net/http"
"os"
@ -130,24 +131,49 @@ func Http(ctx *middleware.Context, params martini.Params) {
}
}
config := Config{setting.RepoRootPath, "git", true, true, func(rpc string, input []byte) {
if rpc == "receive-pack" {
firstLine := bytes.IndexRune(input, '\000')
if firstLine > -1 {
fields := strings.Fields(string(input[:firstLine]))
if len(fields) == 3 {
oldCommitId := fields[0][4:]
newCommitId := fields[1]
refName := fields[2]
var f func(rpc string, input []byte)
if err = models.Update(refName, oldCommitId, newCommitId, authUsername, username, reponame, authUser.Id); err != nil {
log.GitLogger.Error(err.Error())
f = func(rpc string, input []byte) {
if rpc == "receive-pack" {
var lastLine int64 = 0
for {
head := input[lastLine : lastLine+2]
if head[0] == '0' && head[1] == '0' {
size, err := strconv.ParseInt(string(input[lastLine+2:lastLine+4]), 16, 32)
if err != nil {
log.Error("%v", err)
return
}
if size == 0 {
//fmt.Println(string(input[lastLine:]))
break
}
line := input[lastLine : lastLine+size]
idx := bytes.IndexRune(line, '\000')
if idx > -1 {
line = line[:idx]
}
fields := strings.Fields(string(line))
if len(fields) >= 3 {
oldCommitId := fields[0][4:]
newCommitId := fields[1]
refName := fields[2]
models.Update(refName, oldCommitId, newCommitId, authUsername, username, reponame, authUser.Id)
}
lastLine = lastLine + size
} else {
//fmt.Println("ddddddddddd")
break
}
}
}
}}
}
config := Config{setting.RepoRootPath, "git", true, true, f}
handler := HttpBackend(&config)
handler(ctx.ResponseWriter, ctx.Req)
@ -240,8 +266,14 @@ func serviceRpc(rpc string, hr handler) {
w.Header().Set("Content-Type", fmt.Sprintf("application/x-git-%s-result", rpc))
w.WriteHeader(http.StatusOK)
input, _ := ioutil.ReadAll(r.Body)
br := bytes.NewReader(input)
var input []byte
var br io.Reader
if hr.Config.OnSucceed != nil {
input, _ = ioutil.ReadAll(r.Body)
br = bytes.NewReader(input)
} else {
br = r.Body
}
args := []string{rpc, "--stateless-rpc", dir}
cmd := exec.Command(hr.Config.GitBinPath, args...)