bug fixed & more commits for push

diff --git a/models/action.go b/models/action.go
index 107d4b1057fde651a4f99141f2b1faff238e5d0f..d338da24bac3e506e80d71a606a9719490a28049 100644 (file)
--- a/models/action.go
+++ b/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"`
 }
 

diff --git a/models/models.go b/models/models.go
index 8713ff2896a61949c71ae111b2702d835a3ff5c1..7f5f626f5e98ce00b60db3af152c120e63d92bca 100644 (file)
--- a/models/models.go
+++ b/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
 }

diff --git a/serve.go b/serve.go
index 3ce8f9046cb0e4b34a24810bdbecd78f89b94dc0..b786c54356d15df839708b187b8b1b77bac803a9 100644 (file)
--- a/serve.go
+++ b/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("userId", strconv.Itoa(int(user.Id)))
+       //os.Setenv("userName", user.Name)
+       //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)
-               return
+               if err == models.ErrRepoNotExist {
+                       isExist = false
+               } else {
+                       println("Unavilable repository", err)
+                       return
+               }
        }
-       os.Setenv("repoId", strconv.Itoa(int(repo.Id)))
-       os.Setenv("repoName", repoName)
+       //os.Setenv("repoId", strconv.Itoa(int(repo.Id)))
+       //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) {
-       ss := strings.SplitN(cmd, " ", 2)
-       if len(ss) != 2 {
-               return "", ""
+       // update
+       w, _ := os.Create("serve.log")
+       defer w.Close()
+       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
 
-       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])
+       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)
+       }
+
+       commits := make([][]string, 0)
+       for e := l.Back(); e != nil; e = e.Prev() {
+               commit := e.Value.(*git.Commit)
+               commits = append(commits, []string{commit.Id().String(), commit.Message()})
+       }
+
+       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
 }

diff --git a/update.go b/update.go
index baa433d75c6364e2b8c2aca8ad3da74ddf93839f..915e046530d43c6ac0dfc08cc25a53a7562eefa9 100644 (file)
--- a/update.go
+++ b/update.go
@@ -4,16 +4,9 @@
 
 package main
 
-import (
-       "os"
-       "strconv"
+import "github.com/codegangsta/cli"
 
-       "github.com/codegangsta/cli"
-
-       "github.com/gogits/git"
-       "github.com/gogits/gogs/models"
-       "github.com/gogits/gogs/modules/log"
-)
+//"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()
+       }*/
 }