migrate some commands

Author: unknwon

blob.go

@@ -0,0 +1,23 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"bytes"
+	"io"
+)
+
+type Blob struct {
+	repo *Repository
+	*TreeEntry
+}
+
+func (b *Blob) Data() (io.Reader, error) {
+	stdout, err := NewCommand("show", b.ID.String()).RunInDirBytes(b.repo.Path)
+	if err != nil {
+		return nil, err
+	}
+	return bytes.NewBuffer(stdout), nil
+}

command.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"os/exec"
 	"strings"
+	"time"
 )
 
 // Command represents a command with its subcommands or arguments.
@@ -38,39 +39,79 @@ func (c *Command) AddArguments(args ...string) *Command {
 	return c
 }
 
-func (c *Command) run(dir string) (string, error) {
+const DEFAULT_TIMEOUT = 60 * time.Second
+
+// RunInDirTimeout executes the command in given directory with given timeout,
+// and returns stdout in []byte and error (combined with stderr).
+func (c *Command) RunInDirTimeout(timeout time.Duration, dir string) ([]byte, error) {
+	if timeout == -1 {
+		timeout = DEFAULT_TIMEOUT
+	}
+
 	stdout := new(bytes.Buffer)
 	stderr := new(bytes.Buffer)
 
+	if len(dir) == 0 {
+		log(c.String())
+	} else {
+		log("%s: %v", dir, c)
+	}
+
 	cmd := exec.Command(c.name, c.args...)
 	cmd.Dir = dir
 	cmd.Stdout = stdout
 	cmd.Stderr = stderr
+	if err := cmd.Start(); err != nil {
+		return nil, concatenateError(err, stderr.String())
+	}
 
-	if len(dir) == 0 {
-		log(c.String())
-	} else {
-		log("%s: %v", dir, c)
+	done := make(chan error)
+	go func() {
+		done <- cmd.Wait()
+	}()
+
+	var err error
+	select {
+	case <-time.After(timeout):
+		if cmd.Process != nil && cmd.ProcessState != nil && !cmd.ProcessState.Exited() {
+			if err := cmd.Process.Kill(); err != nil {
+				return nil, fmt.Errorf("fail to kill process: %v", err)
+			}
+		}
+
+		<-done
+		return nil, ErrExecTimeout{timeout}
+	case err = <-done:
 	}
 
-	if err := cmd.Run(); err != nil {
-		return stdout.String(), concatenateError(err, stderr.String())
+	if err != nil {
+		return nil, concatenateError(err, stderr.String())
 	}
+
 	if stdout.Len() > 0 {
 		log("stdout:\n%s", stdout)
 	}
-
-	return stdout.String(), nil
+	return stdout.Bytes(), nil
 }
 
-// Run executes the command in defualt working directory
-// and returns stdout and error (combined with stderr).
-func (c *Command) Run() (string, error) {
-	return c.run("")
+// RunInDir executes the command in given directory
+// and returns stdout in []byte and error (combined with stderr).
+func (c *Command) RunInDirBytes(dir string) ([]byte, error) {
+	return c.RunInDirTimeout(-1, dir)
 }
 
 // RunInDir executes the command in given directory
-// and returns stdout and error (combined with stderr).
+// and returns stdout in string and error (combined with stderr).
 func (c *Command) RunInDir(dir string) (string, error) {
-	return c.run(dir)
+	stdout, err := c.RunInDirTimeout(-1, dir)
+	if err != nil {
+		return "", err
+	}
+	return string(stdout), nil
+}
+
+// Run executes the command in defualt working directory
+// and returns stdout in string and error (combined with stderr).
+func (c *Command) Run() (string, error) {
+	return c.RunInDir("")
 }

commit.go

@@ -0,0 +1,67 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/mcuadros/go-version"
+)
+
+// Commit represents a git commit.
+type Commit struct {
+	Tree
+	ID            sha1 // The ID of this commit object
+	Author        *Signature
+	Committer     *Signature
+	CommitMessage string
+
+	parents []sha1 // SHA1 strings
+	// submodules map[string]*SubModule
+}
+
+// AddAllChanges marks local changes to be ready for commit.
+func AddChanges(repoPath string, all bool, files ...string) error {
+	cmd := NewCommand("add")
+	if all {
+		cmd.AddArguments("--all")
+	}
+	_, err := cmd.AddArguments(files...).RunInDir(repoPath)
+	return err
+}
+
+// CommitChanges commits local changes with given message and author.
+func CommitChanges(repoPath, message string, author *Signature) error {
+	cmd := NewCommand("commit", "-m", message)
+	if author != nil {
+		cmd.AddArguments(fmt.Sprintf("--author='%s <%s>'", author.Name, author.Email))
+	}
+	_, err := cmd.RunInDir(repoPath)
+
+	// No stderr but exit status 1 means nothing to commit.
+	if err != nil && err.Error() == "exit status 1" {
+		return nil
+	}
+	return err
+}
+
+// CommitsCount returns number of total commits of until given revision.
+func CommitsCount(repoPath, revision string) (int64, error) {
+	if version.Compare(gitVersion, "1.8.0", "<") {
+		stdout, err := NewCommand("log", "--pretty=format:''", revision).RunInDir(repoPath)
+		if err != nil {
+			return 0, err
+		}
+		return int64(len(strings.Split(stdout, "\n"))), nil
+	}
+
+	stdout, err := NewCommand("rev-list", "--count", revision).RunInDir(repoPath)
+	if err != nil {
+		return 0, err
+	}
+	return strconv.ParseInt(strings.TrimSpace(stdout), 10, 64)
+}

error.go

@@ -6,11 +6,32 @@ package git
 
 import (
 	"fmt"
+	"time"
 )
 
-func concatenateError(err error, stderr string) error {
-	if len(stderr) == 0 {
-		return err
-	}
-	return fmt.Errorf("%v - %s", err, stderr)
+type ErrExecTimeout struct {
+	Duration time.Duration
+}
+
+func IsErrExecTimeout(err error) bool {
+	_, ok := err.(ErrExecTimeout)
+	return ok
+}
+
+func (err ErrExecTimeout) Error() string {
+	return fmt.Sprintf("execution is timeout [duration: %v]", err.Duration)
+}
+
+type ErrNotExist struct {
+	ID      string
+	RelPath string
+}
+
+func IsErrNotExist(err error) bool {
+	_, ok := err.(ErrNotExist)
+	return ok
+}
+
+func (err ErrNotExist) Error() string {
+	return fmt.Sprintf("object does not exist [id: %s, rel_path: %s]", err.ID, err.RelPath)
 }

git.go

@@ -49,3 +49,7 @@ func Version() (string, error) {
 	gitVersion = fields[2]
 	return gitVersion, nil
 }
+
+func init() {
+	Version()
+}

repo.go

@@ -5,10 +5,43 @@
 package git
 
 import (
+	"bytes"
+	"container/list"
+	"errors"
 	"os"
+	"path"
+	"path/filepath"
 )
 
-// InitRepository initializes a new Git repository in choice of bare or not.
+// Repository represents a Git repository.
+type Repository struct {
+	Path string
+
+	commitCache map[sha1]*Commit
+}
+
+const _PRETTY_LOG_FORMAT = `--pretty=format:%H`
+
+func (repo *Repository) parsePrettyFormatLogToList(logs []byte) (*list.List, error) {
+	l := list.New()
+	if len(logs) == 0 {
+		return l, nil
+	}
+
+	parts := bytes.Split(logs, []byte{'\n'})
+
+	for _, commitId := range parts {
+		commit, err := repo.GetCommit(string(commitId))
+		if err != nil {
+			return nil, err
+		}
+		l.PushBack(commit)
+	}
+
+	return l, nil
+}
+
+// InitRepository initializes a new Git repository.
 func InitRepository(repoPath string, bare bool) error {
 	os.MkdirAll(repoPath, os.ModePerm)
 
@@ -19,3 +52,50 @@ func InitRepository(repoPath string, bare bool) error {
 	_, err := cmd.RunInDir(repoPath)
 	return err
 }
+
+// OpenRepository opens the repository at the given path.
+func OpenRepository(repoPath string) (*Repository, error) {
+	repoPath, err := filepath.Abs(repoPath)
+	if err != nil {
+		return nil, err
+	} else if !isDir(repoPath) {
+		return nil, errors.New("no such file or directory")
+	}
+
+	return &Repository{Path: repoPath}, nil
+}
+
+// Clone clones original repository to target path.
+func Clone(from, to string) error {
+	toDir := path.Dir(to)
+	os.MkdirAll(toDir, os.ModePerm)
+
+	_, err := NewCommand("clone", from, to).Run()
+	return err
+}
+
+// Pull pulls changes from remotes.
+func Pull(repoPath string, all bool) error {
+	cmd := NewCommand("pull")
+	if all {
+		cmd.AddArguments("--all")
+	}
+	_, err := cmd.RunInDir(repoPath)
+	return err
+}
+
+// Push pushs local commits to given remote branch.
+func Push(repoPath, remote, branch string) error {
+	_, err := NewCommand("push", remote, branch).RunInDir(repoPath)
+	return err
+}
+
+// Reset resets HEAD to given revision or head of branch.
+func Reset(repoPath string, hard bool, revision string) error {
+	cmd := NewCommand("reset")
+	if hard {
+		cmd.AddArguments("--hard")
+	}
+	_, err := cmd.AddArguments(revision).RunInDir(repoPath)
+	return err
+}

repo_branch.go

@@ -0,0 +1,42 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"fmt"
+	"strings"
+)
+
+const BRANCH_PREFIX = "refs/heads/"
+
+// Branch represents a Git branch.
+type Branch struct {
+	Name string
+	Path string
+}
+
+// GetHEADBranch returns corresponding branch of HEAD.
+func (repo *Repository) GetHEADBranch() (*Branch, error) {
+	stdout, err := NewCommand("symbolic-ref", "HEAD").RunInDir(repo.Path)
+	if err != nil {
+		return nil, err
+	}
+	stdout = strings.TrimSpace(stdout)
+
+	if !strings.HasPrefix(stdout, BRANCH_PREFIX) {
+		return nil, fmt.Errorf("invalid HEAD branch: %v", stdout)
+	}
+
+	return &Branch{
+		Name: stdout[len(BRANCH_PREFIX):],
+		Path: stdout,
+	}, nil
+}
+
+// IsBranchExist returns true if given branch exists in repository.
+func IsBranchExist(repoPath, branch string) bool {
+	_, err := NewCommand("show-ref", "--verify", BRANCH_PREFIX+branch).RunInDir(repoPath)
+	return err == nil
+}