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'}) }