func (s *AdvRefsDecodeEncodeSuite) test(c *C, in []string, exp []string) {
var err error
var input io.Reader
{
var buf bytes.Buffer
p := pktline.NewEncoder(&buf)
err = p.EncodeString(in...)
c.Assert(err, IsNil)
input = &buf
}
var expected []byte
{
var buf bytes.Buffer
p := pktline.NewEncoder(&buf)
err = p.EncodeString(exp...)
c.Assert(err, IsNil)
expected = buf.Bytes()
}
var obtained []byte
{
ar := NewAdvRefs()
c.Assert(ar.Decode(input), IsNil)
var buf bytes.Buffer
c.Assert(ar.Encode(&buf), IsNil)
obtained = buf.Bytes()
}
c.Assert(string(obtained), DeepEquals, string(expected))
}
// Encode writes the ReferenceUpdateRequest encoding to the stream.
func (r *ReferenceUpdateRequest) Encode(w io.Writer) error {
if err := r.validate(); err != nil {
return err
}
e := pktline.NewEncoder(w)
if err := r.encodeShallow(e, r.Shallow); err != nil {
return err
}
if err := r.encodeCommands(e, r.Commands, r.Capabilities); err != nil {
return err
}
if r.Packfile != nil {
if _, err := io.Copy(w, r.Packfile); err != nil {
return err
}
return r.Packfile.Close()
}
return nil
}
func (s *AdvRefsDecodeSuite) TestEmptyFlush(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
e.Flush()
ar := NewAdvRefs()
c.Assert(ar.Decode(&buf), Equals, ErrEmptyAdvRefs)
}
func (s *SuiteScanner) TestScanAndPayload(c *C) {
for _, test := range [...]string{
"a",
"a\n",
strings.Repeat("a", 100),
strings.Repeat("a", 100) + "\n",
strings.Repeat("\x00", 100),
strings.Repeat("\x00", 100) + "\n",
strings.Repeat("a", pktline.MaxPayloadSize),
strings.Repeat("a", pktline.MaxPayloadSize-1) + "\n",
} {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(test)
c.Assert(err, IsNil,
Commentf("input len=%x, contents=%.10q\n", len(test), test))
sc := pktline.NewScanner(&buf)
c.Assert(sc.Scan(), Equals, true,
Commentf("test = %.20q...", test))
obtained := sc.Bytes()
c.Assert(obtained, DeepEquals, []byte(test),
Commentf("in = %.20q out = %.20q", test, string(obtained)))
}
}
// Encode encodes the UploadHaves into the Writer.
func (u *UploadHaves) Encode(w io.Writer) error {
e := pktline.NewEncoder(w)
plumbing.HashesSort(u.Haves)
var last plumbing.Hash
for _, have := range u.Haves {
if bytes.Compare(last[:], have[:]) == 0 {
continue
}
if err := e.Encodef("have %s\n", have); err != nil {
return fmt.Errorf("sending haves for %q: %s", have, err)
}
last = have
}
if len(u.Haves) != 0 {
if err := e.Flush(); err != nil {
return fmt.Errorf("sending flush-pkt after haves: %s", err)
}
}
return nil
}
func ExampleEncoder() {
// Create an encoder that writes pktlines to stdout.
e := pktline.NewEncoder(os.Stdout)
// Encode some data as a new pkt-line.
_ = e.Encode([]byte("data\n")) // error checks removed for brevity
// Encode a flush-pkt.
_ = e.Flush()
// Encode a couple of byte slices and a flush in one go. Each of
// them will end up as payloads of their own pktlines.
_ = e.Encode(
[]byte("hello\n"),
[]byte("world!\n"),
pktline.Flush,
)
// You can also encode strings:
_ = e.EncodeString(
"foo\n",
"bar\n",
pktline.FlushString,
)
// You can also format and encode a payload:
_ = e.Encodef(" %s %d\n", "foo", 42)
// Output:
// 0009data
// 0000000ahello
// 000bworld!
// 00000008foo
// 0008bar
// 0000000c foo 42
}
func (s *SuiteEncoder) TestEncode(c *C) {
for i, test := range [...]struct {
input [][]byte
expected []byte
}{
{
input: [][]byte{
[]byte("hello\n"),
},
expected: []byte("000ahello\n"),
}, {
input: [][]byte{
[]byte("hello\n"),
pktline.Flush,
},
expected: []byte("000ahello\n0000"),
}, {
input: [][]byte{
[]byte("hello\n"),
[]byte("world!\n"),
[]byte("foo"),
},
expected: []byte("000ahello\n000bworld!\n0007foo"),
}, {
input: [][]byte{
[]byte("hello\n"),
pktline.Flush,
[]byte("world!\n"),
[]byte("foo"),
pktline.Flush,
},
expected: []byte("000ahello\n0000000bworld!\n0007foo0000"),
}, {
input: [][]byte{
[]byte(strings.Repeat("a", pktline.MaxPayloadSize)),
},
expected: []byte(
"fff0" + strings.Repeat("a", pktline.MaxPayloadSize)),
}, {
input: [][]byte{
[]byte(strings.Repeat("a", pktline.MaxPayloadSize)),
[]byte(strings.Repeat("b", pktline.MaxPayloadSize)),
},
expected: []byte(
"fff0" + strings.Repeat("a", pktline.MaxPayloadSize) +
"fff0" + strings.Repeat("b", pktline.MaxPayloadSize)),
},
} {
comment := Commentf("input %d = %v\n", i, test.input)
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Encode(test.input...)
c.Assert(err, IsNil, comment)
c.Assert(buf.Bytes(), DeepEquals, test.expected, comment)
}
}
func (s *CommandStatus) encode(w io.Writer) error {
e := pktline.NewEncoder(w)
if s.Error() == nil {
return e.Encodef("ok %s\n", s.ReferenceName.String())
}
return e.Encodef("ng %s %s\n", s.ReferenceName.String(), s.Status)
}
func toPktLines(c *C, payloads []string) io.Reader {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil)
return &buf
}
func (s *AdvRefsDecodeSuite) TestEmptyPrefixFlush(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
e.EncodeString("# service=git-upload-pack")
e.Flush()
e.Flush()
ar := NewAdvRefs()
c.Assert(ar.Decode(&buf), Equals, ErrEmptyAdvRefs)
}
// returns a byte slice with the pkt-lines for the given payloads.
func pktlines(c *C, payloads ...string) []byte {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil, Commentf("building pktlines for %v\n", payloads))
return buf.Bytes()
}
func (s *SuiteEncoder) TestFlush(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Flush()
c.Assert(err, IsNil)
obtained := buf.Bytes()
c.Assert(obtained, DeepEquals, pktline.FlushPkt)
}
func (s *AdvRefsDecodeSuite) testDecodeOK(c *C, payloads []string) *AdvRefs {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil)
ar := NewAdvRefs()
c.Assert(ar.Decode(&buf), IsNil)
return ar
}
// NewMuxer returns a new Muxer for the given t that writes on w.
//
// If t is equal to `Sideband` the max pack size is set to MaxPackedSize, in any
// other value is given, max pack is set to MaxPackedSize64k, that is the
// maximum length of a line in pktline format.
func NewMuxer(t Type, w io.Writer) *Muxer {
max := MaxPackedSize64k
if t == Sideband {
max = MaxPackedSize
}
return &Muxer{
max: max - chLen,
e: pktline.NewEncoder(w),
}
}
func (s *SuiteScanner) TestEOF(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString("first", "second")
c.Assert(err, IsNil)
sc := pktline.NewScanner(&buf)
for sc.Scan() {
}
c.Assert(sc.Err(), IsNil)
}
func (s *UpdReqDecodeSuite) testDecodeOK(c *C, payloads []string) *ReferenceUpdateRequest {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil)
r := NewReferenceUpdateRequest()
c.Assert(r.Decode(&buf), IsNil)
return r
}
func (s *SidebandSuite) TestDecodeErrMaxPacked(c *C) {
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(bytes.Repeat([]byte{'0'}, MaxPackedSize+1)))
content := make([]byte, 13)
d := NewDemuxer(Sideband, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, Equals, ErrMaxPackedExceeded)
c.Assert(n, Equals, 0)
}
func (s *SidebandSuite) TestDecodeWithUnknownChannel(c *C) {
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode([]byte{'4', 'F', 'O', 'O', '\n'})
content := make([]byte, 26)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, ErrorMatches, "unknown channel 4FOO\n")
c.Assert(n, Equals, 0)
}
func (s *SuiteScanner) TestFlush(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Flush()
c.Assert(err, IsNil)
sc := pktline.NewScanner(&buf)
c.Assert(sc.Scan(), Equals, true)
payload := sc.Bytes()
c.Assert(len(payload), Equals, 0)
}
func (s *UlReqDecodeSuite) testDecodeOK(c *C, payloads []string) *UploadRequest {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil)
ur := NewUploadRequest()
d := newUlReqDecoder(&buf)
err = d.Decode(ur)
c.Assert(err, IsNil)
return ur
}
// Encode writes the report status to a writer.
func (s *ReportStatus) Encode(w io.Writer) error {
e := pktline.NewEncoder(w)
if err := e.Encodef("unpack %s\n", s.UnpackStatus); err != nil {
return err
}
for _, cs := range s.CommandStatuses {
if err := cs.encode(w); err != nil {
return err
}
}
return e.Flush()
}
func (s *SidebandSuite) TestDecodeMoreThanContain(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(expected))
content := make([]byte, 42)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, Equals, io.ErrUnexpectedEOF)
c.Assert(n, Equals, 26)
c.Assert(content[0:26], DeepEquals, expected)
}
func (s *SuiteEncoder) TestEncodef(c *C) {
format := " %s %d\n"
str := "foo"
d := 42
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Encodef(format, str, d)
c.Assert(err, IsNil)
expected := []byte("000c foo 42\n")
c.Assert(buf.Bytes(), DeepEquals, expected)
}
func uploadPackRequestToReader(req *packp.UploadPackRequest) (*bytes.Buffer, error) {
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
if err := req.UploadRequest.Encode(buf); err != nil {
return nil, fmt.Errorf("sending upload-req message: %s", err)
}
if err := req.UploadHaves.Encode(buf); err != nil {
return nil, fmt.Errorf("sending haves message: %s", err)
}
_ = e.EncodeString("done\n")
return buf, nil
}
func (s *SidebandSuite) TestDecodeWithError(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(expected[0:8]))
e.Encode(ErrorMessage.WithPayload([]byte{'F', 'O', 'O', '\n'}))
e.Encode(PackData.WithPayload(expected[8:16]))
e.Encode(PackData.WithPayload(expected[16:26]))
content := make([]byte, 26)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, ErrorMatches, "unexpected error: FOO\n")
c.Assert(n, Equals, 8)
c.Assert(content[0:8], DeepEquals, expected[0:8])
}
// returns nSection sections, each of them with nLines pkt-lines (not
// counting the flush-pkt:
//
// 0009 0.0\n
// 0009 0.1\n
// ...
// 0000
// and so on
func sectionsExample(c *C, nSections, nLines int) io.Reader {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
for section := 0; section < nSections; section++ {
ss := []string{}
for line := 0; line < nLines; line++ {
line := fmt.Sprintf(" %d.%d\n", section, line)
ss = append(ss, line)
}
err := e.EncodeString(ss...)
c.Assert(err, IsNil)
err = e.Flush()
c.Assert(err, IsNil)
}
return &buf
}
func (s *SuiteScanner) TestSkip(c *C) {
for _, test := range [...]struct {
input []string
n int
expected []byte
}{
{
input: []string{
"first",
"second",
"third"},
n: 1,
expected: []byte("second"),
},
{
input: []string{
"first",
"second",
"third"},
n: 2,
expected: []byte("third"),
},
} {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(test.input...)
c.Assert(err, IsNil)
sc := pktline.NewScanner(&buf)
for i := 0; i < test.n; i++ {
c.Assert(sc.Scan(), Equals, true,
Commentf("scan error = %s", sc.Err()))
}
c.Assert(sc.Scan(), Equals, true,
Commentf("scan error = %s", sc.Err()))
obtained := sc.Bytes()
c.Assert(obtained, DeepEquals, test.expected,
Commentf("\nin = %.20q\nout = %.20q\nexp = %.20q",
test.input, obtained, test.expected))
}
}
func (s *SidebandSuite) TestDecodeWithPending(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(expected[0:8]))
e.Encode(PackData.WithPayload(expected[8:16]))
e.Encode(PackData.WithPayload(expected[16:26]))
content := make([]byte, 13)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, IsNil)
c.Assert(n, Equals, 13)
c.Assert(content, DeepEquals, expected[0:13])
n, err = d.Read(content)
c.Assert(err, IsNil)
c.Assert(n, Equals, 13)
c.Assert(content, DeepEquals, expected[13:26])
}
func (s *UpdReqDecodeSuite) TestWithPackfile(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
expected := NewReferenceUpdateRequest()
expected.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
packfileContent := []byte("PACKabc")
expected.Packfile = ioutil.NopCloser(bytes.NewReader(packfileContent))
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
c.Assert(e.EncodeString(payloads...), IsNil)
buf.Write(packfileContent)
s.testDecodeOkRaw(c, expected, buf.Bytes())
}
func (s *SidebandSuite) TestDecodeWithProgress(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(expected[0:8]))
e.Encode(ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'}))
e.Encode(PackData.WithPayload(expected[8:16]))
e.Encode(PackData.WithPayload(expected[16:26]))
content := make([]byte, 26)
d := NewDemuxer(Sideband64k, buf)
d.Progress = bytes.NewBuffer(nil)
n, err := io.ReadFull(d, content)
c.Assert(err, IsNil)
c.Assert(n, Equals, 26)
c.Assert(content, DeepEquals, expected)
progress, err := ioutil.ReadAll(d.Progress)
c.Assert(err, IsNil)
c.Assert(progress, DeepEquals, []byte{'F', 'O', 'O', '\n'})
}