Merge pull request #4 from marten-seemann/encoder

implement the simplest possible encoder

Author: marten-seemann

.circleci/config.yml

@@ -22,7 +22,7 @@ jobs:
           command: ginkgo -race -cover -v -randomizeAllSpecs
       - run:
           name: "Run integration tests"
-          command: ginkgo -race -v -randomizeAllSpecs -trace integrationtests
+          command: ginkgo -r -race -v -randomizeAllSpecs -trace integrationtests
       - run:
           name: "Upload coverage report to Codecov"
           when: on_success

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "integrationtests/qifs"]
-	path = integrationtests/qifs
+[submodule "integrationtests/interop/qifs"]
+	path = integrationtests/interop/qifs
 	url = git@github.com:qpackers/qifs.git

README.md

@@ -17,5 +17,5 @@ git submodule update --init --recursive
 
 Then run the tests:
 ```bash
-ginkgo integrationtests
+ginkgo -r integrationtests
 ```

encoder.go

@@ -0,0 +1,52 @@
+package qpack
+
+import (
+	"io"
+)
+
+// An Encoder performs QPACK encoding.
+type Encoder struct {
+	wrotePrefix bool
+
+	w   io.Writer
+	buf []byte
+}
+
+// NewEncoder returns a new Encoder which performs QPACK encoding. An
+// encoded data is written to w.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{w: w}
+}
+
+// WriteField encodes f into a single Write to e's underlying Writer.
+// This function may also produce bytes for the Header Block Prefix
+// if necessary. If produced, it is done before encoding f.
+func (e *Encoder) WriteField(f HeaderField) error {
+	// write the Header Block Prefix
+	if !e.wrotePrefix {
+		e.buf = appendVarInt(e.buf, 8, 0)
+		e.buf = appendVarInt(e.buf, 7, 0)
+		e.wrotePrefix = true
+	}
+
+	e.writeLiteralFieldWithoutNameReference(f)
+	e.w.Write(e.buf)
+	e.buf = e.buf[:0]
+	return nil
+}
+
+// Close declares that the encoding is complete and resets the Encoder
+// to be reused again for a new header block.
+func (e *Encoder) Close() error {
+	e.wrotePrefix = false
+	return nil
+}
+
+func (e *Encoder) writeLiteralFieldWithoutNameReference(f HeaderField) {
+	offset := len(e.buf)
+	e.buf = appendVarInt(e.buf, 3, uint64(len(f.Name)))
+	e.buf[offset] ^= 0x20
+	e.buf = append(e.buf, []byte(f.Name)...)
+	e.buf = appendVarInt(e.buf, 7, uint64(len(f.Value)))
+	e.buf = append(e.buf, []byte(f.Value)...)
+}

encoder_test.go

@@ -0,0 +1,90 @@
+package qpack
+
+import (
+	"bytes"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Encoder", func() {
+	var (
+		encoder *Encoder
+		output  *bytes.Buffer
+	)
+
+	BeforeEach(func() {
+		output = &bytes.Buffer{}
+		encoder = NewEncoder(output)
+	})
+
+	readPrefix := func(data []byte) (rest []byte, requiredInsertCount uint64, deltaBase uint64) {
+		var err error
+		requiredInsertCount, rest, err = readVarInt(8, data)
+		Expect(err).ToNot(HaveOccurred())
+		deltaBase, rest, err = readVarInt(7, rest)
+		Expect(err).ToNot(HaveOccurred())
+		return
+	}
+
+	checkHeaderField := func(data []byte, hf HeaderField) []byte {
+		Expect(data[0] & (0x80 ^ 0x40 ^ 0x20)).To(Equal(uint8(0x20))) // 001xxxxx
+		Expect(data[0] & 0x8).To(BeZero())                            // no Huffman encoding
+		nameLen, data, err := readVarInt(3, data)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(nameLen).To(BeEquivalentTo(len(hf.Name)))
+		Expect(string(data[:len(hf.Name)])).To(Equal(hf.Name))
+		valueLen, data, err := readVarInt(7, data[len(hf.Name):])
+		Expect(err).ToNot(HaveOccurred())
+		Expect(valueLen).To(BeEquivalentTo(len(hf.Value)))
+		Expect(string(data[:len(hf.Value)])).To(Equal(hf.Value))
+		return data[len(hf.Value):]
+	}
+
+	It("encodes a single field", func() {
+		hf := HeaderField{Name: "foobar", Value: "lorem ipsum"}
+		Expect(encoder.WriteField(hf)).To(Succeed())
+
+		data, requiredInsertCount, deltaBase := readPrefix(output.Bytes())
+		Expect(requiredInsertCount).To(BeZero())
+		Expect(deltaBase).To(BeZero())
+
+		data = checkHeaderField(data, hf)
+		Expect(data).To(BeEmpty())
+	})
+
+	It("encodes multipe fields", func() {
+		hf1 := HeaderField{Name: "foobar", Value: "lorem ipsum"}
+		hf2 := HeaderField{Name: "raboof", Value: "dolor sit amet"}
+		Expect(encoder.WriteField(hf1)).To(Succeed())
+		Expect(encoder.WriteField(hf2)).To(Succeed())
+
+		data, requiredInsertCount, deltaBase := readPrefix(output.Bytes())
+		Expect(requiredInsertCount).To(BeZero())
+		Expect(deltaBase).To(BeZero())
+
+		data = checkHeaderField(data, hf1)
+		data = checkHeaderField(data, hf2)
+		Expect(data).To(BeEmpty())
+	})
+
+	It("encodes multiple requests", func() {
+		hf1 := HeaderField{Name: "foobar", Value: "lorem ipsum"}
+		Expect(encoder.WriteField(hf1)).To(Succeed())
+		data, requiredInsertCount, deltaBase := readPrefix(output.Bytes())
+		Expect(requiredInsertCount).To(BeZero())
+		Expect(deltaBase).To(BeZero())
+		data = checkHeaderField(data, hf1)
+		Expect(data).To(BeEmpty())
+
+		output.Reset()
+		Expect(encoder.Close())
+		hf2 := HeaderField{Name: "raboof", Value: "dolor sit amet"}
+		Expect(encoder.WriteField(hf2)).To(Succeed())
+		data, requiredInsertCount, deltaBase = readPrefix(output.Bytes())
+		Expect(requiredInsertCount).To(BeZero())
+		Expect(deltaBase).To(BeZero())
+		data = checkHeaderField(data, hf2)
+		Expect(data).To(BeEmpty())
+	})
+})

