bug fixed & more commits for push

models/action.go

@@ -28,7 +28,7 @@ type Action struct {
 	ActUserName string // Action user name.
 	RepoId      int64
 	RepoName    string
-	Content     string
+	Content     string    `xorm:"varchar(1000)"`
 	Created     time.Time `xorm:"created"`
 }
 

models/models.go

@@ -91,5 +91,5 @@ func GetStatistic() (stats Statistic) {
 	stats.Counter.Watch, _ = orm.Count(new(Watch))
 	stats.Counter.Action, _ = orm.Count(new(Action))
 	stats.Counter.Access, _ = orm.Count(new(Access))
-	return stats
+	return
 }

serve.go

@@ -5,14 +5,19 @@
 package main
 
 import (
+	"bytes"
+	"container/list"
 	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"strconv"
 	"strings"
 
 	"github.com/codegangsta/cli"
+	"github.com/qiniu/log"
 
+	"github.com/gogits/git"
 	"github.com/gogits/gogs/models"
 	"github.com/gogits/gogs/modules/base"
 )
@@ -39,12 +44,27 @@ gogs serv provide access auth for repositories`,
 	Flags:  []cli.Flag{},
 }
 
+func parseCmd(cmd string) (string, string) {
+	ss := strings.SplitN(cmd, " ", 2)
+	if len(ss) != 2 {
+		return "", ""
+	}
+
+	verb, args := ss[0], ss[1]
+	if verb == "git" {
+		ss = strings.SplitN(args, " ", 2)
+		args = ss[1]
+		verb = fmt.Sprintf("%s %s", verb, ss[0])
+	}
+	return verb, args
+}
+
 func In(b string, sl map[string]int) bool {
 	_, e := sl[b]
 	return e
 }
 
-func runServ(*cli.Context) {
+func runServ(k *cli.Context) {
 	base.NewConfigContext()
 	models.LoadModelsConfig()
 	models.NewEngine()
@@ -84,15 +104,20 @@ func runServ(*cli.Context) {
 		repoName = repoName[:len(repoName)-4]
 	}
 
-	os.Setenv("userName", user.Name)
+	//os.Setenv("userName", user.Name)
-	os.Setenv("userId", strconv.Itoa(int(user.Id)))
+	//os.Setenv("userId", strconv.Itoa(int(user.Id)))
 	repo, err := models.GetRepositoryByName(user, repoName)
+	var isExist bool = true
 	if err != nil {
-		println("Unavilable repository", err)
+		if err == models.ErrRepoNotExist {
-		return
+			isExist = false
+		} else {
+			println("Unavilable repository", err)
+			return
+		}
 	}
-	os.Setenv("repoId", strconv.Itoa(int(repo.Id)))
+	//os.Setenv("repoId", strconv.Itoa(int(repo.Id)))
-	os.Setenv("repoName", repoName)
+	//os.Setenv("repoName", repoName)
 
 	isWrite := In(verb, COMMANDS_WRITE)
 	isRead := In(verb, COMMANDS_READONLY)
@@ -130,12 +155,6 @@ func runServ(*cli.Context) {
 		return
 	}
 
-	isExist, err := models.IsRepositoryExist(user, repoName)
-	if err != nil {
-		println("Inernel error:", err.Error())
-		return
-	}
-
 	if !isExist {
 		if isRead {
 			println("Repository", user.Name+"/"+repoName, "is not exist")
@@ -149,28 +168,114 @@ func runServ(*cli.Context) {
 		}
 	}
 
+	rep, err := git.OpenRepository(models.RepoPath(user.Name, repoName))
+	if err != nil {
+		println(err.Error())
+		return
+	}
+
+	refs, err := rep.AllReferencesMap()
+	if err != nil {
+		println(err.Error())
+		return
+	}
+
 	gitcmd := exec.Command(verb, rRepo)
 	gitcmd.Dir = base.RepoRootPath
-	gitcmd.Stdout = os.Stdout
+
-	gitcmd.Stdin = os.Stdin
+	var s string
+	b := bytes.NewBufferString(s)
+
+	gitcmd.Stdout = io.MultiWriter(os.Stdout, b)
+	gitcmd.Stdin = io.MultiReader(os.Stdin, b)
 	gitcmd.Stderr = os.Stderr
 
 	if err = gitcmd.Run(); err != nil {
 		println("execute command error:", err.Error())
 	}
-}
 
-func parseCmd(cmd string) (string, string) {
+	// update
-	ss := strings.SplitN(cmd, " ", 2)
+	w, _ := os.Create("serve.log")
-	if len(ss) != 2 {
+	defer w.Close()
-		return "", ""
+	log.SetOutput(w)
+
+	var t = "ok refs/heads/"
+	var i int
+	var refname string
+	for {
+		l, err := b.ReadString('\n')
+		if err != nil {
+			break
+		}
+		i = i + 1
+		l = l[:len(l)-1]
+		idx := strings.Index(l, t)
+		if idx > 0 {
+			refname = l[idx+len(t):]
+		}
+	}
+	var ref *git.Reference
+	var ok bool
+
+	var l *list.List
+	//log.Info("----", refname, "-----")
+	if ref, ok = refs[refname]; !ok {
+		refs, err = rep.AllReferencesMap()
+		if err != nil {
+			println(err.Error())
+			return
+		}
+		if ref, ok = refs[refname]; !ok {
+			println("unknow reference name", refname)
+			return
+		}
+		l, err = ref.AllCommits()
+		if err != nil {
+			println(err.Error())
+			return
+		}
+	} else {
+		//log.Info("----", ref, "-----")
+		var last *git.Commit
+		//log.Info("00000", ref.Oid.String())
+		last, err = ref.LastCommit()
+		if err != nil {
+			println(err.Error())
+			return
+		}
+
+		ref2, err := rep.LookupReference(ref.Name)
+		if err != nil {
+			println(err.Error())
+			return
+		}
+
+		//log.Info("11111", ref2.Oid.String())
+		before, err := ref2.LastCommit()
+		if err != nil {
+			println(err.Error())
+			return
+		}
+		//log.Info("----", before.Id(), "-----", last.Id())
+		l = ref.CommitsBetween(before, last)
 	}
 
-	verb, args := ss[0], ss[1]
+	commits := make([][]string, 0)
-	if verb == "git" {
+	for e := l.Back(); e != nil; e = e.Prev() {
-		ss = strings.SplitN(args, " ", 2)
+		commit := e.Value.(*git.Commit)
-		args = ss[1]
+		commits = append(commits, []string{commit.Id().String(), commit.Message()})
-		verb = fmt.Sprintf("%s %s", verb, ss[0])
+	}
+
+	if err = models.CommitRepoAction(user.Id, user.Name,
+		repo.Id, ref.BranchName(), commits); err != nil {
+		log.Error("runUpdate.models.CommitRepoAction: %v", err, commits)
+	} else {
+		//log.Info("refname", refname)
+		//log.Info("Listen: %v", cmd)
+		//fmt.Println("...", cmd)
+
+		//runUpdate(k)
+		c := exec.Command("exec", "git", "update-server-info")
+		c.Run()
 	}
-	return verb, args
 }

update.go

@@ -4,16 +4,9 @@
 
 package main
 
-import (
+import "github.com/codegangsta/cli"
-	"os"
-	"strconv"
 
-	"github.com/codegangsta/cli"
+//"github.com/gogits/gogs/modules/log"
-
-	"github.com/gogits/git"
-	"github.com/gogits/gogs/models"
-	"github.com/gogits/gogs/modules/log"
-)
 
 var CmdUpdate = cli.Command{
 	Name:  "update",
@@ -26,6 +19,9 @@ gogs serv provide access auth for repositories`,
 
 // for command: ./gogs update
 func runUpdate(*cli.Context) {
+	/*w, _ := os.Create("update.log")
+	log.SetOutput(w)
+
 	userName := os.Getenv("userName")
 	userId := os.Getenv("userId")
 	repoId := os.Getenv("repoId")
@@ -35,16 +31,19 @@ func runUpdate(*cli.Context) {
 
 	repo, err := git.OpenRepository(f)
 	if err != nil {
+		log.Error("runUpdate.Open repoId: %v", err)
 		return
 	}
 
 	ref, err := repo.LookupReference("HEAD")
 	if err != nil {
+		log.Error("runUpdate.Ref repoId: %v", err)
 		return
 	}
 
 	lastCommit, err := repo.LookupCommit(ref.Oid)
 	if err != nil {
+		log.Error("runUpdate.Commit repoId: %v", err)
 		return
 	}
 
@@ -63,5 +62,8 @@ func runUpdate(*cli.Context) {
 	if err = models.CommitRepoAction(int64(sUserId), userName,
 		int64(sRepoId), repoName, commits); err != nil {
 		log.Error("runUpdate.models.CommitRepoAction: %v", err)
-	}
+	} else {
+		l := exec.Command("exec", "git", "update-server-info")
+		l.Run()
+	}*/
 }