v0.17.3-rc1

config/config.go

@@ -72,8 +72,8 @@ type (
 		// any request with body (each call to request's body will result in status.ErrBodyTooLarge).
 		// In order to disable the setting, use the math.MaxUInt64 value.
 		MaxSize uint64
-		//// DecodingBufferSize is a size of a buffer, used to store decoded request's body
-		//DecodingBufferSize int
+		// Form is either application/x-www-form-urlencoded or multipart/form-data. Due to their common
+		// nature, they are easy to be generalized.
 		Form BodyForm
 	}
 
@@ -96,6 +96,10 @@ type (
 		//  2) If a stream is unsized (1) and the previous write used more than ~98.44% of its
 		//   capacity (2), the capacity doubles.
 		WriteBufferSize NETWriteBufferSize
+		// SmallBody limits how big must a response body be in order to be compressed, if the
+		// auto compression option is enabled. This setting doesn't affect enforced compression
+		// options and unsized streams.
+		SmallBody int64
 	}
 )
 
@@ -158,6 +162,7 @@ func Default() *Config {
 				Default: 2 * 1024,
 				Maximal: 64 * 1024,
 			},
+			SmallBody: 4 * 1024,
 		},
 	}
 }

examples/compression/compression.go

@@ -23,7 +23,7 @@ func Shout(r *http.Request) *http.Response {
 
 func main() {
 	app := indigo.New(":8080").
-		Codec(codec.NewGZIP()).
+		Codec(codec.Suit()...).
 		OnBind(func(addr string) {
 			fmt.Println("Listening on", addr)
 		})

examples/demo/demo.go

@@ -62,7 +62,7 @@ func main() {
 	app := indigo.New(":8080").
 		TLS(":8443", indigo.LocalCert()).
 		Tune(s).
-		Codec(codec.NewGZIP()).
+		Codec(codec.Suit()...).
 		OnBind(func(addr string) {
 			log.Printf("running on %s\n", addr)
 		})
@@ -71,10 +71,14 @@ func main() {
 		Use(middleware.LogRequests()).
 		Alias("/", "/static/index.html", method.GET).
 		Alias("/favicon.ico", "/static/favicon.ico", method.GET).
-		Static("/static", "examples/demo/static")
+		Static("/static", "examples/demo/static", middleware.Autocompress)
 
 	r.Get("/stress", Stressful, middleware.Recover)
 
+	r.Post("/echo", func(request *http.Request) *http.Response {
+		return http.Stream(request, request.Body)
+	})
+
 	r.Resource("/").
 		Post(IndexSay)
 

http/body.go

@@ -32,8 +32,6 @@ type Body struct {
 	form     form.Form
 }
 
-// TODO: body entity can be passed by value (?)
-
 func NewBody(src Fetcher) *Body {
 	return &Body{
 		Fetcher: src,
@@ -79,7 +77,7 @@ func (b *Body) Bytes() ([]byte, error) {
 	}
 
 	newSize := int(b.request.cfg.Body.Form.BufferPrealloc)
-	if !b.request.Encoding.Chunked {
+	if !b.request.Chunked {
 		newSize = min(b.request.ContentLength, int(b.request.cfg.Body.MaxSize))
 	}
 
@@ -178,6 +176,14 @@ func (b *Body) Form() (f form.Form, err error) {
 	}
 }
 
+func (b *Body) Len() int {
+	if b.request.Chunked {
+		return -1
+	}
+
+	return b.request.ContentLength
+}
+
 // Discard sinkholes the rest of the body. Should not be used unless you know what you're doing.
 func (b *Body) Discard() error {
 	for b.error == nil {

http/codec/base.go

@@ -0,0 +1,146 @@
+package codec
+
+import (
+	"io"
+
+	"github.com/indigo-web/indigo/http"
+)
+
+var _ Codec = baseCodec{}
+
+type instantiator = func() Instance
+
+type baseCodec struct {
+	token   string
+	newInst instantiator
+}
+
+func newBaseCodec(token string, newInst instantiator) baseCodec {
+	return baseCodec{
+		token:   token,
+		newInst: newInst,
+	}
+}
+
+func (b baseCodec) Token() string {
+	return b.token
+}
+
+func (b baseCodec) New() Instance {
+	return b.newInst()
+}
+
+var _ Instance = new(baseInstance)
+
+type (
+	decoderResetter = func(io.Reader, *readerAdapter) error
+
+	writeResetter interface {
+		io.WriteCloser
+		Reset(dst io.Writer)
+	}
+)
+
+type baseInstance struct {
+	reset   decoderResetter
+	adapter *readerAdapter
+	w       writeResetter // compressor
+	r       io.Reader     // decompressor
+	dst     io.Closer
+	buff    []byte
+}
+
+func newBaseInstance(encoder writeResetter, decoder io.Reader, reset decoderResetter) instantiator {
+	return func() Instance {
+		return &baseInstance{
+			reset:   reset,
+			adapter: newAdapter(),
+			w:       encoder,
+			r:       decoder,
+		}
+	}
+}
+
+func (b *baseInstance) ResetCompressor(w io.Writer) {
+	b.w.Reset(w)
+	b.dst = nil
+
+	if c, ok := w.(io.Closer); ok {
+		b.dst = c
+	}
+}
+
+func (b *baseInstance) Write(p []byte) (n int, err error) {
+	return b.w.Write(p)
+}
+
+func (b *baseInstance) Close() error {
+	if err := b.w.Close(); err != nil {
+		return err
+	}
+
+	if b.dst != nil {
+		return b.dst.Close()
+	}
+
+	return nil
+}
+
+func (b *baseInstance) ResetDecompressor(source http.Fetcher, bufferSize int) error {
+	if cap(b.buff) < bufferSize {
+		b.buff = make([]byte, bufferSize)
+	}
+
+	b.adapter.Reset(source)
+
+	return b.reset(b.r, b.adapter)
+}
+
+func (b *baseInstance) Fetch() ([]byte, error) {
+	n, err := b.r.Read(b.buff)
+	return b.buff[:n], err
+}
+
+func genericResetter(r io.Reader, adapter *readerAdapter) error {
+	type resetter interface {
+		Reset(r io.Reader) error
+	}
+
+	if reset, ok := r.(resetter); ok {
+		return reset.Reset(adapter)
+	}
+
+	return nil
+}
+
+type readerAdapter struct {
+	fetcher http.Fetcher
+	err     error
+	data    []byte
+}
+
+func newAdapter() *readerAdapter {
+	return new(readerAdapter)
+}
+
+func (r *readerAdapter) Read(b []byte) (n int, err error) {
+	if len(r.data) == 0 {
+		if r.err != nil {
+			return 0, r.err
+		}
+
+		r.data, r.err = r.fetcher.Fetch()
+	}
+
+	n = copy(b, r.data)
+	r.data = r.data[n:]
+	if len(r.data) == 0 {
+		err = r.err
+	}
+
+	return n, err
+}
+
+func (r *readerAdapter) Reset(fetcher http.Fetcher) {
+	*r = readerAdapter{fetcher: fetcher}
+}

http/codec/codec.go

@@ -23,6 +23,14 @@ type Compressor interface {
 }
 
 type Decompressor interface {
-	ResetDecompressor(source http.Fetcher) error
 	http.Fetcher
+	ResetDecompressor(source http.Fetcher, bufferSize int) error
+}
+
+// Suit is a collection of out-of-the-box supported codecs. It contains:
+//   - gzip
+//   - deflate
+//   - zstd
+func Suit() []Codec {
+	return []Codec{NewGZIP(), NewDeflate(), NewZSTD()}
 }

http/codec/deflate.go

@@ -1 +1,21 @@
 package codec
+
+import (
+	"io"
+
+	"github.com/klauspost/compress/flate"
+)
+
+func NewDeflate() Codec {
+	writer, err := flate.NewWriter(nil, 5)
+	if err != nil {
+		panic(err)
+	}
+
+	reader := flate.NewReader(nil)
+	instantiator := newBaseInstance(writer, reader, func(r io.Reader, a *readerAdapter) error {
+		return r.(flate.Resetter).Reset(a, nil)
+	})
+
+	return newBaseCodec("deflate", instantiator)
+}

http/codec/deflate_test.go

@@ -0,0 +1,9 @@
+package codec
+
+import (
+	"testing"
+)
+
+func TestFlate(t *testing.T) {
+	testCodec(t, NewDeflate().New())
+}