…tiontests/integrationtests_suite_test.go …ationtests/interop/interop_suite_test.gointegrationtests/integrationtests_suite_test.go renamed to integrationtests/interop/interop_suite_test.go integrationtests/integrationtests_suite_test.go renamed to integrationtests/interop/interop_suite_test.go

@@ -1,4 +1,4 @@
-package integrationtests
+package interop
 
 import (
 	"bufio"
@@ -13,9 +13,9 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-func TestIntegrationtests(t *testing.T) {
+func TestInterop(t *testing.T) {
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "Integration Tests Suite")
+	RunSpecs(t, "Interop Suite")
 }
 
 type request struct {

integrationtests/interop_test.go integrationtests/interop/interop_test.gointegrationtests/interop_test.go renamed to integrationtests/interop/interop_test.go

@@ -1,4 +1,4 @@
-package integrationtests
+package interop
 
 import (
 	"encoding/binary"

integrationtests/qifs integrationtests/interop/qifsintegrationtests/qifs renamed to integrationtests/interop/qifs

@@ -0,0 +1,77 @@
+package self
+
+import (
+	"bytes"
+
+	"github.com/marten-seemann/qpack"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Self Tests", func() {
+	var (
+		// for the encoder
+		output  *bytes.Buffer
+		encoder *qpack.Encoder
+		// for the decoder
+		headerFields []qpack.HeaderField
+		decoder      *qpack.Decoder
+	)
+
+	BeforeEach(func() {
+		output = &bytes.Buffer{}
+		encoder = qpack.NewEncoder(output)
+		headerFields = nil
+		decoder = qpack.NewDecoder(func(hf qpack.HeaderField) {
+			headerFields = append(headerFields, hf)
+		})
+	})
+
+	It("encodes and decodes a single header field", func() {
+		hf := qpack.HeaderField{Name: "foo", Value: "bar"}
+		Expect(encoder.WriteField(hf)).To(Succeed())
+		_, err := decoder.Write(output.Bytes())
+		Expect(err).ToNot(HaveOccurred())
+		Expect(headerFields).To(Equal([]qpack.HeaderField{hf}))
+	})
+
+	It("encodes and decodes multiple header fields", func() {
+		hfs := []qpack.HeaderField{
+			{Name: "foo", Value: "bar"},
+			{Name: "lorem", Value: "ipsum"},
+			{Name: "name", Value: "value"},
+		}
+		for _, hf := range hfs {
+			Expect(encoder.WriteField(hf)).To(Succeed())
+		}
+		_, err := decoder.Write(output.Bytes())
+		Expect(err).ToNot(HaveOccurred())
+		Expect(headerFields).To(Equal(hfs))
+	})
+
+	It("encodes and decodes multiple requests", func() {
+		hfs1 := []qpack.HeaderField{{Name: "foo", Value: "bar"}}
+		hfs2 := []qpack.HeaderField{
+			{Name: "lorem", Value: "ipsum"},
+			{Name: "name", Value: "value"},
+		}
+		for _, hf := range hfs1 {
+			Expect(encoder.WriteField(hf)).To(Succeed())
+		}
+		req1 := append([]byte{}, output.Bytes()...)
+		output.Reset()
+		for _, hf := range hfs2 {
+			Expect(encoder.WriteField(hf)).To(Succeed())
+		}
+		req2 := append([]byte{}, output.Bytes()...)
+
+		_, err := decoder.Write(req1)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(headerFields).To(Equal(hfs1))
+		headerFields = nil
+		_, err = decoder.Write(req2)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(headerFields).To(Equal(hfs2))
+	})
+})

integrationtests/self/integration_test.go

@@ -0,0 +1,13 @@
+package self
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestSelf(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Self Suite")
+}