Drover's back, baby!

go/src/infra/libs/git/repo/repo.go

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package repo
+
+import (
+        "bufio"
+        "bytes"
+        "fmt"
+        "io"
+        "os/exec"
+        "strconv"
+        "strings"
+
+        "infra/libs/infra_util"
+
+        . "infra/libs/git"
+)
+
+// Types ///////////////////////////////////////////////////////////////////////
+
+// Repo represents a local git repository at the path |Path|.
+type Repo struct {
+        // The path on disk to the location of the git repo.
+        path string
+
+        catFile      catFileService
+        catFileCheck catFileService
+}
+
+// Constructors  ///////////////////////////////////////////////////////////////
+
+func NewRepo(path string) *Repo {
+        return &Repo{path,
+                newCatFileService(path, false),
+                newCatFileService(path, true),
+        }
+}
+
+// Member functions ////////////////////////////////////////////////////////////
+
+func (r *Repo) Path() string { return r.path }
+
+// RunInput runs a git command in the Repo, passing input on stdin, and returning
+// the stdout and success (i.e.  did the git command return 0?)
+func (r *Repo) RunInput(input string, cmd ...string) (string, bool) {
+        ex := exec.Command("git", cmd...)
+        ex.Dir = r.Path()
+        ex.Stdin = bytes.NewBufferString(input)
+        out, err := ex.Output()
+        if err == nil {
+                return string(out), true
+        } else if _, ok := err.(*exec.ExitError); ok {
+                return string(out), false
+        } else {
+                panic(err)
+        }
+}
+
+// Run runs a git command in the Repo, with no input, returning the stdout and
+// success.
+func (r *Repo) Run(cmd ...string) (string, bool) {
+        return r.RunInput("", cmd...)
+}
+
+// RunOk runs a git command in the repo with no input, and returns its success
+// (did it exit 0?)
+func (r *Repo) RunOk(cmd ...string) bool {
+        _, ok := r.Run(cmd...)
+        return ok
+}
+
+// MustRunOk is the same as RunOutput, but it panic's if the command fails
+func (r *Repo) MustRunOk(cmd ...string) {
+        _, ok := r.Run(cmd...)
+        if !ok {
+                panic(fmt.Errorf("in (%s) faild to run %v", r.path, append([]string{"git"}, cmd...)))
+        }
+}
+
+// RunOutput runs a git command in the repo with no input, and returns its
+// stdout
+func (r *Repo) RunOutput(cmd ...string) string {
+        out, _ := r.Run(cmd...)
+        return out
+}
+
+// RunOutputS is the same as RunOutput, except it strips the trailing newline
+func (r *Repo) RunOutputS(cmd ...string) string {
+        out, _ := r.Run(cmd...)
+        return strings.TrimRight(out, "\n")
+}
+
+// MustRunOutput is the same as RunOutput, but it panic's if the command fails
+func (r *Repo) MustRunOutput(cmd ...string) string {
+        out, ok := r.Run(cmd...)
+        if !ok {
+                panic(fmt.Errorf("in (%s) faild to run %v", r.path, append([]string{"git"}, cmd...)))
+        }
+        return out
+}
+
+// GetObject retrieves a real representation of objectish.
+//
+// This may return MissingError if the object is not found.
+func (r *Repo) GetObject(objectish string) (InternableObject, error) {
+        rsp := r.catFile.request(objectish)
+        if rsp == nil {
+                return nil, nil
+        }
+        return ObjectFromRawWithID(rsp.id, rsp.typ, rsp.data)
+}
+
+func (r *Repo) GetObjectID(id Identifiable) (InternableObject, error) {
+        return r.GetObject(id.ID().String())
+}
+
+func (r *Repo) ObjectInfo(objectish string) *ObjectInfo {
+        rslt := r.catFileCheck.request(objectish)
+        if rslt != nil {
+                return &ObjectInfo{rslt.typ, rslt.size, rslt.id}
+        } else {
+                return nil
+        }
+}
+
+func (r *Repo) ObjectInfoID(id Identifiable) *ObjectInfo {
+        return r.ObjectInfo(id.ID().String())
+}
+
+func (r *Repo) HasObject(objectish string) bool {
+        return r.ObjectInfo(objectish) != nil
+}
+
+func (r *Repo) HasObjectID(id Identifiable) bool {
+        return r.ObjectInfoID(id) != nil
+}
+
+func (r *Repo) GetTextDiff(left, right string) (string, error) {
+        rslt, ok := r.Run("diff", left, right)
+        if !ok {
+                return "", fmt.Errorf("cannot diff(%s, %s): %s", left, right, rslt)
+        }
+        return rslt, nil
+}
+
+// DiffTree computes the 2-tree diff (with copy/rename detection) and returns
+// a parsed TreeDiff of what it found.
+//
+// This diff-tree invocation is done with -t, which implies that it is recursive,
+// and that the actual intermediate tree objects will also be contianed in the
+// return value.
+func (r *Repo) DiffTree(left, right string) (ret TreeDiff, err error) {
+        atoi := func(s string, base int) int {
+                ret, err := strconv.ParseInt(s, base, 0)
+                if err != nil {
+                        panic(err)
+                }
+                return int(ret)
+        }
+
+        lines := strings.Split(strings.TrimRight(
+                r.RunOutput("diff-tree", "-t", "-z", "-M", "-M", "-C", left, right), "\000"),
+                "\000")
+
+        infoStream := make(chan string, len(lines))
+        for _, line := range lines {
+                infoStream <- line
+        }
+        close(infoStream)
+        for header := range infoStream {
+                if len(header) == 0 {
+                        break
+                }
+                if header[0] != ':' {
+                        return nil, fmt.Errorf("git.DiffTree: desynchronized parsing error")
+                }
+                info := strings.Fields(strings.TrimLeft(header, ":"))
+                // old_mode new_mode old_id new_id action
+                // oldPath (if action[0] in "RC")
+                // newPath
+                action := info[4]
+                similarity := 0
+                oldPath := <-infoStream
+                newPath := oldPath
+                if action[0] == 'R' || action[0] == 'C' {
+                        newPath = <-infoStream
+                        similarity = atoi(action[1:], 10)
+                }
+
+                old_id, err := MakeObjectIDErr(info[2])
+                if err != nil {
+                        return nil, err
+                }
+                old_c, err := NewEmptyChild(Mode(atoi(info[0], 8)), old_id)
+                if err != nil {
+                        return nil, err
+                }
+
+                new_id, err := MakeObjectIDErr(info[3])
+                if err != nil {
+                        return nil, err
+                }
+                new_c, err := NewEmptyChild(Mode(atoi(info[1], 8)), new_id)
+                if err != nil {
+                        return nil, err
+                }
+
+                ret = append(ret, TreeDiffEntry{
+                        Action:     action,
+                        Similarity: similarity,
+                        Old: TreeDiffEntryHalf{
+                                *old_c,
+                                oldPath,
+                        },
+                        New: TreeDiffEntryHalf{
+                                *new_c,
+                                newPath,
+                        },
+                })
+        }
+
+        return
+}
+
+// Intern takes an InternableObject (Blob, Tree, Commit), and writes it into
+// the on-disk Repo.
+func (r *Repo) Intern(obj InternableObject) (*ObjectID, error) {
+        return InternImpl(r, obj, func(data string) (string, error) {
+                cmd := []string{"hash-object", "-t", obj.Type().String(), "-w", "--stdin"}
+                out, ok := r.RunInput(data, cmd...)
+                if !ok {
+                        return "", fmt.Errorf("error running %s <- %s: not ok", cmd, data)
+                }
+                return string(out), nil
+        })
+}
+
+/// Private
+
+type catFileService struct {
+        path string
+        ch   chan<- catFileRequest
+}
+
+type catFileRequest struct {
+        objectish string
+        reply     chan<- *catFileReply
+}
+
+type catFileReply struct {
+        id   *ObjectID
+        typ  ObjectType
+        size int
+        data []byte
+}
+
+func (c *catFileService) request(objectish string) *catFileReply {
+        if strings.ContainsAny(objectish, "\n") {
+                // These requests are generated internally from the library. The caller
+                // should check or recover if they think that objectish can contain
+                // a newline.
+                panic(fmt.Errorf("catFile request may not contain a newline"))
+        }
+
+        rchan := make(chan *catFileReply, 1)
+        c.ch <- catFileRequest{objectish, rchan}
+        return <-rchan
+}
+
+func newCatFileService(path string, checkOnly bool) catFileService {
+        ch := make(chan catFileRequest)
+        batchMode := "--batch"
+        if checkOnly {
+                batchMode = "--batch-check"
+        }
+        go func() {
+                var err error
+                var in io.WriteCloser
+                var nom func(byte) string
+                var yoink func(int) []byte
+                var out *bufio.Reader
+
+                started := false
+                for req := range ch {
+                        if !started {
+                                started = true
+                                catFile := exec.Command("git", "cat-file", batchMode)
+                                catFile.Dir = path
+
+                                in, err = catFile.StdinPipe()
+                                if err != nil {
+                                        panic(err)
+                                }
+                                defer in.Close()
+
+                                outRaw, err := catFile.StdoutPipe()
+                                if err != nil {
+                                        panic(err)
+                                }
+                                defer outRaw.Close()
+
+                                if err = catFile.Start(); err != nil {
+                                        panic(err)
+                                }
+
+                                out = bufio.NewReader(outRaw)
+                                nom = infra_util.Nom(out)
+                                yoink = infra_util.Yoink(out)
+                        }
+
+                        func() {
+                                defer close(req.reply)
+                                in.Write([]byte(req.objectish + "\n"))
+                                rsp := nom('\n')
+                                if strings.HasSuffix(rsp, " missing") {
+                                        req.reply <- nil
+                                        return
+                                }
+
+                                parts := strings.Split(rsp, " ")
+                                objID, typ, sizeStr := parts[0], parts[1], parts[2]
+                                size, err := strconv.ParseUint(sizeStr, 10, 64)
+                                if err != nil {
+                                        panic(err) // git itself returned a non-integer size field!?
+                                }
+
+                                data := []byte{}
+                                if !checkOnly {
+                                        data = yoink(int(size))
+                                        out.ReadByte() // drop extra newline
+                                }
+                                req.reply <- &catFileReply{
+                                        id:   MakeObjectID(objID),
+                                        typ:  MakeObjectType(typ),
+                                        data: data,
+                                        size: int(size),
+                                }
+                        }()
+                }
+        }()
+
+        return catFileService{path, ch}
+}