protocol/packp: UploadPackResponse implementation (#161)

* plumbing/protocol: paktp avoid duplication of haves, wants and shallow

* protocol/pakp: UploadPackResponse implementation

* changes

* changes

* changes

* debug

* changes

Author: mcuadros

fixtures/fixtures.go

@@ -3,6 +3,7 @@ package fixtures
 import (
 	"fmt"
 	"go/build"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 
@@ -195,6 +196,25 @@ func (f *Fixture) DotGit() fs.Filesystem {
 	return osfs.New(path)
 }
 
+func (f *Fixture) Worktree() fs.Filesystem {
+	fn := filepath.Join(RootFolder, DataFolder, fmt.Sprintf("git-%s.tgz", f.DotGitHash))
+	git, err := tgz.Extract(fn)
+	if err != nil {
+		panic(err)
+	}
+
+	worktree, err := ioutil.TempDir("", "worktree")
+	if err != nil {
+		panic(err)
+	}
+
+	if err := os.Rename(git, filepath.Join(worktree, ".git")); err != nil {
+		panic(err)
+	}
+
+	return osfs.New(worktree)
+}
+
 type Fixtures []*Fixture
 
 func (g Fixtures) Test(c *check.C, test func(*Fixture)) {

plumbing/protocol/packp/common.go

@@ -17,19 +17,26 @@ var (
 	eol = []byte("\n")
 	eq  = []byte{'='}
 
-	// advrefs
+	// advertised-refs
 	null       = []byte("\x00")
 	peeled     = []byte("^{}")
 	noHeadMark = []byte(" capabilities^{}\x00")
 
-	// ulreq
+	// upload-request
 	want            = []byte("want ")
 	shallow         = []byte("shallow ")
 	deepen          = []byte("deepen")
 	deepenCommits   = []byte("deepen ")
 	deepenSince     = []byte("deepen-since ")
 	deepenReference = []byte("deepen-not ")
 
+	// shallow-update
+	unshallow = []byte("unshallow ")
+
+	// server-response
+	ack = []byte("ACK")
+	nak = []byte("NAK")
+
 	// updreq
 	shallowNoSp = []byte("shallow")
 )

plumbing/protocol/packp/shallowupd.go

@@ -0,0 +1,73 @@
+package packp
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
+)
+
+const (
+	shallowLineLen   = 48
+	unshallowLineLen = 50
+)
+
+type ShallowUpdate struct {
+	Shallows   []plumbing.Hash
+	Unshallows []plumbing.Hash
+}
+
+func (r *ShallowUpdate) Decode(reader io.Reader) error {
+	s := pktline.NewScanner(reader)
+
+	for s.Scan() {
+		line := s.Bytes()
+
+		var err error
+		switch {
+		case bytes.HasPrefix(line, shallow):
+			err = r.decodeShallowLine(line)
+		case bytes.HasPrefix(line, unshallow):
+			err = r.decodeUnshallowLine(line)
+		case bytes.Compare(line, pktline.Flush) == 0:
+			return nil
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return s.Err()
+}
+
+func (r *ShallowUpdate) decodeShallowLine(line []byte) error {
+	hash, err := r.decodeLine(line, shallow, shallowLineLen)
+	if err != nil {
+		return err
+	}
+
+	r.Shallows = append(r.Shallows, hash)
+	return nil
+}
+
+func (r *ShallowUpdate) decodeUnshallowLine(line []byte) error {
+	hash, err := r.decodeLine(line, unshallow, unshallowLineLen)
+	if err != nil {
+		return err
+	}
+
+	r.Unshallows = append(r.Unshallows, hash)
+	return nil
+}
+
+func (r *ShallowUpdate) decodeLine(line, prefix []byte, expLen int) (plumbing.Hash, error) {
+	if len(line) != expLen {
+		return plumbing.ZeroHash, fmt.Errorf("malformed %s%q", prefix, line)
+	}
+
+	raw := string(line[expLen-40 : expLen])
+	return plumbing.NewHash(raw), nil
+}

plumbing/protocol/packp/shallowupd_test.go

@@ -0,0 +1,63 @@
+package packp
+
+import (
+	"bytes"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+
+	. "gopkg.in/check.v1"
+)
+
+type ShallowUpdateSuite struct{}
+
+var _ = Suite(&ShallowUpdateSuite{})
+
+func (s *ShallowUpdateSuite) TestDecode(c *C) {
+	raw := "" +
+		"0034shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+		"0034shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" +
+		"0000"
+
+	su := &ShallowUpdate{}
+	err := su.Decode(bytes.NewBufferString(raw))
+	c.Assert(err, IsNil)
+
+	plumbing.HashesSort(su.Shallows)
+
+	c.Assert(su.Unshallows, HasLen, 0)
+	c.Assert(su.Shallows, HasLen, 2)
+	c.Assert(su.Shallows, DeepEquals, []plumbing.Hash{
+		plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+		plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
+	})
+}
+
+func (s *ShallowUpdateSuite) TestDecodeUnshallow(c *C) {
+	raw := "" +
+		"0036unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+		"0036unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" +
+		"0000"
+
+	su := &ShallowUpdate{}
+	err := su.Decode(bytes.NewBufferString(raw))
+	c.Assert(err, IsNil)
+
+	plumbing.HashesSort(su.Unshallows)
+
+	c.Assert(su.Shallows, HasLen, 0)
+	c.Assert(su.Unshallows, HasLen, 2)
+	c.Assert(su.Unshallows, DeepEquals, []plumbing.Hash{
+		plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+		plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
+	})
+}
+
+func (s *ShallowUpdateSuite) TestDecodeMalformed(c *C) {
+	raw := "" +
+		"0035unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
+		"0000"
+
+	su := &ShallowUpdate{}
+	err := su.Decode(bytes.NewBufferString(raw))
+	c.Assert(err, NotNil)
+}

plumbing/protocol/packp/srvresp.go

@@ -0,0 +1,70 @@
+package packp
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
+)
+
+const ackLineLen = 44
+
+// ServerResponse object acknowledgement from upload-pack service
+// TODO: implement support for multi_ack or multi_ack_detailed responses
+type ServerResponse struct {
+	ACKs []plumbing.Hash
+}
+
+// Decode decodes the response into the struct, isMultiACK should be true, if
+// the request was done with multi_ack or multi_ack_detailed capabilities
+func (r *ServerResponse) Decode(reader io.Reader, isMultiACK bool) error {
+	if isMultiACK {
+		return errors.New("multi_ack and multi_ack_detailed are not supported")
+	}
+
+	s := pktline.NewScanner(reader)
+
+	for s.Scan() {
+		line := s.Bytes()
+
+		if err := r.decodeLine(line); err != nil {
+			return err
+		}
+
+		if !isMultiACK {
+			break
+		}
+	}
+
+	return s.Err()
+}
+
+func (r *ServerResponse) decodeLine(line []byte) error {
+	if len(line) == 0 {
+		return fmt.Errorf("unexpected flush")
+	}
+
+	if bytes.Compare(line[0:3], ack) == 0 {
+		return r.decodeACKLine(line)
+	}
+
+	if bytes.Compare(line[0:3], nak) == 0 {
+		return nil
+	}
+
+	return fmt.Errorf("unexpected content %q", string(line))
+}
+
+func (r *ServerResponse) decodeACKLine(line []byte) error {
+	if len(line) < ackLineLen {
+		return fmt.Errorf("malformed ACK %q", line)
+	}
+
+	sp := bytes.Index(line, []byte(" "))
+	h := plumbing.NewHash(string(line[sp+1 : sp+41]))
+	r.ACKs = append(r.ACKs, h)
+	return nil
+}

plumbing/protocol/packp/srvresp_test.go

@@ -0,0 +1,48 @@
+package packp
+
+import (
+	"bytes"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+
+	. "gopkg.in/check.v1"
+)
+
+type ServerResponseSuite struct{}
+
+var _ = Suite(&ServerResponseSuite{})
+
+func (s *ServerResponseSuite) TestDecodeNAK(c *C) {
+	raw := "0008NAK\n"
+
+	sr := &ServerResponse{}
+	err := sr.Decode(bytes.NewBufferString(raw), false)
+	c.Assert(err, IsNil)
+
+	c.Assert(sr.ACKs, HasLen, 0)
+}
+
+func (s *ServerResponseSuite) TestDecodeACK(c *C) {
+	raw := "0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n"
+
+	sr := &ServerResponse{}
+	err := sr.Decode(bytes.NewBufferString(raw), false)
+	c.Assert(err, IsNil)
+
+	c.Assert(sr.ACKs, HasLen, 1)
+	c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
+}
+
+func (s *ServerResponseSuite) TestDecodeMalformed(c *C) {
+	raw := "0029ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e\n"
+
+	sr := &ServerResponse{}
+	err := sr.Decode(bytes.NewBufferString(raw), false)
+	c.Assert(err, NotNil)
+}
+
+func (s *ServerResponseSuite) TestDecodeMultiACK(c *C) {
+	sr := &ServerResponse{}
+	err := sr.Decode(bytes.NewBuffer(nil), true)
+	c.Assert(err, NotNil)
+}

plumbing/protocol/packp/ulreq.go

@@ -25,6 +25,7 @@ type UploadRequest struct {
 // DepthCommit, DepthSince and DepthReference.
 type Depth interface {
 	isDepth()
+	IsZero() bool
 }
 
 // DepthCommits values stores the maximum number of requested commits in
@@ -34,16 +35,28 @@ type DepthCommits int
 
 func (d DepthCommits) isDepth() {}
 
+func (d DepthCommits) IsZero() bool {
+	return d == 0
+}
+
 // DepthSince values requests only commits newer than the specified time.
 type DepthSince time.Time
 
 func (d DepthSince) isDepth() {}
 
+func (d DepthSince) IsZero() bool {
+	return time.Time(d).IsZero()
+}
+
 // DepthReference requests only commits not to found in the specified reference.
 type DepthReference string
 
 func (d DepthReference) isDepth() {}
 
+func (d DepthReference) IsZero() bool {
+	return string(d) == ""
+}
+
 // NewUploadRequest returns a pointer to a new UploadRequest value, ready to be
 // used. It has no capabilities, wants or shallows and an infinite depth. Please
 // note that to encode an upload-request it has to have at least one wanted hash.

plumbing/protocol/packp/ulreq_encode_test.go

@@ -6,9 +6,9 @@ import (
 
 	"gopkg.in/src-d/go-git.v4/plumbing"
 	"gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
+	"gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
 
 	. "gopkg.in/check.v1"
-	"gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
 )
 
 type UlReqEncodeSuite struct{}