Update vendor

vendor/github.com/valyala/bytebufferpool/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Aliaksandr Valialkin, VertaMedia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

vendor/github.com/valyala/bytebufferpool/README.md

@@ -0,0 +1,21 @@
+[![Build Status](https://travis-ci.org/valyala/bytebufferpool.svg)](https://travis-ci.org/valyala/bytebufferpool)
+[![GoDoc](https://godoc.org/github.com/valyala/bytebufferpool?status.svg)](http://godoc.org/github.com/valyala/bytebufferpool)
+[![Go Report](http://goreportcard.com/badge/valyala/bytebufferpool)](http://goreportcard.com/report/valyala/bytebufferpool)
+
+# bytebufferpool
+
+An implementation of a pool of byte buffers with anti-memory-waste protection.
+
+The pool may waste limited amount of memory due to fragmentation.
+This amount equals to the maximum total size of the byte buffers
+in concurrent use.
+
+# Benchmark results
+Currently bytebufferpool is fastest and most effective buffer pool written in Go.
+
+You can find results [here](https://omgnull.github.io/go-benchmark/buffer/).
+
+# bytebufferpool users
+
+* [fasthttp](https://github.com/valyala/fasthttp)
+* [quicktemplate](https://github.com/valyala/quicktemplate)

vendor/github.com/valyala/bytebufferpool/bytebuffer.go

@@ -0,0 +1,111 @@
+package bytebufferpool
+
+import "io"
+
+// ByteBuffer provides byte buffer, which can be used for minimizing
+// memory allocations.
+//
+// ByteBuffer may be used with functions appending data to the given []byte
+// slice. See example code for details.
+//
+// Use Get for obtaining an empty byte buffer.
+type ByteBuffer struct {
+
+	// B is a byte buffer to use in append-like workloads.
+	// See example code for details.
+	B []byte
+}
+
+// Len returns the size of the byte buffer.
+func (b *ByteBuffer) Len() int {
+	return len(b.B)
+}
+
+// ReadFrom implements io.ReaderFrom.
+//
+// The function appends all the data read from r to b.
+func (b *ByteBuffer) ReadFrom(r io.Reader) (int64, error) {
+	p := b.B
+	nStart := int64(len(p))
+	nMax := int64(cap(p))
+	n := nStart
+	if nMax == 0 {
+		nMax = 64
+		p = make([]byte, nMax)
+	} else {
+		p = p[:nMax]
+	}
+	for {
+		if n == nMax {
+			nMax *= 2
+			bNew := make([]byte, nMax)
+			copy(bNew, p)
+			p = bNew
+		}
+		nn, err := r.Read(p[n:])
+		n += int64(nn)
+		if err != nil {
+			b.B = p[:n]
+			n -= nStart
+			if err == io.EOF {
+				return n, nil
+			}
+			return n, err
+		}
+	}
+}
+
+// WriteTo implements io.WriterTo.
+func (b *ByteBuffer) WriteTo(w io.Writer) (int64, error) {
+	n, err := w.Write(b.B)
+	return int64(n), err
+}
+
+// Bytes returns b.B, i.e. all the bytes accumulated in the buffer.
+//
+// The purpose of this function is bytes.Buffer compatibility.
+func (b *ByteBuffer) Bytes() []byte {
+	return b.B
+}
+
+// Write implements io.Writer - it appends p to ByteBuffer.B
+func (b *ByteBuffer) Write(p []byte) (int, error) {
+	b.B = append(b.B, p...)
+	return len(p), nil
+}
+
+// WriteByte appends the byte c to the buffer.
+//
+// The purpose of this function is bytes.Buffer compatibility.
+//
+// The function always returns nil.
+func (b *ByteBuffer) WriteByte(c byte) error {
+	b.B = append(b.B, c)
+	return nil
+}
+
+// WriteString appends s to ByteBuffer.B.
+func (b *ByteBuffer) WriteString(s string) (int, error) {
+	b.B = append(b.B, s...)
+	return len(s), nil
+}
+
+// Set sets ByteBuffer.B to p.
+func (b *ByteBuffer) Set(p []byte) {
+	b.B = append(b.B[:0], p...)
+}
+
+// SetString sets ByteBuffer.B to s.
+func (b *ByteBuffer) SetString(s string) {
+	b.B = append(b.B[:0], s...)
+}
+
+// String returns string representation of ByteBuffer.B.
+func (b *ByteBuffer) String() string {
+	return string(b.B)
+}
+
+// Reset makes ByteBuffer.B empty.
+func (b *ByteBuffer) Reset() {
+	b.B = b.B[:0]
+}

vendor/github.com/valyala/bytebufferpool/doc.go

@@ -0,0 +1,7 @@
+// Package bytebufferpool implements a pool of byte buffers
+// with anti-fragmentation protection.
+//
+// The pool may waste limited amount of memory due to fragmentation.
+// This amount equals to the maximum total size of the byte buffers
+// in concurrent use.
+package bytebufferpool

vendor/github.com/valyala/bytebufferpool/pool.go

@@ -0,0 +1,151 @@
+package bytebufferpool
+
+import (
+	"sort"
+	"sync"
+	"sync/atomic"
+)
+
+const (
+	minBitSize = 6 // 2**6=64 is a CPU cache line size
+	steps      = 20
+
+	minSize = 1 << minBitSize
+	maxSize = 1 << (minBitSize + steps - 1)
+
+	calibrateCallsThreshold = 42000
+	maxPercentile           = 0.95
+)
+
+// Pool represents byte buffer pool.
+//
+// Distinct pools may be used for distinct types of byte buffers.
+// Properly determined byte buffer types with their own pools may help reducing
+// memory waste.
+type Pool struct {
+	calls       [steps]uint64
+	calibrating uint64
+
+	defaultSize uint64
+	maxSize     uint64
+
+	pool sync.Pool
+}
+
+var defaultPool Pool
+
+// Get returns an empty byte buffer from the pool.
+//
+// Got byte buffer may be returned to the pool via Put call.
+// This reduces the number of memory allocations required for byte buffer
+// management.
+func Get() *ByteBuffer { return defaultPool.Get() }
+
+// Get returns new byte buffer with zero length.
+//
+// The byte buffer may be returned to the pool via Put after the use
+// in order to minimize GC overhead.
+func (p *Pool) Get() *ByteBuffer {
+	v := p.pool.Get()
+	if v != nil {
+		return v.(*ByteBuffer)
+	}
+	return &ByteBuffer{
+		B: make([]byte, 0, atomic.LoadUint64(&p.defaultSize)),
+	}
+}
+
+// Put returns byte buffer to the pool.
+//
+// ByteBuffer.B mustn't be touched after returning it to the pool.
+// Otherwise data races will occur.
+func Put(b *ByteBuffer) { defaultPool.Put(b) }
+
+// Put releases byte buffer obtained via Get to the pool.
+//
+// The buffer mustn't be accessed after returning to the pool.
+func (p *Pool) Put(b *ByteBuffer) {
+	idx := index(len(b.B))
+
+	if atomic.AddUint64(&p.calls[idx], 1) > calibrateCallsThreshold {
+		p.calibrate()
+	}
+
+	maxSize := int(atomic.LoadUint64(&p.maxSize))
+	if maxSize == 0 || cap(b.B) <= maxSize {
+		b.Reset()
+		p.pool.Put(b)
+	}
+}
+
+func (p *Pool) calibrate() {
+	if !atomic.CompareAndSwapUint64(&p.calibrating, 0, 1) {
+		return
+	}
+
+	a := make(callSizes, 0, steps)
+	var callsSum uint64
+	for i := uint64(0); i < steps; i++ {
+		calls := atomic.SwapUint64(&p.calls[i], 0)
+		callsSum += calls
+		a = append(a, callSize{
+			calls: calls,
+			size:  minSize << i,
+		})
+	}
+	sort.Sort(a)
+
+	defaultSize := a[0].size
+	maxSize := defaultSize
+
+	maxSum := uint64(float64(callsSum) * maxPercentile)
+	callsSum = 0
+	for i := 0; i < steps; i++ {
+		if callsSum > maxSum {
+			break
+		}
+		callsSum += a[i].calls
+		size := a[i].size
+		if size > maxSize {
+			maxSize = size
+		}
+	}
+
+	atomic.StoreUint64(&p.defaultSize, defaultSize)
+	atomic.StoreUint64(&p.maxSize, maxSize)
+
+	atomic.StoreUint64(&p.calibrating, 0)
+}
+
+type callSize struct {
+	calls uint64
+	size  uint64
+}
+
+type callSizes []callSize
+
+func (ci callSizes) Len() int {
+	return len(ci)
+}
+
+func (ci callSizes) Less(i, j int) bool {
+	return ci[i].calls > ci[j].calls
+}
+
+func (ci callSizes) Swap(i, j int) {
+	ci[i], ci[j] = ci[j], ci[i]
+}
+
+func index(n int) int {
+	n--
+	n >>= minBitSize
+	idx := 0
+	for n > 0 {
+		n >>= 1
+		idx++
+	}
+	if idx >= steps {
+		idx = steps - 1
+	}
+	return idx
+}

vendor/github.com/valyala/fasthttp/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Aliaksandr Valialkin, VertaMedia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

vendor/github.com/valyala/fasthttp/README.md

@@ -0,0 +1,579 @@
+[![Build Status](https://travis-ci.org/valyala/fasthttp.svg)](https://travis-ci.org/valyala/fasthttp)
+[![GoDoc](https://godoc.org/github.com/valyala/fasthttp?status.svg)](http://godoc.org/github.com/valyala/fasthttp)
+[![Go Report](https://goreportcard.com/badge/github.com/valyala/fasthttp)](https://goreportcard.com/report/github.com/valyala/fasthttp)
+
+# fasthttp
+Fast HTTP implementation for Go.
+
+Currently fasthttp is successfully used by [VertaMedia](https://vertamedia.com/)
+in a production serving up to 200K rps from more than 1.5M concurrent keep-alive
+connections per physical server.
+
+[TechEmpower Benchmark round 12 results](https://www.techempower.com/benchmarks/#section=data-r12&hw=peak&test=plaintext)
+
+[Server Benchmarks](#http-server-performance-comparison-with-nethttp)
+
+[Client Benchmarks](#http-client-comparison-with-nethttp)
+
+[Install](#install)
+
+[Documentation](https://godoc.org/github.com/valyala/fasthttp)
+
+[Examples from docs](https://godoc.org/github.com/valyala/fasthttp#pkg-examples)
+
+[Code examples](examples)
+
+[Switching from net/http to fasthttp](#switching-from-nethttp-to-fasthttp)
+
+[Fasthttp best practices](#fasthttp-best-practices)
+
+[Tricks with byte buffers](#tricks-with-byte-buffers)
+
+[Related projects](#related-projects)
+
+[FAQ](#faq)
+
+# HTTP server performance comparison with [net/http](https://golang.org/pkg/net/http/)
+
+In short, fasthttp server is up to 10 times faster than net/http.
+Below are benchmark results.
+
+*GOMAXPROCS=1*
+
+net/http server:
+```
+$ GOMAXPROCS=1 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
+BenchmarkNetHTTPServerGet1ReqPerConn                	 1000000	     12052 ns/op	    2297 B/op	      29 allocs/op
+BenchmarkNetHTTPServerGet2ReqPerConn                	 1000000	     12278 ns/op	    2327 B/op	      24 allocs/op
+BenchmarkNetHTTPServerGet10ReqPerConn               	 2000000	      8903 ns/op	    2112 B/op	      19 allocs/op
+BenchmarkNetHTTPServerGet10KReqPerConn              	 2000000	      8451 ns/op	    2058 B/op	      18 allocs/op
+BenchmarkNetHTTPServerGet1ReqPerConn10KClients      	  500000	     26733 ns/op	    3229 B/op	      29 allocs/op
+BenchmarkNetHTTPServerGet2ReqPerConn10KClients      	 1000000	     23351 ns/op	    3211 B/op	      24 allocs/op
+BenchmarkNetHTTPServerGet10ReqPerConn10KClients     	 1000000	     13390 ns/op	    2483 B/op	      19 allocs/op
+BenchmarkNetHTTPServerGet100ReqPerConn10KClients    	 1000000	     13484 ns/op	    2171 B/op	      18 allocs/op
+```
+
+fasthttp server:
+```
+$ GOMAXPROCS=1 go test -bench=kServerGet -benchmem -benchtime=10s
+BenchmarkServerGet1ReqPerConn                       	10000000	      1559 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet2ReqPerConn                       	10000000	      1248 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet10ReqPerConn                      	20000000	       797 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet10KReqPerConn                     	20000000	       716 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet1ReqPerConn10KClients             	10000000	      1974 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet2ReqPerConn10KClients             	10000000	      1352 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet10ReqPerConn10KClients            	20000000	       789 ns/op	       2 B/op	       0 allocs/op
+BenchmarkServerGet100ReqPerConn10KClients           	20000000	       604 ns/op	       0 B/op	       0 allocs/op
+```
+
+*GOMAXPROCS=4*
+
+net/http server:
+```
+$ GOMAXPROCS=4 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
+BenchmarkNetHTTPServerGet1ReqPerConn-4                  	 3000000	      4529 ns/op	    2389 B/op	      29 allocs/op
+BenchmarkNetHTTPServerGet2ReqPerConn-4                  	 5000000	      3896 ns/op	    2418 B/op	      24 allocs/op
+BenchmarkNetHTTPServerGet10ReqPerConn-4                 	 5000000	      3145 ns/op	    2160 B/op	      19 allocs/op
+BenchmarkNetHTTPServerGet10KReqPerConn-4                	 5000000	      3054 ns/op	    2065 B/op	      18 allocs/op
+BenchmarkNetHTTPServerGet1ReqPerConn10KClients-4        	 1000000	     10321 ns/op	    3710 B/op	      30 allocs/op
+BenchmarkNetHTTPServerGet2ReqPerConn10KClients-4        	 2000000	      7556 ns/op	    3296 B/op	      24 allocs/op
+BenchmarkNetHTTPServerGet10ReqPerConn10KClients-4       	 5000000	      3905 ns/op	    2349 B/op	      19 allocs/op
+BenchmarkNetHTTPServerGet100ReqPerConn10KClients-4      	 5000000	      3435 ns/op	    2130 B/op	      18 allocs/op
+```
+
+fasthttp server:
+```
+$ GOMAXPROCS=4 go test -bench=kServerGet -benchmem -benchtime=10s
+BenchmarkServerGet1ReqPerConn-4                         	10000000	      1141 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet2ReqPerConn-4                         	20000000	       707 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet10ReqPerConn-4                        	30000000	       341 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet10KReqPerConn-4                       	50000000	       310 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet1ReqPerConn10KClients-4               	10000000	      1119 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet2ReqPerConn10KClients-4               	20000000	       644 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet10ReqPerConn10KClients-4              	30000000	       346 ns/op	       0 B/op	       0 allocs/op
+BenchmarkServerGet100ReqPerConn10KClients-4             	50000000	       282 ns/op	       0 B/op	       0 allocs/op
+```
+
+# HTTP client comparison with net/http
+
+In short, fasthttp client is up to 10 times faster than net/http.
+Below are benchmark results.
+
+*GOMAXPROCS=1*
+
+net/http client:
+```
+$ GOMAXPROCS=1 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
+BenchmarkNetHTTPClientDoFastServer                  	 1000000	     12567 ns/op	    2616 B/op	      35 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd1TCP               	  200000	     67030 ns/op	    5028 B/op	      56 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd10TCP              	  300000	     51098 ns/op	    5031 B/op	      56 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd100TCP             	  300000	     45096 ns/op	    5026 B/op	      55 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd1Inmemory          	  500000	     24779 ns/op	    5035 B/op	      57 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd10Inmemory         	 1000000	     26425 ns/op	    5035 B/op	      57 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd100Inmemory        	  500000	     28515 ns/op	    5045 B/op	      57 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd1000Inmemory       	  500000	     39511 ns/op	    5096 B/op	      56 allocs/op
+```
+
+fasthttp client:
+```
+$ GOMAXPROCS=1 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
+BenchmarkClientDoFastServer                         	20000000	       865 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd1TCP                      	 1000000	     18711 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd10TCP                     	 1000000	     14664 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd100TCP                    	 1000000	     14043 ns/op	       1 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd1Inmemory                 	 5000000	      3965 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd10Inmemory                	 3000000	      4060 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd100Inmemory               	 5000000	      3396 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd1000Inmemory              	 5000000	      3306 ns/op	       2 B/op	       0 allocs/op
+```
+
+*GOMAXPROCS=4*
+
+net/http client:
+```
+$ GOMAXPROCS=4 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
+BenchmarkNetHTTPClientDoFastServer-4                    	 2000000	      8774 ns/op	    2619 B/op	      35 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd1TCP-4                 	  500000	     22951 ns/op	    5047 B/op	      56 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd10TCP-4                	 1000000	     19182 ns/op	    5037 B/op	      55 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd100TCP-4               	 1000000	     16535 ns/op	    5031 B/op	      55 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd1Inmemory-4            	 1000000	     14495 ns/op	    5038 B/op	      56 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd10Inmemory-4           	 1000000	     10237 ns/op	    5034 B/op	      56 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd100Inmemory-4          	 1000000	     10125 ns/op	    5045 B/op	      56 allocs/op
+BenchmarkNetHTTPClientGetEndToEnd1000Inmemory-4         	 1000000	     11132 ns/op	    5136 B/op	      56 allocs/op
+```
+
+fasthttp client:
+```
+$ GOMAXPROCS=4 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
+BenchmarkClientDoFastServer-4                           	50000000	       397 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd1TCP-4                        	 2000000	      7388 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd10TCP-4                       	 2000000	      6689 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd100TCP-4                      	 3000000	      4927 ns/op	       1 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd1Inmemory-4                   	10000000	      1604 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd10Inmemory-4                  	10000000	      1458 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd100Inmemory-4                 	10000000	      1329 ns/op	       0 B/op	       0 allocs/op
+BenchmarkClientGetEndToEnd1000Inmemory-4                	10000000	      1316 ns/op	       5 B/op	       0 allocs/op
+```
+
+
+# Install
+
+```
+go get -u github.com/valyala/fasthttp
+```
+
+
+# Switching from net/http to fasthttp
+
+Unfortunately, fasthttp doesn't provide API identical to net/http.
+See the [FAQ](#faq) for details.
+There is [net/http -> fasthttp handler converter](https://godoc.org/github.com/valyala/fasthttp/fasthttpadaptor),
+but it is better to write fasthttp request handlers by hand in order to use 
+all of the fasthttp advantages (especially high performance :) ).
+
+Important points:
+
+* Fasthttp works with [RequestHandler functions](https://godoc.org/github.com/valyala/fasthttp#RequestHandler)
+instead of objects implementing [Handler interface](https://golang.org/pkg/net/http/#Handler).
+Fortunately, it is easy to pass bound struct methods to fasthttp:
+
+  ```go
+  type MyHandler struct {
+  	foobar string
+  }
+
+  // request handler in net/http style, i.e. method bound to MyHandler struct.
+  func (h *MyHandler) HandleFastHTTP(ctx *fasthttp.RequestCtx) {
+  	// notice that we may access MyHandler properties here - see h.foobar.
+  	fmt.Fprintf(ctx, "Hello, world! Requested path is %q. Foobar is %q",
+  		ctx.Path(), h.foobar)
+  }
+
+  // request handler in fasthttp style, i.e. just plain function.
+  func fastHTTPHandler(ctx *fasthttp.RequestCtx) {
+  	fmt.Fprintf(ctx, "Hi there! RequestURI is %q", ctx.RequestURI())
+  }
+
+  // pass bound struct method to fasthttp
+  myHandler := &MyHandler{
+  	foobar: "foobar",
+  }
+  fasthttp.ListenAndServe(":8080", myHandler.HandleFastHTTP)
+
+  // pass plain function to fasthttp
+  fasthttp.ListenAndServe(":8081", fastHTTPHandler)
+  ```
+
+* The [RequestHandler](https://godoc.org/github.com/valyala/fasthttp#RequestHandler)
+accepts only one argument - [RequestCtx](https://godoc.org/github.com/valyala/fasthttp#RequestCtx).
+It contains all the functionality required for http request processing
+and response writing. Below is an example of a simple request handler conversion
+from net/http to fasthttp.
+
+  ```go
+  // net/http request handler
+  requestHandler := func(w http.ResponseWriter, r *http.Request) {
+  	switch r.URL.Path {
+  	case "/foo":
+  		fooHandler(w, r)
+  	case "/bar":
+  		barHandler(w, r)
+  	default:
+  		http.Error(w, "Unsupported path", http.StatusNotFound)
+  	}
+  }
+  ```
+
+  ```go
+  // the corresponding fasthttp request handler
+  requestHandler := func(ctx *fasthttp.RequestCtx) {
+  	switch string(ctx.Path()) {
+  	case "/foo":
+  		fooHandler(ctx)
+  	case "/bar":
+  		barHandler(ctx)
+  	default:
+  		ctx.Error("Unsupported path", fasthttp.StatusNotFound)
+  	}
+  }
+  ```
+
+* Fasthttp allows setting response headers and writing response body
+in an arbitrary order. There is no 'headers first, then body' restriction
+like in net/http. The following code is valid for fasthttp:
+
+  ```go
+  requestHandler := func(ctx *fasthttp.RequestCtx) {
+  	// set some headers and status code first
+  	ctx.SetContentType("foo/bar")
+  	ctx.SetStatusCode(fasthttp.StatusOK)
+
+  	// then write the first part of body
+  	fmt.Fprintf(ctx, "this is the first part of body\n")
+
+  	// then set more headers
+  	ctx.Response.Header.Set("Foo-Bar", "baz")
+
+  	// then write more body
+  	fmt.Fprintf(ctx, "this is the second part of body\n")
+
+  	// then override already written body
+  	ctx.SetBody([]byte("this is completely new body contents"))
+
+  	// then update status code
+  	ctx.SetStatusCode(fasthttp.StatusNotFound)
+
+  	// basically, anything may be updated many times before
+  	// returning from RequestHandler.
+  	//
+  	// Unlike net/http fasthttp doesn't put response to the wire until
+  	// returning from RequestHandler.
+  }
+  ```
+
+* Fasthttp doesn't provide [ServeMux](https://golang.org/pkg/net/http/#ServeMux),
+but there are more powerful third-party routers and web frameworks
+with fasthttp support:
+
+  * [Iris](https://github.com/kataras/iris)
+  * [fasthttp-routing](https://github.com/qiangxue/fasthttp-routing)
+  * [fasthttprouter](https://github.com/buaazp/fasthttprouter)
+  * [lu](https://github.com/vincentLiuxiang/lu)
+
+  Net/http code with simple ServeMux is trivially converted to fasthttp code:
+
+  ```go
+  // net/http code
+
+  m := &http.ServeMux{}
+  m.HandleFunc("/foo", fooHandlerFunc)
+  m.HandleFunc("/bar", barHandlerFunc)
+  m.Handle("/baz", bazHandler)
+
+  http.ListenAndServe(":80", m)
+  ```
+
+  ```go
+  // the corresponding fasthttp code
+  m := func(ctx *fasthttp.RequestCtx) {
+  	switch string(ctx.Path()) {
+  	case "/foo":
+  		fooHandlerFunc(ctx)
+  	case "/bar":
+  		barHandlerFunc(ctx)
+  	case "/baz":
+  		bazHandler.HandlerFunc(ctx)
+  	default:
+  		ctx.Error("not found", fasthttp.StatusNotFound)
+  	}
+  }
+
+  fasthttp.ListenAndServe(":80", m)
+  ```
+
+* net/http -> fasthttp conversion table:
+
+  * All the pseudocode below assumes w, r and ctx have these types:
+  ```go
+	var (
+		w http.ResponseWriter
+		r *http.Request
+		ctx *fasthttp.RequestCtx
+	)
+  ```
+  * r.Body -> [ctx.PostBody()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.PostBody)
+  * r.URL.Path -> [ctx.Path()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Path)
+  * r.URL -> [ctx.URI()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.URI)
+  * r.Method -> [ctx.Method()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Method)
+  * r.Header -> [ctx.Request.Header](https://godoc.org/github.com/valyala/fasthttp#RequestHeader)
+  * r.Header.Get() -> [ctx.Request.Header.Peek()](https://godoc.org/github.com/valyala/fasthttp#RequestHeader.Peek)
+  * r.Host -> [ctx.Host()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Host)
+  * r.Form -> [ctx.QueryArgs()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.QueryArgs) +
+  [ctx.PostArgs()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.PostArgs)
+  * r.PostForm -> [ctx.PostArgs()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.PostArgs)
+  * r.FormValue() -> [ctx.FormValue()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.FormValue)
+  * r.FormFile() -> [ctx.FormFile()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.FormFile)
+  * r.MultipartForm -> [ctx.MultipartForm()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.MultipartForm)
+  * r.RemoteAddr -> [ctx.RemoteAddr()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.RemoteAddr)
+  * r.RequestURI -> [ctx.RequestURI()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.RequestURI)
+  * r.TLS -> [ctx.IsTLS()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.IsTLS)
+  * r.Cookie() -> [ctx.Request.Header.Cookie()](https://godoc.org/github.com/valyala/fasthttp#RequestHeader.Cookie)
+  * r.Referer() -> [ctx.Referer()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Referer)
+  * r.UserAgent() -> [ctx.UserAgent()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.UserAgent)
+  * w.Header() -> [ctx.Response.Header](https://godoc.org/github.com/valyala/fasthttp#ResponseHeader)
+  * w.Header().Set() -> [ctx.Response.Header.Set()](https://godoc.org/github.com/valyala/fasthttp#ResponseHeader.Set)
+  * w.Header().Set("Content-Type") -> [ctx.SetContentType()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.SetContentType)
+  * w.Header().Set("Set-Cookie") -> [ctx.Response.Header.SetCookie()](https://godoc.org/github.com/valyala/fasthttp#ResponseHeader.SetCookie)
+  * w.Write() -> [ctx.Write()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Write),
+  [ctx.SetBody()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.SetBody),
+  [ctx.SetBodyStream()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.SetBodyStream),
+  [ctx.SetBodyStreamWriter()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.SetBodyStreamWriter)
+  * w.WriteHeader() -> [ctx.SetStatusCode()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.SetStatusCode)
+  * w.(http.Hijacker).Hijack() -> [ctx.Hijack()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Hijack)
+  * http.Error() -> [ctx.Error()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Error)
+  * http.FileServer() -> [fasthttp.FSHandler()](https://godoc.org/github.com/valyala/fasthttp#FSHandler),
+  [fasthttp.FS](https://godoc.org/github.com/valyala/fasthttp#FS)
+  * http.ServeFile() -> [fasthttp.ServeFile()](https://godoc.org/github.com/valyala/fasthttp#ServeFile)
+  * http.Redirect() -> [ctx.Redirect()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Redirect)
+  * http.NotFound() -> [ctx.NotFound()](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.NotFound)
+  * http.StripPrefix() -> [fasthttp.PathRewriteFunc](https://godoc.org/github.com/valyala/fasthttp#PathRewriteFunc)
+
+* *VERY IMPORTANT!* Fasthttp disallows holding references
+to [RequestCtx](https://godoc.org/github.com/valyala/fasthttp#RequestCtx) or to its'
+members after returning from [RequestHandler](https://godoc.org/github.com/valyala/fasthttp#RequestHandler).
+Otherwise [data races](http://blog.golang.org/race-detector) are inevitable.
+Carefully inspect all the net/http request handlers converted to fasthttp whether
+they retain references to RequestCtx or to its' members after returning.
+RequestCtx provides the following _band aids_ for this case:
+
+  * Wrap RequestHandler into [TimeoutHandler](https://godoc.org/github.com/valyala/fasthttp#TimeoutHandler).
+  * Call [TimeoutError](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.TimeoutError)
+  before returning from RequestHandler if there are references to RequestCtx or to its' members.
+  See [the example](https://godoc.org/github.com/valyala/fasthttp#example-RequestCtx-TimeoutError)
+  for more details.
+
+Use this brilliant tool - [race detector](http://blog.golang.org/race-detector) -
+for detecting and eliminating data races in your program. If you detected
+data race related to fasthttp in your program, then there is high probability
+you forgot calling [TimeoutError](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.TimeoutError)
+before returning from [RequestHandler](https://godoc.org/github.com/valyala/fasthttp#RequestHandler).
+
+* Blind switching from net/http to fasthttp won't give you performance boost.
+While fasthttp is optimized for speed, its' performance may be easily saturated
+by slow [RequestHandler](https://godoc.org/github.com/valyala/fasthttp#RequestHandler).
+So [profile](http://blog.golang.org/profiling-go-programs) and optimize your
+code after switching to fasthttp. For instance, use [quicktemplate](https://github.com/valyala/quicktemplate)
+instead of [html/template](https://golang.org/pkg/html/template/).
+
+* See also [fasthttputil](https://godoc.org/github.com/valyala/fasthttp/fasthttputil),
+[fasthttpadaptor](https://godoc.org/github.com/valyala/fasthttp/fasthttpadaptor) and
+[expvarhandler](https://godoc.org/github.com/valyala/fasthttp/expvarhandler).
+
+
+# Performance optimization tips for multi-core systems
+
+* Use [reuseport](https://godoc.org/github.com/valyala/fasthttp/reuseport) listener.
+* Run a separate server instance per CPU core with GOMAXPROCS=1.
+* Pin each server instance to a separate CPU core using [taskset](http://linux.die.net/man/1/taskset).
+* Ensure the interrupts of multiqueue network card are evenly distributed between CPU cores.
+  See [this article](https://blog.cloudflare.com/how-to-achieve-low-latency/) for details.
+* Use Go 1.6 as it provides some considerable performance improvements.
+
+
+# Fasthttp best practices
+
+* Do not allocate objects and `[]byte` buffers - just reuse them as much
+  as possible. Fasthttp API design encourages this.
+* [sync.Pool](https://golang.org/pkg/sync/#Pool) is your best friend.
+* [Profile your program](http://blog.golang.org/profiling-go-programs)
+  in production.
+  `go tool pprof --alloc_objects your-program mem.pprof` usually gives better
+  insights for optimization opportunities than `go tool pprof your-program cpu.pprof`.
+* Write [tests and benchmarks](https://golang.org/pkg/testing/) for hot paths.
+* Avoid conversion between `[]byte` and `string`, since this may result in memory
+  allocation+copy. Fasthttp API provides functions for both `[]byte` and `string` -
+  use these functions instead of converting manually between `[]byte` and `string`.
+  There are some exceptions - see [this wiki page](https://github.com/golang/go/wiki/CompilerOptimizations#string-and-byte)
+  for more details.
+* Verify your tests and production code under
+  [race detector](https://golang.org/doc/articles/race_detector.html) on a regular basis.
+* Prefer [quicktemplate](https://github.com/valyala/quicktemplate) instead of
+  [html/template](https://golang.org/pkg/html/template/) in your webserver.
+
+
+# Tricks with `[]byte` buffers
+
+The following tricks are used by fasthttp. Use them in your code too.
+
+* Standard Go functions accept nil buffers
+```go
+var (
+	// both buffers are uninitialized
+	dst []byte
+	src []byte
+)
+dst = append(dst, src...)  // is legal if dst is nil and/or src is nil
+copy(dst, src)  // is legal if dst is nil and/or src is nil
+(string(src) == "")  // is true if src is nil
+(len(src) == 0)  // is true if src is nil
+src = src[:0]  // works like a charm with nil src
+
+// this for loop doesn't panic if src is nil
+for i, ch := range src {
+	doSomething(i, ch)
+}
+```
+
+So throw away nil checks for `[]byte` buffers from you code. For example,
+```go
+srcLen := 0
+if src != nil {
+	srcLen = len(src)
+}
+```
+
+becomes
+
+```go
+srcLen := len(src)
+```
+
+* String may be appended to `[]byte` buffer with `append`
+```go
+dst = append(dst, "foobar"...)
+```
+
+* `[]byte` buffer may be extended to its' capacity.
+```go
+buf := make([]byte, 100)
+a := buf[:10]  // len(a) == 10, cap(a) == 100.
+b := a[:100]  // is valid, since cap(a) == 100.
+```
+
+* All fasthttp functions accept nil `[]byte` buffer
+```go
+statusCode, body, err := fasthttp.Get(nil, "http://google.com/")
+uintBuf := fasthttp.AppendUint(nil, 1234)
+```
+
+# Related projects
+
+  * [fasthttp-contrib](https://github.com/fasthttp-contrib) - various useful
+    helpers for projects based on fasthttp.
+  * [iris](https://github.com/kataras/iris) - web application framework built
+    on top of fasthttp. Features speed and functionality.
+  * [fasthttp-routing](https://github.com/qiangxue/fasthttp-routing) - fast and
+    powerful routing package for fasthttp servers.
+  * [fasthttprouter](https://github.com/buaazp/fasthttprouter) - a high
+    performance fasthttp request router that scales well.
+  * [lu](https://github.com/vincentLiuxiang/lu) - a high performance
+    go middleware web framework which is based on fasthttp.
+  * [websocket](https://github.com/leavengood/websocket) - Gorilla-based
+    websocket implementation for fasthttp.
+
+
+# FAQ
+
+* *Why creating yet another http package instead of optimizing net/http?*
+
+  Because net/http API limits many optimization opportunities.
+  For example:
+  * net/http Request object lifetime isn't limited by request handler execution
+    time. So the server must create a new request object per each request instead
+    of reusing existing objects like fasthttp does.
+  * net/http headers are stored in a `map[string][]string`. So the server
+    must parse all the headers, convert them from `[]byte` to `string` and put
+    them into the map before calling user-provided request handler.
+    This all requires unnecessary memory allocations avoided by fasthttp.
+  * net/http client API requires creating a new response object per each request.
+
+* *Why fasthttp API is incompatible with net/http?*
+
+  Because net/http API limits many optimization opportunities. See the answer
+  above for more details. Also certain net/http API parts are suboptimal
+  for use:
+  * Compare [net/http connection hijacking](https://golang.org/pkg/net/http/#Hijacker)
+    to [fasthttp connection hijacking](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Hijack).
+  * Compare [net/http Request.Body reading](https://golang.org/pkg/net/http/#Request)
+    to [fasthttp request body reading](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.PostBody).
+
+* *Why fasthttp doesn't support HTTP/2.0 and WebSockets?*
+
+  There are [plans](TODO) for adding HTTP/2.0 and WebSockets support
+  in the future.
+  In the mean time, third parties may use [RequestCtx.Hijack](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.Hijack)
+  for implementing these goodies. See [the first third-party websocket implementation on the top of fasthttp](https://github.com/leavengood/websocket).
+
+* *Are there known net/http advantages comparing to fasthttp?*
+
+  Yes:
+  * net/http supports [HTTP/2.0 starting from go1.6](https://http2.golang.org/).
+  * net/http API is stable, while fasthttp API constantly evolves.
+  * net/http handles more HTTP corner cases.
+  * net/http should contain less bugs, since it is used and tested by much
+    wider audience.
+  * net/http works on Go older than 1.5.
+
+* *Why fasthttp API prefers returning `[]byte` instead of `string`?*
+
+  Because `[]byte` to `string` conversion isn't free - it requires memory
+  allocation and copy. Feel free wrapping returned `[]byte` result into
+  `string()` if you prefer working with strings instead of byte slices.
+  But be aware that this has non-zero overhead.
+
+* *Which GO versions are supported by fasthttp?*
+
+  Go1.5+. Older versions won't be supported, since their standard package
+  [miss useful functions](https://github.com/valyala/fasthttp/issues/5).
+
+* *Please provide real benchmark data and sever information*
+
+  See [this issue](https://github.com/valyala/fasthttp/issues/4).
+
+* *Are there plans to add request routing to fasthttp?*
+
+  There are no plans to add request routing into fasthttp.
+  Use third-party routers and web frameworks with fasthttp support:
+
+    * [Iris](https://github.com/kataras/iris)
+    * [fasthttp-routing](https://github.com/qiangxue/fasthttp-routing)
+    * [fasthttprouter](https://github.com/buaazp/fasthttprouter)
+    * [lu](https://github.com/vincentLiuxiang/lu)
+
+  See also [this issue](https://github.com/valyala/fasthttp/issues/9) for more info.
+
+* *I detected data race in fasthttp!*
+
+  Cool! [File a bug](https://github.com/valyala/fasthttp/issues/new). But before
+  doing this check the following in your code:
+
+  * Make sure there are no references to [RequestCtx](https://godoc.org/github.com/valyala/fasthttp#RequestCtx)
+  or to its' members after returning from [RequestHandler](https://godoc.org/github.com/valyala/fasthttp#RequestHandler).
+  * Make sure you call [TimeoutError](https://godoc.org/github.com/valyala/fasthttp#RequestCtx.TimeoutError)
+  before returning from [RequestHandler](https://godoc.org/github.com/valyala/fasthttp#RequestHandler)
+  if there are references to [RequestCtx](https://godoc.org/github.com/valyala/fasthttp#RequestCtx)
+  or to its' members, which may be accessed by other goroutines.
+
+* *I didn't find an answer for my question here*
+
+  Try exploring [these questions](https://github.com/valyala/fasthttp/issues?q=label%3Aquestion).

vendor/github.com/valyala/fasthttp/TODO

@@ -0,0 +1,4 @@
+- SessionClient with referer and cookies support.
+- ProxyHandler similar to FSHandler.
+- WebSockets. See https://tools.ietf.org/html/rfc6455 .
+- HTTP/2.0. See https://tools.ietf.org/html/rfc7540 .

vendor/github.com/valyala/fasthttp/args.go

@@ -0,0 +1,469 @@
+package fasthttp
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"sync"
+)
+
+// AcquireArgs returns an empty Args object from the pool.
+//
+// The returned Args may be returned to the pool with ReleaseArgs
+// when no longer needed. This allows reducing GC load.
+func AcquireArgs() *Args {
+	return argsPool.Get().(*Args)
+}
+
+// ReleaseArgs returns the object acquired via AquireArgs to the pool.
+//
+// Do not access the released Args object, otherwise data races may occur.
+func ReleaseArgs(a *Args) {
+	a.Reset()
+	argsPool.Put(a)
+}
+
+var argsPool = &sync.Pool{
+	New: func() interface{} {
+		return &Args{}
+	},
+}
+
+// Args represents query arguments.
+//
+// It is forbidden copying Args instances. Create new instances instead
+// and use CopyTo().
+//
+// Args instance MUST NOT be used from concurrently running goroutines.
+type Args struct {
+	noCopy noCopy
+
+	args []argsKV
+	buf  []byte
+}
+
+type argsKV struct {
+	key   []byte
+	value []byte
+}
+
+// Reset clears query args.
+func (a *Args) Reset() {
+	a.args = a.args[:0]
+}
+
+// CopyTo copies all args to dst.
+func (a *Args) CopyTo(dst *Args) {
+	dst.Reset()
+	dst.args = copyArgs(dst.args, a.args)
+}
+
+// VisitAll calls f for each existing arg.
+//
+// f must not retain references to key and value after returning.
+// Make key and/or value copies if you need storing them after returning.
+func (a *Args) VisitAll(f func(key, value []byte)) {
+	visitArgs(a.args, f)
+}
+
+// Len returns the number of query args.
+func (a *Args) Len() int {
+	return len(a.args)
+}
+
+// Parse parses the given string containing query args.
+func (a *Args) Parse(s string) {
+	a.buf = append(a.buf[:0], s...)
+	a.ParseBytes(a.buf)
+}
+
+// ParseBytes parses the given b containing query args.
+func (a *Args) ParseBytes(b []byte) {
+	a.Reset()
+
+	var s argsScanner
+	s.b = b
+
+	var kv *argsKV
+	a.args, kv = allocArg(a.args)
+	for s.next(kv) {
+		if len(kv.key) > 0 || len(kv.value) > 0 {
+			a.args, kv = allocArg(a.args)
+		}
+	}
+	a.args = releaseArg(a.args)
+}
+
+// String returns string representation of query args.
+func (a *Args) String() string {
+	return string(a.QueryString())
+}
+
+// QueryString returns query string for the args.
+//
+// The returned value is valid until the next call to Args methods.
+func (a *Args) QueryString() []byte {
+	a.buf = a.AppendBytes(a.buf[:0])
+	return a.buf
+}
+
+// AppendBytes appends query string to dst and returns the extended dst.
+func (a *Args) AppendBytes(dst []byte) []byte {
+	for i, n := 0, len(a.args); i < n; i++ {
+		kv := &a.args[i]
+		dst = AppendQuotedArg(dst, kv.key)
+		if len(kv.value) > 0 {
+			dst = append(dst, '=')
+			dst = AppendQuotedArg(dst, kv.value)
+		}
+		if i+1 < n {
+			dst = append(dst, '&')
+		}
+	}
+	return dst
+}
+
+// WriteTo writes query string to w.
+//
+// WriteTo implements io.WriterTo interface.
+func (a *Args) WriteTo(w io.Writer) (int64, error) {
+	n, err := w.Write(a.QueryString())
+	return int64(n), err
+}
+
+// Del deletes argument with the given key from query args.
+func (a *Args) Del(key string) {
+	a.args = delAllArgs(a.args, key)
+}
+
+// DelBytes deletes argument with the given key from query args.
+func (a *Args) DelBytes(key []byte) {
+	a.args = delAllArgs(a.args, b2s(key))
+}
+
+// Add adds 'key=value' argument.
+//
+// Multiple values for the same key may be added.
+func (a *Args) Add(key, value string) {
+	a.args = appendArg(a.args, key, value)
+}
+
+// AddBytesK adds 'key=value' argument.
+//
+// Multiple values for the same key may be added.
+func (a *Args) AddBytesK(key []byte, value string) {
+	a.args = appendArg(a.args, b2s(key), value)
+}
+
+// AddBytesV adds 'key=value' argument.
+//
+// Multiple values for the same key may be added.
+func (a *Args) AddBytesV(key string, value []byte) {
+	a.args = appendArg(a.args, key, b2s(value))
+}
+
+// AddBytesKV adds 'key=value' argument.
+//
+// Multiple values for the same key may be added.
+func (a *Args) AddBytesKV(key, value []byte) {
+	a.args = appendArg(a.args, b2s(key), b2s(value))
+}
+
+// Set sets 'key=value' argument.
+func (a *Args) Set(key, value string) {
+	a.args = setArg(a.args, key, value)
+}
+
+// SetBytesK sets 'key=value' argument.
+func (a *Args) SetBytesK(key []byte, value string) {
+	a.args = setArg(a.args, b2s(key), value)
+}
+
+// SetBytesV sets 'key=value' argument.
+func (a *Args) SetBytesV(key string, value []byte) {
+	a.args = setArg(a.args, key, b2s(value))
+}
+
+// SetBytesKV sets 'key=value' argument.
+func (a *Args) SetBytesKV(key, value []byte) {
+	a.args = setArgBytes(a.args, key, value)
+}
+
+// Peek returns query arg value for the given key.
+//
+// Returned value is valid until the next Args call.
+func (a *Args) Peek(key string) []byte {
+	return peekArgStr(a.args, key)
+}
+
+// PeekBytes returns query arg value for the given key.
+//
+// Returned value is valid until the next Args call.
+func (a *Args) PeekBytes(key []byte) []byte {
+	return peekArgBytes(a.args, key)
+}
+
+// PeekMulti returns all the arg values for the given key.
+func (a *Args) PeekMulti(key string) [][]byte {
+	var values [][]byte
+	a.VisitAll(func(k, v []byte) {
+		if string(k) == key {
+			values = append(values, v)
+		}
+	})
+	return values
+}
+
+// PeekMultiBytes returns all the arg values for the given key.
+func (a *Args) PeekMultiBytes(key []byte) [][]byte {
+	return a.PeekMulti(b2s(key))
+}
+
+// Has returns true if the given key exists in Args.
+func (a *Args) Has(key string) bool {
+	return hasArg(a.args, key)
+}
+
+// HasBytes returns true if the given key exists in Args.
+func (a *Args) HasBytes(key []byte) bool {
+	return hasArg(a.args, b2s(key))
+}
+
+// ErrNoArgValue is returned when Args value with the given key is missing.
+var ErrNoArgValue = errors.New("no Args value for the given key")
+
+// GetUint returns uint value for the given key.
+func (a *Args) GetUint(key string) (int, error) {
+	value := a.Peek(key)
+	if len(value) == 0 {
+		return -1, ErrNoArgValue
+	}
+	return ParseUint(value)
+}
+
+// SetUint sets uint value for the given key.
+func (a *Args) SetUint(key string, value int) {
+	bb := AcquireByteBuffer()
+	bb.B = AppendUint(bb.B[:0], value)
+	a.SetBytesV(key, bb.B)
+	ReleaseByteBuffer(bb)
+}
+
+// SetUintBytes sets uint value for the given key.
+func (a *Args) SetUintBytes(key []byte, value int) {
+	a.SetUint(b2s(key), value)
+}
+
+// GetUintOrZero returns uint value for the given key.
+//
+// Zero (0) is returned on error.
+func (a *Args) GetUintOrZero(key string) int {
+	n, err := a.GetUint(key)
+	if err != nil {
+		n = 0
+	}
+	return n
+}
+
+// GetUfloat returns ufloat value for the given key.
+func (a *Args) GetUfloat(key string) (float64, error) {
+	value := a.Peek(key)
+	if len(value) == 0 {
+		return -1, ErrNoArgValue
+	}
+	return ParseUfloat(value)
+}
+
+// GetUfloatOrZero returns ufloat value for the given key.
+//
+// Zero (0) is returned on error.
+func (a *Args) GetUfloatOrZero(key string) float64 {
+	f, err := a.GetUfloat(key)
+	if err != nil {
+		f = 0
+	}
+	return f
+}
+
+func visitArgs(args []argsKV, f func(k, v []byte)) {
+	for i, n := 0, len(args); i < n; i++ {
+		kv := &args[i]
+		f(kv.key, kv.value)
+	}
+}
+
+func copyArgs(dst, src []argsKV) []argsKV {
+	if cap(dst) < len(src) {
+		tmp := make([]argsKV, len(src))
+		copy(tmp, dst)
+		dst = tmp
+	}
+	n := len(src)
+	dst = dst[:n]
+	for i := 0; i < n; i++ {
+		dstKV := &dst[i]
+		srcKV := &src[i]
+		dstKV.key = append(dstKV.key[:0], srcKV.key...)
+		dstKV.value = append(dstKV.value[:0], srcKV.value...)
+	}
+	return dst
+}
+
+func delAllArgsBytes(args []argsKV, key []byte) []argsKV {
+	return delAllArgs(args, b2s(key))
+}
+
+func delAllArgs(args []argsKV, key string) []argsKV {
+	for i, n := 0, len(args); i < n; i++ {
+		kv := &args[i]
+		if key == string(kv.key) {
+			tmp := *kv
+			copy(args[i:], args[i+1:])
+			n--
+			args[n] = tmp
+			args = args[:n]
+		}
+	}
+	return args
+}
+
+func setArgBytes(h []argsKV, key, value []byte) []argsKV {
+	return setArg(h, b2s(key), b2s(value))
+}
+
+func setArg(h []argsKV, key, value string) []argsKV {
+	n := len(h)
+	for i := 0; i < n; i++ {
+		kv := &h[i]
+		if key == string(kv.key) {
+			kv.value = append(kv.value[:0], value...)
+			return h
+		}
+	}
+	return appendArg(h, key, value)
+}
+
+func appendArgBytes(h []argsKV, key, value []byte) []argsKV {
+	return appendArg(h, b2s(key), b2s(value))
+}
+
+func appendArg(args []argsKV, key, value string) []argsKV {
+	var kv *argsKV
+	args, kv = allocArg(args)
+	kv.key = append(kv.key[:0], key...)
+	kv.value = append(kv.value[:0], value...)
+	return args
+}
+
+func allocArg(h []argsKV) ([]argsKV, *argsKV) {
+	n := len(h)
+	if cap(h) > n {
+		h = h[:n+1]
+	} else {
+		h = append(h, argsKV{})
+	}
+	return h, &h[n]
+}
+
+func releaseArg(h []argsKV) []argsKV {
+	return h[:len(h)-1]
+}
+
+func hasArg(h []argsKV, key string) bool {
+	for i, n := 0, len(h); i < n; i++ {
+		kv := &h[i]
+		if key == string(kv.key) {
+			return true
+		}
+	}
+	return false
+}
+
+func peekArgBytes(h []argsKV, k []byte) []byte {
+	for i, n := 0, len(h); i < n; i++ {
+		kv := &h[i]
+		if bytes.Equal(kv.key, k) {
+			return kv.value
+		}
+	}
+	return nil
+}
+
+func peekArgStr(h []argsKV, k string) []byte {
+	for i, n := 0, len(h); i < n; i++ {
+		kv := &h[i]
+		if string(kv.key) == k {
+			return kv.value
+		}
+	}
+	return nil
+}
+
+type argsScanner struct {
+	b []byte
+}
+
+func (s *argsScanner) next(kv *argsKV) bool {
+	if len(s.b) == 0 {
+		return false
+	}
+
+	isKey := true
+	k := 0
+	for i, c := range s.b {
+		switch c {
+		case '=':
+			if isKey {
+				isKey = false
+				kv.key = decodeArg(kv.key, s.b[:i], true)
+				k = i + 1
+			}
+		case '&':
+			if isKey {
+				kv.key = decodeArg(kv.key, s.b[:i], true)
+				kv.value = kv.value[:0]
+			} else {
+				kv.value = decodeArg(kv.value, s.b[k:i], true)
+			}
+			s.b = s.b[i+1:]
+			return true
+		}
+	}
+
+	if isKey {
+		kv.key = decodeArg(kv.key, s.b, true)
+		kv.value = kv.value[:0]
+	} else {
+		kv.value = decodeArg(kv.value, s.b[k:], true)
+	}
+	s.b = s.b[len(s.b):]
+	return true
+}
+
+func decodeArg(dst, src []byte, decodePlus bool) []byte {
+	return decodeArgAppend(dst[:0], src, decodePlus)
+}
+
+func decodeArgAppend(dst, src []byte, decodePlus bool) []byte {
+	for i, n := 0, len(src); i < n; i++ {
+		c := src[i]
+		if c == '%' {
+			if i+2 >= n {
+				return append(dst, src[i:]...)
+			}
+			x1 := hexbyte2int(src[i+1])
+			x2 := hexbyte2int(src[i+2])
+			if x1 < 0 || x2 < 0 {
+				dst = append(dst, c)
+			} else {
+				dst = append(dst, byte(x1<<4|x2))
+				i += 2
+			}
+		} else if decodePlus && c == '+' {
+			dst = append(dst, ' ')
+		} else {
+			dst = append(dst, c)
+		}
+	}
+	return dst
+}

vendor/github.com/valyala/fasthttp/bytebuffer.go

@@ -0,0 +1,64 @@
+package fasthttp
+
+import (
+	"github.com/valyala/bytebufferpool"
+)
+
+// ByteBuffer provides byte buffer, which can be used with fasthttp API
+// in order to minimize memory allocations.
+//
+// ByteBuffer may be used with functions appending data to the given []byte
+// slice. See example code for details.
+//
+// Use AcquireByteBuffer for obtaining an empty byte buffer.
+//
+// ByteBuffer is deprecated. Use github.com/valyala/bytebufferpool instead.
+type ByteBuffer bytebufferpool.ByteBuffer
+
+// Write implements io.Writer - it appends p to ByteBuffer.B
+func (b *ByteBuffer) Write(p []byte) (int, error) {
+	return bb(b).Write(p)
+}
+
+// WriteString appends s to ByteBuffer.B
+func (b *ByteBuffer) WriteString(s string) (int, error) {
+	return bb(b).WriteString(s)
+}
+
+// Set sets ByteBuffer.B to p
+func (b *ByteBuffer) Set(p []byte) {
+	bb(b).Set(p)
+}
+
+// SetString sets ByteBuffer.B to s
+func (b *ByteBuffer) SetString(s string) {
+	bb(b).SetString(s)
+}
+
+// Reset makes ByteBuffer.B empty.
+func (b *ByteBuffer) Reset() {
+	bb(b).Reset()
+}
+
+// AcquireByteBuffer returns an empty byte buffer from the pool.
+//
+// Acquired byte buffer may be returned to the pool via ReleaseByteBuffer call.
+// This reduces the number of memory allocations required for byte buffer
+// management.
+func AcquireByteBuffer() *ByteBuffer {
+	return (*ByteBuffer)(defaultByteBufferPool.Get())
+}
+
+// ReleaseByteBuffer returns byte buffer to the pool.
+//
+// ByteBuffer.B mustn't be touched after returning it to the pool.
+// Otherwise data races occur.
+func ReleaseByteBuffer(b *ByteBuffer) {
+	defaultByteBufferPool.Put(bb(b))
+}
+
+func bb(b *ByteBuffer) *bytebufferpool.ByteBuffer {
+	return (*bytebufferpool.ByteBuffer)(b)
+}
+
+var defaultByteBufferPool bytebufferpool.Pool

vendor/github.com/valyala/fasthttp/bytesconv.go

@@ -0,0 +1,422 @@
+package fasthttp
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"net"
+	"reflect"
+	"sync"
+	"time"
+	"unsafe"
+)
+
+// AppendHTMLEscape appends html-escaped s to dst and returns the extended dst.
+func AppendHTMLEscape(dst []byte, s string) []byte {
+	var prev int
+	var sub string
+	for i, n := 0, len(s); i < n; i++ {
+		sub = ""
+		switch s[i] {
+		case '<':
+			sub = "&lt;"
+		case '>':
+			sub = "&gt;"
+		case '"':
+			sub = "&quot;"
+		case '\'':
+			sub = "&#39;"
+		}
+		if len(sub) > 0 {
+			dst = append(dst, s[prev:i]...)
+			dst = append(dst, sub...)
+			prev = i + 1
+		}
+	}
+	return append(dst, s[prev:]...)
+}
+
+// AppendHTMLEscapeBytes appends html-escaped s to dst and returns
+// the extended dst.
+func AppendHTMLEscapeBytes(dst, s []byte) []byte {
+	return AppendHTMLEscape(dst, b2s(s))
+}
+
+// AppendIPv4 appends string representation of the given ip v4 to dst
+// and returns the extended dst.
+func AppendIPv4(dst []byte, ip net.IP) []byte {
+	ip = ip.To4()
+	if ip == nil {
+		return append(dst, "non-v4 ip passed to AppendIPv4"...)
+	}
+
+	dst = AppendUint(dst, int(ip[0]))
+	for i := 1; i < 4; i++ {
+		dst = append(dst, '.')
+		dst = AppendUint(dst, int(ip[i]))
+	}
+	return dst
+}
+
+var errEmptyIPStr = errors.New("empty ip address string")
+
+// ParseIPv4 parses ip address from ipStr into dst and returns the extended dst.
+func ParseIPv4(dst net.IP, ipStr []byte) (net.IP, error) {
+	if len(ipStr) == 0 {
+		return dst, errEmptyIPStr
+	}
+	if len(dst) < net.IPv4len {
+		dst = make([]byte, net.IPv4len)
+	}
+	copy(dst, net.IPv4zero)
+	dst = dst.To4()
+	if dst == nil {
+		panic("BUG: dst must not be nil")
+	}
+
+	b := ipStr
+	for i := 0; i < 3; i++ {
+		n := bytes.IndexByte(b, '.')
+		if n < 0 {
+			return dst, fmt.Errorf("cannot find dot in ipStr %q", ipStr)
+		}
+		v, err := ParseUint(b[:n])
+		if err != nil {
+			return dst, fmt.Errorf("cannot parse ipStr %q: %s", ipStr, err)
+		}
+		if v > 255 {
+			return dst, fmt.Errorf("cannot parse ipStr %q: ip part cannot exceed 255: parsed %d", ipStr, v)
+		}
+		dst[i] = byte(v)
+		b = b[n+1:]
+	}
+	v, err := ParseUint(b)
+	if err != nil {
+		return dst, fmt.Errorf("cannot parse ipStr %q: %s", ipStr, err)
+	}
+	if v > 255 {
+		return dst, fmt.Errorf("cannot parse ipStr %q: ip part cannot exceed 255: parsed %d", ipStr, v)
+	}
+	dst[3] = byte(v)
+
+	return dst, nil
+}
+
+// AppendHTTPDate appends HTTP-compliant (RFC1123) representation of date
+// to dst and returns the extended dst.
+func AppendHTTPDate(dst []byte, date time.Time) []byte {
+	dst = date.In(time.UTC).AppendFormat(dst, time.RFC1123)
+	copy(dst[len(dst)-3:], strGMT)
+	return dst
+}
+
+// ParseHTTPDate parses HTTP-compliant (RFC1123) date.
+func ParseHTTPDate(date []byte) (time.Time, error) {
+	return time.Parse(time.RFC1123, b2s(date))
+}
+
+// AppendUint appends n to dst and returns the extended dst.
+func AppendUint(dst []byte, n int) []byte {
+	if n < 0 {
+		panic("BUG: int must be positive")
+	}
+
+	var b [20]byte
+	buf := b[:]
+	i := len(buf)
+	var q int
+	for n >= 10 {
+		i--
+		q = n / 10
+		buf[i] = '0' + byte(n-q*10)
+		n = q
+	}
+	i--
+	buf[i] = '0' + byte(n)
+
+	dst = append(dst, buf[i:]...)
+	return dst
+}
+
+// ParseUint parses uint from buf.
+func ParseUint(buf []byte) (int, error) {
+	v, n, err := parseUintBuf(buf)
+	if n != len(buf) {
+		return -1, errUnexpectedTrailingChar
+	}
+	return v, err
+}
+
+var (
+	errEmptyInt               = errors.New("empty integer")
+	errUnexpectedFirstChar    = errors.New("unexpected first char found. Expecting 0-9")
+	errUnexpectedTrailingChar = errors.New("unexpected traling char found. Expecting 0-9")
+	errTooLongInt             = errors.New("too long int")
+)
+
+func parseUintBuf(b []byte) (int, int, error) {
+	n := len(b)
+	if n == 0 {
+		return -1, 0, errEmptyInt
+	}
+	v := 0
+	for i := 0; i < n; i++ {
+		c := b[i]
+		k := c - '0'
+		if k > 9 {
+			if i == 0 {
+				return -1, i, errUnexpectedFirstChar
+			}
+			return v, i, nil
+		}
+		if i >= maxIntChars {
+			return -1, i, errTooLongInt
+		}
+		v = 10*v + int(k)
+	}
+	return v, n, nil
+}
+
+var (
+	errEmptyFloat           = errors.New("empty float number")
+	errDuplicateFloatPoint  = errors.New("duplicate point found in float number")
+	errUnexpectedFloatEnd   = errors.New("unexpected end of float number")
+	errInvalidFloatExponent = errors.New("invalid float number exponent")
+	errUnexpectedFloatChar  = errors.New("unexpected char found in float number")
+)
+
+// ParseUfloat parses unsigned float from buf.
+func ParseUfloat(buf []byte) (float64, error) {
+	if len(buf) == 0 {
+		return -1, errEmptyFloat
+	}
+	b := buf
+	var v uint64
+	var offset = 1.0
+	var pointFound bool
+	for i, c := range b {
+		if c < '0' || c > '9' {
+			if c == '.' {
+				if pointFound {
+					return -1, errDuplicateFloatPoint
+				}
+				pointFound = true
+				continue
+			}
+			if c == 'e' || c == 'E' {
+				if i+1 >= len(b) {
+					return -1, errUnexpectedFloatEnd
+				}
+				b = b[i+1:]
+				minus := -1
+				switch b[0] {
+				case '+':
+					b = b[1:]
+					minus = 1
+				case '-':
+					b = b[1:]
+				default:
+					minus = 1
+				}
+				vv, err := ParseUint(b)
+				if err != nil {
+					return -1, errInvalidFloatExponent
+				}
+				return float64(v) * offset * math.Pow10(minus*int(vv)), nil
+			}
+			return -1, errUnexpectedFloatChar
+		}
+		v = 10*v + uint64(c-'0')
+		if pointFound {
+			offset /= 10
+		}
+	}
+	return float64(v) * offset, nil
+}
+
+var (
+	errEmptyHexNum    = errors.New("empty hex number")
+	errTooLargeHexNum = errors.New("too large hex number")
+)
+
+func readHexInt(r *bufio.Reader) (int, error) {
+	n := 0
+	i := 0
+	var k int
+	for {
+		c, err := r.ReadByte()
+		if err != nil {
+			if err == io.EOF && i > 0 {
+				return n, nil
+			}
+			return -1, err
+		}
+		k = hexbyte2int(c)
+		if k < 0 {
+			if i == 0 {
+				return -1, errEmptyHexNum
+			}
+			r.UnreadByte()
+			return n, nil
+		}
+		if i >= maxHexIntChars {
+			return -1, errTooLargeHexNum
+		}
+		n = (n << 4) | k
+		i++
+	}
+}
+
+var hexIntBufPool sync.Pool
+
+func writeHexInt(w *bufio.Writer, n int) error {
+	if n < 0 {
+		panic("BUG: int must be positive")
+	}
+
+	v := hexIntBufPool.Get()
+	if v == nil {
+		v = make([]byte, maxHexIntChars+1)
+	}
+	buf := v.([]byte)
+	i := len(buf) - 1
+	for {
+		buf[i] = int2hexbyte(n & 0xf)
+		n >>= 4
+		if n == 0 {
+			break
+		}
+		i--
+	}
+	_, err := w.Write(buf[i:])
+	hexIntBufPool.Put(v)
+	return err
+}
+
+func int2hexbyte(n int) byte {
+	if n < 10 {
+		return '0' + byte(n)
+	}
+	return 'a' + byte(n) - 10
+}
+
+func hexCharUpper(c byte) byte {
+	if c < 10 {
+		return '0' + c
+	}
+	return c - 10 + 'A'
+}
+
+var hex2intTable = func() []byte {
+	b := make([]byte, 255)
+	for i := byte(0); i < 255; i++ {
+		c := byte(0)
+		if i >= '0' && i <= '9' {
+			c = 1 + i - '0'
+		} else if i >= 'a' && i <= 'f' {
+			c = 1 + i - 'a' + 10
+		} else if i >= 'A' && i <= 'F' {
+			c = 1 + i - 'A' + 10
+		}
+		b[i] = c
+	}
+	return b
+}()
+
+func hexbyte2int(c byte) int {
+	return int(hex2intTable[c]) - 1
+}
+
+const toLower = 'a' - 'A'
+
+func uppercaseByte(p *byte) {
+	c := *p
+	if c >= 'a' && c <= 'z' {
+		*p = c - toLower
+	}
+}
+
+func lowercaseByte(p *byte) {
+	c := *p
+	if c >= 'A' && c <= 'Z' {
+		*p = c + toLower
+	}
+}
+
+func lowercaseBytes(b []byte) {
+	for i, n := 0, len(b); i < n; i++ {
+		lowercaseByte(&b[i])
+	}
+}
+
+// b2s converts byte slice to a string without memory allocation.
+// See https://groups.google.com/forum/#!msg/Golang-Nuts/ENgbUzYvCuU/90yGx7GUAgAJ .
+//
+// Note it may break if string and/or slice header will change
+// in the future go versions.
+func b2s(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}
+
+// s2b converts string to a byte slice without memory allocation.
+//
+// Note it may break if string and/or slice header will change
+// in the future go versions.
+func s2b(s string) []byte {
+	sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
+	bh := reflect.SliceHeader{
+		Data: sh.Data,
+		Len:  sh.Len,
+		Cap:  sh.Len,
+	}
+	return *(*[]byte)(unsafe.Pointer(&bh))
+}
+
+// AppendQuotedArg appends url-encoded src to dst and returns appended dst.
+func AppendQuotedArg(dst, src []byte) []byte {
+	for _, c := range src {
+		// See http://www.w3.org/TR/html5/forms.html#form-submission-algorithm
+		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' ||
+			c == '*' || c == '-' || c == '.' || c == '_' {
+			dst = append(dst, c)
+		} else {
+			dst = append(dst, '%', hexCharUpper(c>>4), hexCharUpper(c&15))
+		}
+	}
+	return dst
+}
+
+func appendQuotedPath(dst, src []byte) []byte {
+	for _, c := range src {
+		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' ||
+			c == '/' || c == '.' || c == ',' || c == '=' || c == ':' || c == '&' || c == '~' || c == '-' || c == '_' {
+			dst = append(dst, c)
+		} else {
+			dst = append(dst, '%', hexCharUpper(c>>4), hexCharUpper(c&15))
+		}
+	}
+	return dst
+}
+
+// EqualBytesStr returns true if string(b) == s.
+//
+// This function has no performance benefits comparing to string(b) == s.
+// It is left here for backwards compatibility only.
+//
+// This function is deperecated and may be deleted soon.
+func EqualBytesStr(b []byte, s string) bool {
+	return string(b) == s
+}
+
+// AppendBytesStr appends src to dst and returns the extended dst.
+//
+// This function has no performance benefits comparing to append(dst, src...).
+// It is left here for backwards compatibility only.
+//
+// This function is deprecated and may be deleted soon.
+func AppendBytesStr(dst []byte, src string) []byte {
+	return append(dst, src...)
+}

vendor/github.com/valyala/fasthttp/bytesconv_32.go

@@ -0,0 +1,8 @@
+// +build !amd64,!arm64,!ppc64
+
+package fasthttp
+
+const (
+	maxIntChars    = 9
+	maxHexIntChars = 7
+)

vendor/github.com/valyala/fasthttp/bytesconv_64.go

@@ -0,0 +1,8 @@
+// +build amd64 arm64 ppc64
+
+package fasthttp
+
+const (
+	maxIntChars    = 18
+	maxHexIntChars = 15
+)

vendor/github.com/valyala/fasthttp/compress.go

@@ -0,0 +1,291 @@
+package fasthttp
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sync"
+
+	"github.com/klauspost/compress/flate"
+	"github.com/klauspost/compress/gzip"
+	"github.com/klauspost/compress/zlib"
+	"github.com/valyala/fasthttp/stackless"
+)
+
+// Supported compression levels.
+const (
+	CompressNoCompression      = flate.NoCompression
+	CompressBestSpeed          = flate.BestSpeed
+	CompressBestCompression    = flate.BestCompression
+	CompressDefaultCompression = flate.DefaultCompression
+)
+
+func acquireGzipReader(r io.Reader) (*gzip.Reader, error) {
+	v := gzipReaderPool.Get()
+	if v == nil {
+		return gzip.NewReader(r)
+	}
+	zr := v.(*gzip.Reader)
+	if err := zr.Reset(r); err != nil {
+		return nil, err
+	}
+	return zr, nil
+}
+
+func releaseGzipReader(zr *gzip.Reader) {
+	zr.Close()
+	gzipReaderPool.Put(zr)
+}
+
+var gzipReaderPool sync.Pool
+
+func acquireFlateReader(r io.Reader) (io.ReadCloser, error) {
+	v := flateReaderPool.Get()
+	if v == nil {
+		zr, err := zlib.NewReader(r)
+		if err != nil {
+			return nil, err
+		}
+		return zr, nil
+	}
+	zr := v.(io.ReadCloser)
+	if err := resetFlateReader(zr, r); err != nil {
+		return nil, err
+	}
+	return zr, nil
+}
+
+func releaseFlateReader(zr io.ReadCloser) {
+	zr.Close()
+	flateReaderPool.Put(zr)
+}
+
+func resetFlateReader(zr io.ReadCloser, r io.Reader) error {
+	zrr, ok := zr.(zlib.Resetter)
+	if !ok {
+		panic("BUG: zlib.Reader doesn't implement zlib.Resetter???")
+	}
+	return zrr.Reset(r, nil)
+}
+
+var flateReaderPool sync.Pool
+
+func acquireGzipWriter(w io.Writer, level int) *gzipWriter {
+	p := gzipWriterPoolMap[level]
+	if p == nil {
+		panic(fmt.Sprintf("BUG: unexpected compression level passed: %d. See compress/gzip for supported levels", level))
+	}
+
+	v := p.Get()
+	if v == nil {
+		sw := stackless.NewWriter(w, func(w io.Writer) stackless.Writer {
+			zw, err := gzip.NewWriterLevel(w, level)
+			if err != nil {
+				panic(fmt.Sprintf("BUG: unexpected error from gzip.NewWriterLevel(%d): %s", level, err))
+			}
+			return zw
+		})
+		return &gzipWriter{
+			Writer: sw,
+			p:      p,
+		}
+	}
+	zw := v.(*gzipWriter)
+	zw.Reset(w)
+	return zw
+}
+
+func releaseGzipWriter(zw *gzipWriter) {
+	zw.Close()
+	zw.p.Put(zw)
+}
+
+type gzipWriter struct {
+	stackless.Writer
+	p *sync.Pool
+}
+
+var gzipWriterPoolMap = func() map[int]*sync.Pool {
+	// Initialize pools for all the compression levels defined
+	// in https://golang.org/pkg/compress/gzip/#pkg-constants .
+	m := make(map[int]*sync.Pool, 11)
+	m[-1] = &sync.Pool{}
+	for i := 0; i < 10; i++ {
+		m[i] = &sync.Pool{}
+	}
+	return m
+}()
+
+// AppendGzipBytesLevel appends gzipped src to dst using the given
+// compression level and returns the resulting dst.
+//
+// Supported compression levels are:
+//
+//    * CompressNoCompression
+//    * CompressBestSpeed
+//    * CompressBestCompression
+//    * CompressDefaultCompression
+func AppendGzipBytesLevel(dst, src []byte, level int) []byte {
+	w := &byteSliceWriter{dst}
+	WriteGzipLevel(w, src, level)
+	return w.b
+}
+
+// WriteGzipLevel writes gzipped p to w using the given compression level
+// and returns the number of compressed bytes written to w.
+//
+// Supported compression levels are:
+//
+//    * CompressNoCompression
+//    * CompressBestSpeed
+//    * CompressBestCompression
+//    * CompressDefaultCompression
+func WriteGzipLevel(w io.Writer, p []byte, level int) (int, error) {
+	zw := acquireGzipWriter(w, level)
+	n, err := zw.Write(p)
+	releaseGzipWriter(zw)
+	return n, err
+}
+
+// WriteGzip writes gzipped p to w and returns the number of compressed
+// bytes written to w.
+func WriteGzip(w io.Writer, p []byte) (int, error) {
+	return WriteGzipLevel(w, p, CompressDefaultCompression)
+}
+
+// AppendGzipBytes appends gzipped src to dst and returns the resulting dst.
+func AppendGzipBytes(dst, src []byte) []byte {
+	return AppendGzipBytesLevel(dst, src, CompressDefaultCompression)
+}
+
+// WriteGunzip writes ungzipped p to w and returns the number of uncompressed
+// bytes written to w.
+func WriteGunzip(w io.Writer, p []byte) (int, error) {
+	r := &byteSliceReader{p}
+	zr, err := acquireGzipReader(r)
+	if err != nil {
+		return 0, err
+	}
+	n, err := copyZeroAlloc(w, zr)
+	releaseGzipReader(zr)
+	nn := int(n)
+	if int64(nn) != n {
+		return 0, fmt.Errorf("too much data gunzipped: %d", n)
+	}
+	return nn, err
+}
+
+// WriteInflate writes inflated p to w and returns the number of uncompressed
+// bytes written to w.
+func WriteInflate(w io.Writer, p []byte) (int, error) {
+	r := &byteSliceReader{p}
+	zr, err := acquireFlateReader(r)
+	if err != nil {
+		return 0, err
+	}
+	n, err := copyZeroAlloc(w, zr)
+	releaseFlateReader(zr)
+	nn := int(n)
+	if int64(nn) != n {
+		return 0, fmt.Errorf("too much data inflated: %d", n)
+	}
+	return nn, err
+}
+
+// AppendGunzipBytes append gunzipped src to dst and returns the resulting dst.
+func AppendGunzipBytes(dst, src []byte) ([]byte, error) {
+	w := &byteSliceWriter{dst}
+	_, err := WriteGunzip(w, src)
+	return w.b, err
+}
+
+type byteSliceWriter struct {
+	b []byte
+}
+
+func (w *byteSliceWriter) Write(p []byte) (int, error) {
+	w.b = append(w.b, p...)
+	return len(p), nil
+}
+
+type byteSliceReader struct {
+	b []byte
+}
+
+func (r *byteSliceReader) Read(p []byte) (int, error) {
+	if len(r.b) == 0 {
+		return 0, io.EOF
+	}
+	n := copy(p, r.b)
+	r.b = r.b[n:]
+	return n, nil
+}
+
+func acquireFlateWriter(w io.Writer, level int) *flateWriter {
+	p := flateWriterPoolMap[level]
+	if p == nil {
+		panic(fmt.Sprintf("BUG: unexpected compression level passed: %d. See compress/flate for supported levels", level))
+	}
+
+	v := p.Get()
+	if v == nil {
+		sw := stackless.NewWriter(w, func(w io.Writer) stackless.Writer {
+			zw, err := zlib.NewWriterLevel(w, level)
+			if err != nil {
+				panic(fmt.Sprintf("BUG: unexpected error in zlib.NewWriterLevel(%d): %s", level, err))
+			}
+			return zw
+		})
+		return &flateWriter{
+			Writer: sw,
+			p:      p,
+		}
+	}
+	zw := v.(*flateWriter)
+	zw.Reset(w)
+	return zw
+}
+
+func releaseFlateWriter(zw *flateWriter) {
+	zw.Close()
+	zw.p.Put(zw)
+}
+
+type flateWriter struct {
+	stackless.Writer
+	p *sync.Pool
+}
+
+var flateWriterPoolMap = func() map[int]*sync.Pool {
+	// Initialize pools for all the compression levels defined
+	// in https://golang.org/pkg/compress/flate/#pkg-constants .
+	m := make(map[int]*sync.Pool, 11)
+	m[-1] = &sync.Pool{}
+	for i := 0; i < 10; i++ {
+		m[i] = &sync.Pool{}
+	}
+	return m
+}()
+
+func isFileCompressible(f *os.File, minCompressRatio float64) bool {
+	// Try compressing the first 4kb of of the file
+	// and see if it can be compressed by more than
+	// the given minCompressRatio.
+	b := AcquireByteBuffer()
+	zw := acquireGzipWriter(b, CompressDefaultCompression)
+	lr := &io.LimitedReader{
+		R: f,
+		N: 4096,
+	}
+	_, err := copyZeroAlloc(zw, lr)
+	releaseGzipWriter(zw)
+	f.Seek(0, 0)
+	if err != nil {
+		return false
+	}
+
+	n := 4096 - lr.N
+	zn := len(b.B)
+	ReleaseByteBuffer(b)
+	return float64(zn) < float64(n)*minCompressRatio
+}

vendor/github.com/valyala/fasthttp/cookie.go

@@ -0,0 +1,396 @@
+package fasthttp
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"sync"
+	"time"
+)
+
+var zeroTime time.Time
+
+var (
+	// CookieExpireDelete may be set on Cookie.Expire for expiring the given cookie.
+	CookieExpireDelete = time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
+
+	// CookieExpireUnlimited indicates that the cookie doesn't expire.
+	CookieExpireUnlimited = zeroTime
+)
+
+// AcquireCookie returns an empty Cookie object from the pool.
+//
+// The returned object may be returned back to the pool with ReleaseCookie.
+// This allows reducing GC load.
+func AcquireCookie() *Cookie {
+	return cookiePool.Get().(*Cookie)
+}
+
+// ReleaseCookie returns the Cookie object acquired with AcquireCookie back
+// to the pool.
+//
+// Do not access released Cookie object, otherwise data races may occur.
+func ReleaseCookie(c *Cookie) {
+	c.Reset()
+	cookiePool.Put(c)
+}
+
+var cookiePool = &sync.Pool{
+	New: func() interface{} {
+		return &Cookie{}
+	},
+}
+
+// Cookie represents HTTP response cookie.
+//
+// Do not copy Cookie objects. Create new object and use CopyTo instead.
+//
+// Cookie instance MUST NOT be used from concurrently running goroutines.
+type Cookie struct {
+	noCopy noCopy
+
+	key    []byte
+	value  []byte
+	expire time.Time
+	domain []byte
+	path   []byte
+
+	httpOnly bool
+	secure   bool
+
+	bufKV argsKV
+	buf   []byte
+}
+
+// CopyTo copies src cookie to c.
+func (c *Cookie) CopyTo(src *Cookie) {
+	c.Reset()
+	c.key = append(c.key[:0], src.key...)
+	c.value = append(c.value[:0], src.value...)
+	c.expire = src.expire
+	c.domain = append(c.domain[:0], src.domain...)
+	c.path = append(c.path[:0], src.path...)
+	c.httpOnly = src.httpOnly
+	c.secure = src.secure
+}
+
+// HTTPOnly returns true if the cookie is http only.
+func (c *Cookie) HTTPOnly() bool {
+	return c.httpOnly
+}
+
+// SetHTTPOnly sets cookie's httpOnly flag to the given value.
+func (c *Cookie) SetHTTPOnly(httpOnly bool) {
+	c.httpOnly = httpOnly
+}
+
+// Secure returns true if the cookie is secure.
+func (c *Cookie) Secure() bool {
+	return c.secure
+}
+
+// SetSecure sets cookie's secure flag to the given value.
+func (c *Cookie) SetSecure(secure bool) {
+	c.secure = secure
+}
+
+// Path returns cookie path.
+func (c *Cookie) Path() []byte {
+	return c.path
+}
+
+// SetPath sets cookie path.
+func (c *Cookie) SetPath(path string) {
+	c.buf = append(c.buf[:0], path...)
+	c.path = normalizePath(c.path, c.buf)
+}
+
+// SetPathBytes sets cookie path.
+func (c *Cookie) SetPathBytes(path []byte) {
+	c.buf = append(c.buf[:0], path...)
+	c.path = normalizePath(c.path, c.buf)
+}
+
+// Domain returns cookie domain.
+//
+// The returned domain is valid until the next Cookie modification method call.
+func (c *Cookie) Domain() []byte {
+	return c.domain
+}
+
+// SetDomain sets cookie domain.
+func (c *Cookie) SetDomain(domain string) {
+	c.domain = append(c.domain[:0], domain...)
+}
+
+// SetDomainBytes sets cookie domain.
+func (c *Cookie) SetDomainBytes(domain []byte) {
+	c.domain = append(c.domain[:0], domain...)
+}
+
+// Expire returns cookie expiration time.
+//
+// CookieExpireUnlimited is returned if cookie doesn't expire
+func (c *Cookie) Expire() time.Time {
+	expire := c.expire
+	if expire.IsZero() {
+		expire = CookieExpireUnlimited
+	}
+	return expire
+}
+
+// SetExpire sets cookie expiration time.
+//
+// Set expiration time to CookieExpireDelete for expiring (deleting)
+// the cookie on the client.
+//
+// By default cookie lifetime is limited by browser session.
+func (c *Cookie) SetExpire(expire time.Time) {
+	c.expire = expire
+}
+
+// Value returns cookie value.
+//
+// The returned value is valid until the next Cookie modification method call.
+func (c *Cookie) Value() []byte {
+	return c.value
+}
+
+// SetValue sets cookie value.
+func (c *Cookie) SetValue(value string) {
+	c.value = append(c.value[:0], value...)
+}
+
+// SetValueBytes sets cookie value.
+func (c *Cookie) SetValueBytes(value []byte) {
+	c.value = append(c.value[:0], value...)
+}
+
+// Key returns cookie name.
+//
+// The returned value is valid until the next Cookie modification method call.
+func (c *Cookie) Key() []byte {
+	return c.key
+}
+
+// SetKey sets cookie name.
+func (c *Cookie) SetKey(key string) {
+	c.key = append(c.key[:0], key...)
+}
+
+// SetKeyBytes sets cookie name.
+func (c *Cookie) SetKeyBytes(key []byte) {
+	c.key = append(c.key[:0], key...)
+}
+
+// Reset clears the cookie.
+func (c *Cookie) Reset() {
+	c.key = c.key[:0]
+	c.value = c.value[:0]
+	c.expire = zeroTime
+	c.domain = c.domain[:0]
+	c.path = c.path[:0]
+	c.httpOnly = false
+	c.secure = false
+}
+
+// AppendBytes appends cookie representation to dst and returns
+// the extended dst.
+func (c *Cookie) AppendBytes(dst []byte) []byte {
+	if len(c.key) > 0 {
+		dst = append(dst, c.key...)
+		dst = append(dst, '=')
+	}
+	dst = append(dst, c.value...)
+
+	if !c.expire.IsZero() {
+		c.bufKV.value = AppendHTTPDate(c.bufKV.value[:0], c.expire)
+		dst = append(dst, ';', ' ')
+		dst = append(dst, strCookieExpires...)
+		dst = append(dst, '=')
+		dst = append(dst, c.bufKV.value...)
+	}
+	if len(c.domain) > 0 {
+		dst = appendCookiePart(dst, strCookieDomain, c.domain)
+	}
+	if len(c.path) > 0 {
+		dst = appendCookiePart(dst, strCookiePath, c.path)
+	}
+	if c.httpOnly {
+		dst = append(dst, ';', ' ')
+		dst = append(dst, strCookieHTTPOnly...)
+	}
+	if c.secure {
+		dst = append(dst, ';', ' ')
+		dst = append(dst, strCookieSecure...)
+	}
+	return dst
+}
+
+// Cookie returns cookie representation.
+//
+// The returned value is valid until the next call to Cookie methods.
+func (c *Cookie) Cookie() []byte {
+	c.buf = c.AppendBytes(c.buf[:0])
+	return c.buf
+}
+
+// String returns cookie representation.
+func (c *Cookie) String() string {
+	return string(c.Cookie())
+}
+
+// WriteTo writes cookie representation to w.
+//
+// WriteTo implements io.WriterTo interface.
+func (c *Cookie) WriteTo(w io.Writer) (int64, error) {
+	n, err := w.Write(c.Cookie())
+	return int64(n), err
+}
+
+var errNoCookies = errors.New("no cookies found")
+
+// Parse parses Set-Cookie header.
+func (c *Cookie) Parse(src string) error {
+	c.buf = append(c.buf[:0], src...)
+	return c.ParseBytes(c.buf)
+}
+
+// ParseBytes parses Set-Cookie header.
+func (c *Cookie) ParseBytes(src []byte) error {
+	c.Reset()
+
+	var s cookieScanner
+	s.b = src
+
+	kv := &c.bufKV
+	if !s.next(kv) {
+		return errNoCookies
+	}
+
+	c.key = append(c.key[:0], kv.key...)
+	c.value = append(c.value[:0], kv.value...)
+
+	for s.next(kv) {
+		if len(kv.key) == 0 && len(kv.value) == 0 {
+			continue
+		}
+		switch string(kv.key) {
+		case "expires":
+			v := b2s(kv.value)
+			exptime, err := time.ParseInLocation(time.RFC1123, v, time.UTC)
+			if err != nil {
+				return err
+			}
+			c.expire = exptime
+		case "domain":
+			c.domain = append(c.domain[:0], kv.value...)
+		case "path":
+			c.path = append(c.path[:0], kv.value...)
+		case "":
+			switch string(kv.value) {
+			case "HttpOnly":
+				c.httpOnly = true
+			case "secure":
+				c.secure = true
+			}
+		}
+	}
+	return nil
+}
+
+func appendCookiePart(dst, key, value []byte) []byte {
+	dst = append(dst, ';', ' ')
+	dst = append(dst, key...)
+	dst = append(dst, '=')
+	return append(dst, value...)
+}
+
+func getCookieKey(dst, src []byte) []byte {
+	n := bytes.IndexByte(src, '=')
+	if n >= 0 {
+		src = src[:n]
+	}
+	return decodeCookieArg(dst, src, false)
+}
+
+func appendRequestCookieBytes(dst []byte, cookies []argsKV) []byte {
+	for i, n := 0, len(cookies); i < n; i++ {
+		kv := &cookies[i]
+		if len(kv.key) > 0 {
+			dst = append(dst, kv.key...)
+			dst = append(dst, '=')
+		}
+		dst = append(dst, kv.value...)
+		if i+1 < n {
+			dst = append(dst, ';', ' ')
+		}
+	}
+	return dst
+}
+
+func parseRequestCookies(cookies []argsKV, src []byte) []argsKV {
+	var s cookieScanner
+	s.b = src
+	var kv *argsKV
+	cookies, kv = allocArg(cookies)
+	for s.next(kv) {
+		if len(kv.key) > 0 || len(kv.value) > 0 {
+			cookies, kv = allocArg(cookies)
+		}
+	}
+	return releaseArg(cookies)
+}
+
+type cookieScanner struct {
+	b []byte
+}
+
+func (s *cookieScanner) next(kv *argsKV) bool {
+	b := s.b
+	if len(b) == 0 {
+		return false
+	}
+
+	isKey := true
+	k := 0
+	for i, c := range b {
+		switch c {
+		case '=':
+			if isKey {
+				isKey = false
+				kv.key = decodeCookieArg(kv.key, b[:i], false)
+				k = i + 1
+			}
+		case ';':
+			if isKey {
+				kv.key = kv.key[:0]
+			}
+			kv.value = decodeCookieArg(kv.value, b[k:i], true)
+			s.b = b[i+1:]
+			return true
+		}
+	}
+
+	if isKey {
+		kv.key = kv.key[:0]
+	}
+	kv.value = decodeCookieArg(kv.value, b[k:], true)
+	s.b = b[len(b):]
+	return true
+}
+
+func decodeCookieArg(dst, src []byte, skipQuotes bool) []byte {
+	for len(src) > 0 && src[0] == ' ' {
+		src = src[1:]
+	}
+	for len(src) > 0 && src[len(src)-1] == ' ' {
+		src = src[:len(src)-1]
+	}
+	if skipQuotes {
+		if len(src) > 1 && src[0] == '"' && src[len(src)-1] == '"' {
+			src = src[1 : len(src)-1]
+		}
+	}
+	return append(dst[:0], src...)
+}

vendor/github.com/valyala/fasthttp/doc.go

@@ -0,0 +1,40 @@
+/*
+Package fasthttp provides fast HTTP server and client API.
+
+Fasthttp provides the following features:
+
+    * Optimized for speed. Easily handles more than 100K qps and more than 1M
+      concurrent keep-alive connections on modern hardware.
+    * Optimized for low memory usage.
+    * Easy 'Connection: Upgrade' support via RequestCtx.Hijack.
+    * Server supports requests' pipelining. Multiple requests may be read from
+      a single network packet and multiple responses may be sent in a single
+      network packet. This may be useful for highly loaded REST services.
+    * Server provides the following anti-DoS limits:
+
+        * The number of concurrent connections.
+        * The number of concurrent connections per client IP.
+        * The number of requests per connection.
+        * Request read timeout.
+        * Response write timeout.
+        * Maximum request header size.
+        * Maximum request body size.
+        * Maximum request execution time.
+        * Maximum keep-alive connection lifetime.
+        * Early filtering out non-GET requests.
+
+    * A lot of additional useful info is exposed to request handler:
+
+        * Server and client address.
+        * Per-request logger.
+        * Unique request id.
+        * Request start time.
+        * Connection start time.
+        * Request sequence number for the current connection.
+
+    * Client supports automatic retry on idempotent requests' failure.
+    * Fasthttp API is designed with the ability to extend existing client
+      and server implementations or to write custom client and server
+      implementations from scratch.
+*/
+package fasthttp

vendor/github.com/valyala/fasthttp/fasthttputil/doc.go

@@ -0,0 +1,2 @@
+// Package fasthttputil provides utility functions for fasthttp.
+package fasthttputil

vendor/github.com/valyala/fasthttp/fasthttputil/inmemory_listener.go

@@ -0,0 +1,84 @@
+package fasthttputil
+
+import (
+	"fmt"
+	"net"
+	"sync"
+)
+
+// InmemoryListener provides in-memory dialer<->net.Listener implementation.
+//
+// It may be used either for fast in-process client<->server communcations
+// without network stack overhead or for client<->server tests.
+type InmemoryListener struct {
+	lock   sync.Mutex
+	closed bool
+	conns  chan net.Conn
+}
+
+// NewInmemoryListener returns new in-memory dialer<->net.Listener.
+func NewInmemoryListener() *InmemoryListener {
+	return &InmemoryListener{
+		conns: make(chan net.Conn, 1024),
+	}
+}
+
+// Accept implements net.Listener's Accept.
+//
+// It is safe calling Accept from concurrently running goroutines.
+//
+// Accept returns new connection per each Dial call.
+func (ln *InmemoryListener) Accept() (net.Conn, error) {
+	c, ok := <-ln.conns
+	if !ok {
+		return nil, fmt.Errorf("InmemoryListener is already closed: use of closed network connection")
+	}
+	return c, nil
+}
+
+// Close implements net.Listener's Close.
+func (ln *InmemoryListener) Close() error {
+	var err error
+
+	ln.lock.Lock()
+	if !ln.closed {
+		close(ln.conns)
+		ln.closed = true
+	} else {
+		err = fmt.Errorf("InmemoryListener is already closed")
+	}
+	ln.lock.Unlock()
+	return err
+}
+
+// Addr implements net.Listener's Addr.
+func (ln *InmemoryListener) Addr() net.Addr {
+	return &net.UnixAddr{
+		Name: "InmemoryListener",
+		Net:  "memory",
+	}
+}
+
+// Dial creates new client<->server connection, enqueues server side
+// of the connection to Accept and returns client side of the connection.
+//
+// It is safe calling Dial from concurrently running goroutines.
+func (ln *InmemoryListener) Dial() (net.Conn, error) {
+	pc := NewPipeConns()
+	cConn := pc.Conn1()
+	sConn := pc.Conn2()
+	ln.lock.Lock()
+	if !ln.closed {
+		ln.conns <- sConn
+	} else {
+		sConn.Close()
+		cConn.Close()
+		cConn = nil
+	}
+	ln.lock.Unlock()
+
+	if cConn == nil {
+		return nil, fmt.Errorf("InmemoryListener is already closed")
+	}
+	return cConn, nil
+}

vendor/github.com/valyala/fasthttp/fasthttputil/pipeconns.go

@@ -0,0 +1,283 @@
+package fasthttputil
+
+import (
+	"errors"
+	"io"
+	"net"
+	"sync"
+	"time"
+)
+
+// NewPipeConns returns new bi-directonal connection pipe.
+func NewPipeConns() *PipeConns {
+	ch1 := make(chan *byteBuffer, 4)
+	ch2 := make(chan *byteBuffer, 4)
+
+	pc := &PipeConns{
+		stopCh: make(chan struct{}),
+	}
+	pc.c1.rCh = ch1
+	pc.c1.wCh = ch2
+	pc.c2.rCh = ch2
+	pc.c2.wCh = ch1
+	pc.c1.pc = pc
+	pc.c2.pc = pc
+	return pc
+}
+
+// PipeConns provides bi-directional connection pipe,
+// which use in-process memory as a transport.
+//
+// PipeConns must be created by calling NewPipeConns.
+//
+// PipeConns has the following additional features comparing to connections
+// returned from net.Pipe():
+//
+//   * It is faster.
+//   * It buffers Write calls, so there is no need to have concurrent goroutine
+//     calling Read in order to unblock each Write call.
+//   * It supports read and write deadlines.
+//
+type PipeConns struct {
+	c1         pipeConn
+	c2         pipeConn
+	stopCh     chan struct{}
+	stopChLock sync.Mutex
+}
+
+// Conn1 returns the first end of bi-directional pipe.
+//
+// Data written to Conn1 may be read from Conn2.
+// Data written to Conn2 may be read from Conn1.
+func (pc *PipeConns) Conn1() net.Conn {
+	return &pc.c1
+}
+
+// Conn2 returns the second end of bi-directional pipe.
+//
+// Data written to Conn2 may be read from Conn1.
+// Data written to Conn1 may be read from Conn2.
+func (pc *PipeConns) Conn2() net.Conn {
+	return &pc.c2
+}
+
+// Close closes pipe connections.
+func (pc *PipeConns) Close() error {
+	pc.stopChLock.Lock()
+	select {
+	case <-pc.stopCh:
+	default:
+		close(pc.stopCh)
+	}
+	pc.stopChLock.Unlock()
+
+	return nil
+}
+
+type pipeConn struct {
+	b  *byteBuffer
+	bb []byte
+
+	rCh chan *byteBuffer
+	wCh chan *byteBuffer
+	pc  *PipeConns
+
+	readDeadlineTimer  *time.Timer
+	writeDeadlineTimer *time.Timer
+
+	readDeadlineCh  <-chan time.Time
+	writeDeadlineCh <-chan time.Time
+}
+
+func (c *pipeConn) Write(p []byte) (int, error) {
+	b := acquireByteBuffer()
+	b.b = append(b.b[:0], p...)
+
+	select {
+	case <-c.pc.stopCh:
+		releaseByteBuffer(b)
+		return 0, errConnectionClosed
+	default:
+	}
+
+	select {
+	case c.wCh <- b:
+	default:
+		select {
+		case c.wCh <- b:
+		case <-c.writeDeadlineCh:
+			c.writeDeadlineCh = closedDeadlineCh
+			return 0, ErrTimeout
+		case <-c.pc.stopCh:
+			releaseByteBuffer(b)
+			return 0, errConnectionClosed
+		}
+	}
+
+	return len(p), nil
+}
+
+func (c *pipeConn) Read(p []byte) (int, error) {
+	mayBlock := true
+	nn := 0
+	for len(p) > 0 {
+		n, err := c.read(p, mayBlock)
+		nn += n
+		if err != nil {
+			if !mayBlock && err == errWouldBlock {
+				err = nil
+			}
+			return nn, err
+		}
+		p = p[n:]
+		mayBlock = false
+	}
+
+	return nn, nil
+}
+
+func (c *pipeConn) read(p []byte, mayBlock bool) (int, error) {
+	if len(c.bb) == 0 {
+		if err := c.readNextByteBuffer(mayBlock); err != nil {
+			return 0, err
+		}
+	}
+	n := copy(p, c.bb)
+	c.bb = c.bb[n:]
+
+	return n, nil
+}
+
+func (c *pipeConn) readNextByteBuffer(mayBlock bool) error {
+	releaseByteBuffer(c.b)
+	c.b = nil
+
+	select {
+	case c.b = <-c.rCh:
+	default:
+		if !mayBlock {
+			return errWouldBlock
+		}
+		select {
+		case c.b = <-c.rCh:
+		case <-c.readDeadlineCh:
+			c.readDeadlineCh = closedDeadlineCh
+			// rCh may contain data when deadline is reached.
+			// Read the data before returning ErrTimeout.
+			select {
+			case c.b = <-c.rCh:
+			default:
+				return ErrTimeout
+			}
+		case <-c.pc.stopCh:
+			// rCh may contain data when stopCh is closed.
+			// Read the data before returning EOF.
+			select {
+			case c.b = <-c.rCh:
+			default:
+				return io.EOF
+			}
+		}
+	}
+
+	c.bb = c.b.b
+	return nil
+}
+
+var (
+	errWouldBlock       = errors.New("would block")
+	errConnectionClosed = errors.New("connection closed")
+
+	// ErrTimeout is returned from Read() or Write() on timeout.
+	ErrTimeout = errors.New("timeout")
+)
+
+func (c *pipeConn) Close() error {
+	return c.pc.Close()
+}
+
+func (c *pipeConn) LocalAddr() net.Addr {
+	return pipeAddr(0)
+}
+
+func (c *pipeConn) RemoteAddr() net.Addr {
+	return pipeAddr(0)
+}
+
+func (c *pipeConn) SetDeadline(deadline time.Time) error {
+	c.SetReadDeadline(deadline)
+	c.SetWriteDeadline(deadline)
+	return nil
+}
+
+func (c *pipeConn) SetReadDeadline(deadline time.Time) error {
+	if c.readDeadlineTimer == nil {
+		c.readDeadlineTimer = time.NewTimer(time.Hour)
+	}
+	c.readDeadlineCh = updateTimer(c.readDeadlineTimer, deadline)
+	return nil
+}
+
+func (c *pipeConn) SetWriteDeadline(deadline time.Time) error {
+	if c.writeDeadlineTimer == nil {
+		c.writeDeadlineTimer = time.NewTimer(time.Hour)
+	}
+	c.writeDeadlineCh = updateTimer(c.writeDeadlineTimer, deadline)
+	return nil
+}
+
+func updateTimer(t *time.Timer, deadline time.Time) <-chan time.Time {
+	if !t.Stop() {
+		select {
+		case <-t.C:
+		default:
+		}
+	}
+	if deadline.IsZero() {
+		return nil
+	}
+	d := -time.Since(deadline)
+	if d <= 0 {
+		return closedDeadlineCh
+	}
+	t.Reset(d)
+	return t.C
+}
+
+var closedDeadlineCh = func() <-chan time.Time {
+	ch := make(chan time.Time)
+	close(ch)
+	return ch
+}()
+
+type pipeAddr int
+
+func (pipeAddr) Network() string {
+	return "pipe"
+}
+
+func (pipeAddr) String() string {
+	return "pipe"
+}
+
+type byteBuffer struct {
+	b []byte
+}
+
+func acquireByteBuffer() *byteBuffer {
+	return byteBufferPool.Get().(*byteBuffer)
+}
+
+func releaseByteBuffer(b *byteBuffer) {
+	if b != nil {
+		byteBufferPool.Put(b)
+	}
+}
+
+var byteBufferPool = &sync.Pool{
+	New: func() interface{} {
+		return &byteBuffer{
+			b: make([]byte, 1024),
+		}
+	},
+}

vendor/github.com/valyala/fasthttp/fasthttputil/ssl-cert-snakeoil.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQD4IQusAs8PJdnG
+3mURt/AXtgC+ceqLOatJ49JJE1VPTkMAy+oE1f1XvkMrYsHqmDf6GWVzgVXryL4U
+wq2/nJSm56ddhN55nI8oSN3dtywUB8/ShelEN73nlN77PeD9tl6NksPwWaKrqxq0
+FlabRPZSQCfmgZbhDV8Sa8mfCkFU0G0lit6kLGceCKMvmW+9Bz7ebsYmVdmVMxmf
+IJStFD44lWFTdUc65WISKEdW2ELcUefb0zOLw+0PCbXFGJH5x5ktksW8+BBk2Hkg
+GeQRL/qPCccthbScO0VgNj3zJ3ZZL0ObSDAbvNDG85joeNjDNq5DT/BAZ0bOSbEF
+sh+f9BAzAgMBAAECggEBAJWv2cq7Jw6MVwSRxYca38xuD6TUNBopgBvjREixURW2
+sNUaLuMb9Omp7fuOaE2N5rcJ+xnjPGIxh/oeN5MQctz9gwn3zf6vY+15h97pUb4D
+uGvYPRDaT8YVGS+X9NMZ4ZCmqW2lpWzKnCFoGHcy8yZLbcaxBsRdvKzwOYGoPiFb
+K2QuhXZ/1UPmqK9i2DFKtj40X6vBszTNboFxOVpXrPu0FJwLVSDf2hSZ4fMM0DH3
+YqwKcYf5te+hxGKgrqRA3tn0NCWii0in6QIwXMC+kMw1ebg/tZKqyDLMNptAK8J+
+DVw9m5X1seUHS5ehU/g2jrQrtK5WYn7MrFK4lBzlRwECgYEA/d1TeANYECDWRRDk
+B0aaRZs87Rwl/J9PsvbsKvtU/bX+OfSOUjOa9iQBqn0LmU8GqusEET/QVUfocVwV
+Bggf/5qDLxz100Rj0ags/yE/kNr0Bb31kkkKHFMnCT06YasR7qKllwrAlPJvQv9x
+IzBKq+T/Dx08Wep9bCRSFhzRCnsCgYEA+jdeZXTDr/Vz+D2B3nAw1frqYFfGnEVY
+wqmoK3VXMDkGuxsloO2rN+SyiUo3JNiQNPDub/t7175GH5pmKtZOlftePANsUjBj
+wZ1D0rI5Bxu/71ibIUYIRVmXsTEQkh/ozoh3jXCZ9+bLgYiYx7789IUZZSokFQ3D
+FICUT9KJ36kCgYAGoq9Y1rWJjmIrYfqj2guUQC+CfxbbGIrrwZqAsRsSmpwvhZ3m
+tiSZxG0quKQB+NfSxdvQW5ulbwC7Xc3K35F+i9pb8+TVBdeaFkw+yu6vaZmxQLrX
+fQM/pEjD7A7HmMIaO7QaU5SfEAsqdCTP56Y8AftMuNXn/8IRfo2KuGwaWwKBgFpU
+ILzJoVdlad9E/Rw7LjYhZfkv1uBVXIyxyKcfrkEXZSmozDXDdxsvcZCEfVHM6Ipk
+K/+7LuMcqp4AFEAEq8wTOdq6daFaHLkpt/FZK6M4TlruhtpFOPkoNc3e45eM83OT
+6mziKINJC1CQ6m65sQHpBtjxlKMRG8rL/D6wx9s5AoGBAMRlqNPMwglT3hvDmsAt
+9Lf9pdmhERUlHhD8bj8mDaBj2Aqv7f6VRJaYZqP403pKKQexuqcn80mtjkSAPFkN
+Cj7BVt/RXm5uoxDTnfi26RF9F6yNDEJ7UU9+peBr99aazF/fTgW/1GcMkQnum8uV
+c257YgaWmjK9uB0Y2r2VxS0G
+-----END PRIVATE KEY-----

vendor/github.com/valyala/fasthttp/fasthttputil/ssl-cert-snakeoil.pem

@@ -0,0 +1,17 @@
+-----BEGIN CERTIFICATE-----
+MIICujCCAaKgAwIBAgIJAMbXnKZ/cikUMA0GCSqGSIb3DQEBCwUAMBUxEzARBgNV
+BAMTCnVidW50dS5uYW4wHhcNMTUwMjA0MDgwMTM5WhcNMjUwMjAxMDgwMTM5WjAV
+MRMwEQYDVQQDEwp1YnVudHUubmFuMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEA+CELrALPDyXZxt5lEbfwF7YAvnHqizmrSePSSRNVT05DAMvqBNX9V75D
+K2LB6pg3+hllc4FV68i+FMKtv5yUpuenXYTeeZyPKEjd3bcsFAfP0oXpRDe955Te
++z3g/bZejZLD8Fmiq6satBZWm0T2UkAn5oGW4Q1fEmvJnwpBVNBtJYrepCxnHgij
+L5lvvQc+3m7GJlXZlTMZnyCUrRQ+OJVhU3VHOuViEihHVthC3FHn29Mzi8PtDwm1
+xRiR+ceZLZLFvPgQZNh5IBnkES/6jwnHLYW0nDtFYDY98yd2WS9Dm0gwG7zQxvOY
+6HjYwzauQ0/wQGdGzkmxBbIfn/QQMwIDAQABow0wCzAJBgNVHRMEAjAAMA0GCSqG
+SIb3DQEBCwUAA4IBAQBQjKm/4KN/iTgXbLTL3i7zaxYXFLXsnT1tF+ay4VA8aj98
+L3JwRTciZ3A5iy/W4VSCt3eASwOaPWHKqDBB5RTtL73LoAqsWmO3APOGQAbixcQ2
+45GXi05OKeyiYRi1Nvq7Unv9jUkRDHUYVPZVSAjCpsXzPhFkmZoTRxmx5l0ZF7Li
+K91lI5h+eFq0dwZwrmlPambyh1vQUi70VHv8DNToVU29kel7YLbxGbuqETfhrcy6
+X+Mha6RYITkAn5FqsZcKMsc9eYGEF4l3XV+oS7q6xfTxktYJMFTI18J0lQ2Lv/CI
+whdMnYGntDQBE/iFCrJEGNsKGc38796GBOb5j+zd
+-----END CERTIFICATE-----

vendor/github.com/valyala/fasthttp/lbclient.go

@@ -0,0 +1,183 @@
+package fasthttp
+
+import (
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// BalancingClient is the interface for clients, which may be passed
+// to LBClient.Clients.
+type BalancingClient interface {
+	DoDeadline(req *Request, resp *Response, deadline time.Time) error
+	PendingRequests() int
+}
+
+// LBClient balances requests among available LBClient.Clients.
+//
+// It has the following features:
+//
+//   - Balances load among available clients using 'least loaded' + 'round robin'
+//     hybrid technique.
+//   - Dynamically decreases load on unhealthy clients.
+//
+// It is forbidden copying LBClient instances. Create new instances instead.
+//
+// It is safe calling LBClient methods from concurrently running goroutines.
+type LBClient struct {
+	noCopy noCopy
+
+	// Clients must contain non-zero clients list.
+	// Incoming requests are balanced among these clients.
+	Clients []BalancingClient
+
+	// HealthCheck is a callback called after each request.
+	//
+	// The request, response and the error returned by the client
+	// is passed to HealthCheck, so the callback may determine whether
+	// the client is healthy.
+	//
+	// Load on the current client is decreased if HealthCheck returns false.
+	//
+	// By default HealthCheck returns false if err != nil.
+	HealthCheck func(req *Request, resp *Response, err error) bool
+
+	// Timeout is the request timeout used when calling LBClient.Do.
+	//
+	// DefaultLBClientTimeout is used by default.
+	Timeout time.Duration
+
+	cs []*lbClient
+
+	// nextIdx is for spreading requests among equally loaded clients
+	// in a round-robin fashion.
+	nextIdx uint32
+
+	once sync.Once
+}
+
+// DefaultLBClientTimeout is the default request timeout used by LBClient
+// when calling LBClient.Do.
+//
+// The timeout may be overriden via LBClient.Timeout.
+const DefaultLBClientTimeout = time.Second
+
+// DoDeadline calls DoDeadline on the least loaded client
+func (cc *LBClient) DoDeadline(req *Request, resp *Response, deadline time.Time) error {
+	return cc.get().DoDeadline(req, resp, deadline)
+}
+
+// DoTimeout calculates deadline and calls DoDeadline on the least loaded client
+func (cc *LBClient) DoTimeout(req *Request, resp *Response, timeout time.Duration) error {
+	deadline := time.Now().Add(timeout)
+	return cc.get().DoDeadline(req, resp, deadline)
+}
+
+// Do calls calculates deadline using LBClient.Timeout and calls DoDeadline
+// on the least loaded client.
+func (cc *LBClient) Do(req *Request, resp *Response) error {
+	timeout := cc.Timeout
+	if timeout <= 0 {
+		timeout = DefaultLBClientTimeout
+	}
+	return cc.DoTimeout(req, resp, timeout)
+}
+
+func (cc *LBClient) init() {
+	if len(cc.Clients) == 0 {
+		panic("BUG: LBClient.Clients cannot be empty")
+	}
+	for _, c := range cc.Clients {
+		cc.cs = append(cc.cs, &lbClient{
+			c:           c,
+			healthCheck: cc.HealthCheck,
+		})
+	}
+
+	// Randomize nextIdx in order to prevent initial servers'
+	// hammering from a cluster of identical LBClients.
+	cc.nextIdx = uint32(time.Now().UnixNano())
+}
+
+func (cc *LBClient) get() *lbClient {
+	cc.once.Do(cc.init)
+
+	cs := cc.cs
+	idx := atomic.AddUint32(&cc.nextIdx, 1)
+	idx %= uint32(len(cs))
+
+	minC := cs[idx]
+	minN := minC.PendingRequests()
+	if minN == 0 {
+		return minC
+	}
+	for _, c := range cs[idx+1:] {
+		n := c.PendingRequests()
+		if n == 0 {
+			return c
+		}
+		if n < minN {
+			minC = c
+			minN = n
+		}
+	}
+	for _, c := range cs[:idx] {
+		n := c.PendingRequests()
+		if n == 0 {
+			return c
+		}
+		if n < minN {
+			minC = c
+			minN = n
+		}
+	}
+	return minC
+}
+
+type lbClient struct {
+	c           BalancingClient
+	healthCheck func(req *Request, resp *Response, err error) bool
+	penalty     uint32
+}
+
+func (c *lbClient) DoDeadline(req *Request, resp *Response, deadline time.Time) error {
+	err := c.c.DoDeadline(req, resp, deadline)
+	if !c.isHealthy(req, resp, err) && c.incPenalty() {
+		// Penalize the client returning error, so the next requests
+		// are routed to another clients.
+		time.AfterFunc(penaltyDuration, c.decPenalty)
+	}
+	return err
+}
+
+func (c *lbClient) PendingRequests() int {
+	n := c.c.PendingRequests()
+	m := atomic.LoadUint32(&c.penalty)
+	return n + int(m)
+}
+
+func (c *lbClient) isHealthy(req *Request, resp *Response, err error) bool {
+	if c.healthCheck == nil {
+		return err == nil
+	}
+	return c.healthCheck(req, resp, err)
+}
+
+func (c *lbClient) incPenalty() bool {
+	m := atomic.AddUint32(&c.penalty, 1)
+	if m > maxPenalty {
+		c.decPenalty()
+		return false
+	}
+	return true
+}
+
+func (c *lbClient) decPenalty() {
+	atomic.AddUint32(&c.penalty, ^uint32(0))
+}
+
+const (
+	maxPenalty = 300
+
+	penaltyDuration = 3 * time.Second
+)

vendor/github.com/valyala/fasthttp/nocopy.go

@@ -0,0 +1,9 @@
+package fasthttp
+
+// Embed this type into a struct, which mustn't be copied,
+// so `go vet` gives a warning if this struct is copied.
+//
+// See https://github.com/golang/go/issues/8005#issuecomment-190753527 for details.
+type noCopy struct{}
+
+func (*noCopy) Lock() {}

vendor/github.com/valyala/fasthttp/peripconn.go

@@ -0,0 +1,100 @@
+package fasthttp
+
+import (
+	"fmt"
+	"net"
+	"sync"
+)
+
+type perIPConnCounter struct {
+	pool sync.Pool
+	lock sync.Mutex
+	m    map[uint32]int
+}
+
+func (cc *perIPConnCounter) Register(ip uint32) int {
+	cc.lock.Lock()
+	if cc.m == nil {
+		cc.m = make(map[uint32]int)
+	}
+	n := cc.m[ip] + 1
+	cc.m[ip] = n
+	cc.lock.Unlock()
+	return n
+}
+
+func (cc *perIPConnCounter) Unregister(ip uint32) {
+	cc.lock.Lock()
+	if cc.m == nil {
+		cc.lock.Unlock()
+		panic("BUG: perIPConnCounter.Register() wasn't called")
+	}
+	n := cc.m[ip] - 1
+	if n < 0 {
+		cc.lock.Unlock()
+		panic(fmt.Sprintf("BUG: negative per-ip counter=%d for ip=%d", n, ip))
+	}
+	cc.m[ip] = n
+	cc.lock.Unlock()
+}
+
+type perIPConn struct {
+	net.Conn
+
+	ip               uint32
+	perIPConnCounter *perIPConnCounter
+}
+
+func acquirePerIPConn(conn net.Conn, ip uint32, counter *perIPConnCounter) *perIPConn {
+	v := counter.pool.Get()
+	if v == nil {
+		v = &perIPConn{
+			perIPConnCounter: counter,
+		}
+	}
+	c := v.(*perIPConn)
+	c.Conn = conn
+	c.ip = ip
+	return c
+}
+
+func releasePerIPConn(c *perIPConn) {
+	c.Conn = nil
+	c.perIPConnCounter.pool.Put(c)
+}
+
+func (c *perIPConn) Close() error {
+	err := c.Conn.Close()
+	c.perIPConnCounter.Unregister(c.ip)
+	releasePerIPConn(c)
+	return err
+}
+
+func getUint32IP(c net.Conn) uint32 {
+	return ip2uint32(getConnIP4(c))
+}
+
+func getConnIP4(c net.Conn) net.IP {
+	addr := c.RemoteAddr()
+	ipAddr, ok := addr.(*net.TCPAddr)
+	if !ok {
+		return net.IPv4zero
+	}
+	return ipAddr.IP.To4()
+}
+
+func ip2uint32(ip net.IP) uint32 {
+	if len(ip) != 4 {
+		return 0
+	}
+	return uint32(ip[0])<<24 | uint32(ip[1])<<16 | uint32(ip[2])<<8 | uint32(ip[3])
+}
+
+func uint322ip(ip uint32) net.IP {
+	b := make([]byte, 4)
+	b[0] = byte(ip >> 24)
+	b[1] = byte(ip >> 16)
+	b[2] = byte(ip >> 8)
+	b[3] = byte(ip)
+	return b
+}

vendor/github.com/valyala/fasthttp/ssl-cert-snakeoil.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQD4IQusAs8PJdnG
+3mURt/AXtgC+ceqLOatJ49JJE1VPTkMAy+oE1f1XvkMrYsHqmDf6GWVzgVXryL4U
+wq2/nJSm56ddhN55nI8oSN3dtywUB8/ShelEN73nlN77PeD9tl6NksPwWaKrqxq0
+FlabRPZSQCfmgZbhDV8Sa8mfCkFU0G0lit6kLGceCKMvmW+9Bz7ebsYmVdmVMxmf
+IJStFD44lWFTdUc65WISKEdW2ELcUefb0zOLw+0PCbXFGJH5x5ktksW8+BBk2Hkg
+GeQRL/qPCccthbScO0VgNj3zJ3ZZL0ObSDAbvNDG85joeNjDNq5DT/BAZ0bOSbEF
+sh+f9BAzAgMBAAECggEBAJWv2cq7Jw6MVwSRxYca38xuD6TUNBopgBvjREixURW2
+sNUaLuMb9Omp7fuOaE2N5rcJ+xnjPGIxh/oeN5MQctz9gwn3zf6vY+15h97pUb4D
+uGvYPRDaT8YVGS+X9NMZ4ZCmqW2lpWzKnCFoGHcy8yZLbcaxBsRdvKzwOYGoPiFb
+K2QuhXZ/1UPmqK9i2DFKtj40X6vBszTNboFxOVpXrPu0FJwLVSDf2hSZ4fMM0DH3
+YqwKcYf5te+hxGKgrqRA3tn0NCWii0in6QIwXMC+kMw1ebg/tZKqyDLMNptAK8J+
+DVw9m5X1seUHS5ehU/g2jrQrtK5WYn7MrFK4lBzlRwECgYEA/d1TeANYECDWRRDk
+B0aaRZs87Rwl/J9PsvbsKvtU/bX+OfSOUjOa9iQBqn0LmU8GqusEET/QVUfocVwV
+Bggf/5qDLxz100Rj0ags/yE/kNr0Bb31kkkKHFMnCT06YasR7qKllwrAlPJvQv9x
+IzBKq+T/Dx08Wep9bCRSFhzRCnsCgYEA+jdeZXTDr/Vz+D2B3nAw1frqYFfGnEVY
+wqmoK3VXMDkGuxsloO2rN+SyiUo3JNiQNPDub/t7175GH5pmKtZOlftePANsUjBj
+wZ1D0rI5Bxu/71ibIUYIRVmXsTEQkh/ozoh3jXCZ9+bLgYiYx7789IUZZSokFQ3D
+FICUT9KJ36kCgYAGoq9Y1rWJjmIrYfqj2guUQC+CfxbbGIrrwZqAsRsSmpwvhZ3m
+tiSZxG0quKQB+NfSxdvQW5ulbwC7Xc3K35F+i9pb8+TVBdeaFkw+yu6vaZmxQLrX
+fQM/pEjD7A7HmMIaO7QaU5SfEAsqdCTP56Y8AftMuNXn/8IRfo2KuGwaWwKBgFpU
+ILzJoVdlad9E/Rw7LjYhZfkv1uBVXIyxyKcfrkEXZSmozDXDdxsvcZCEfVHM6Ipk
+K/+7LuMcqp4AFEAEq8wTOdq6daFaHLkpt/FZK6M4TlruhtpFOPkoNc3e45eM83OT
+6mziKINJC1CQ6m65sQHpBtjxlKMRG8rL/D6wx9s5AoGBAMRlqNPMwglT3hvDmsAt
+9Lf9pdmhERUlHhD8bj8mDaBj2Aqv7f6VRJaYZqP403pKKQexuqcn80mtjkSAPFkN
+Cj7BVt/RXm5uoxDTnfi26RF9F6yNDEJ7UU9+peBr99aazF/fTgW/1GcMkQnum8uV
+c257YgaWmjK9uB0Y2r2VxS0G
+-----END PRIVATE KEY-----

vendor/github.com/valyala/fasthttp/ssl-cert-snakeoil.pem

@@ -0,0 +1,17 @@
+-----BEGIN CERTIFICATE-----
+MIICujCCAaKgAwIBAgIJAMbXnKZ/cikUMA0GCSqGSIb3DQEBCwUAMBUxEzARBgNV
+BAMTCnVidW50dS5uYW4wHhcNMTUwMjA0MDgwMTM5WhcNMjUwMjAxMDgwMTM5WjAV
+MRMwEQYDVQQDEwp1YnVudHUubmFuMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEA+CELrALPDyXZxt5lEbfwF7YAvnHqizmrSePSSRNVT05DAMvqBNX9V75D
+K2LB6pg3+hllc4FV68i+FMKtv5yUpuenXYTeeZyPKEjd3bcsFAfP0oXpRDe955Te
++z3g/bZejZLD8Fmiq6satBZWm0T2UkAn5oGW4Q1fEmvJnwpBVNBtJYrepCxnHgij
+L5lvvQc+3m7GJlXZlTMZnyCUrRQ+OJVhU3VHOuViEihHVthC3FHn29Mzi8PtDwm1
+xRiR+ceZLZLFvPgQZNh5IBnkES/6jwnHLYW0nDtFYDY98yd2WS9Dm0gwG7zQxvOY
+6HjYwzauQ0/wQGdGzkmxBbIfn/QQMwIDAQABow0wCzAJBgNVHRMEAjAAMA0GCSqG
+SIb3DQEBCwUAA4IBAQBQjKm/4KN/iTgXbLTL3i7zaxYXFLXsnT1tF+ay4VA8aj98
+L3JwRTciZ3A5iy/W4VSCt3eASwOaPWHKqDBB5RTtL73LoAqsWmO3APOGQAbixcQ2
+45GXi05OKeyiYRi1Nvq7Unv9jUkRDHUYVPZVSAjCpsXzPhFkmZoTRxmx5l0ZF7Li
+K91lI5h+eFq0dwZwrmlPambyh1vQUi70VHv8DNToVU29kel7YLbxGbuqETfhrcy6
+X+Mha6RYITkAn5FqsZcKMsc9eYGEF4l3XV+oS7q6xfTxktYJMFTI18J0lQ2Lv/CI
+whdMnYGntDQBE/iFCrJEGNsKGc38796GBOb5j+zd
+-----END CERTIFICATE-----

vendor/github.com/valyala/fasthttp/stackless/doc.go

@@ -0,0 +1,3 @@
+// Package stackless saves stack space for high number of concurrently
+// running goroutines, which use writers from compress/* packages.
+package stackless

vendor/github.com/valyala/fasthttp/stackless/writer.go

@@ -0,0 +1,146 @@
+package stackless
+
+import (
+	"fmt"
+	"github.com/valyala/bytebufferpool"
+	"io"
+	"runtime"
+)
+
+// Writer is an interface stackless writer must conform to.
+//
+// The interface contains common subset for Writers from compress/* packages.
+type Writer interface {
+	Write(p []byte) (int, error)
+	Flush() error
+	Close() error
+	Reset(w io.Writer)
+}
+
+// NewWriterFunc must return new writer that will be wrapped into
+// stackless writer.
+type NewWriterFunc func(w io.Writer) Writer
+
+// NewWriter creates a stackless writer around a writer returned
+// from newWriter.
+//
+// The returned writer writes data to dstW.
+//
+// Writers that use a lot of stack space may be wrapped into stackless writer,
+// thus saving stack space for high number of concurrently running goroutines.
+func NewWriter(dstW io.Writer, newWriter NewWriterFunc) Writer {
+	w := &writer{
+		dstW: dstW,
+		done: make(chan error),
+	}
+	w.zw = newWriter(&w.xw)
+	return w
+}
+
+type writer struct {
+	dstW io.Writer
+	zw   Writer
+	xw   xWriter
+
+	done chan error
+	n    int
+
+	p  []byte
+	op op
+}
+
+type op int
+
+const (
+	opWrite op = iota
+	opFlush
+	opClose
+	opReset
+)
+
+func (w *writer) Write(p []byte) (int, error) {
+	w.p = p
+	err := w.do(opWrite)
+	w.p = nil
+	return w.n, err
+}
+
+func (w *writer) Flush() error {
+	return w.do(opFlush)
+}
+
+func (w *writer) Close() error {
+	return w.do(opClose)
+}
+
+func (w *writer) Reset(dstW io.Writer) {
+	w.xw.Reset()
+	w.do(opReset)
+	w.dstW = dstW
+}
+
+func (w *writer) do(op op) error {
+	w.op = op
+	writerCh <- w
+	err := <-w.done
+	if err != nil {
+		return err
+	}
+	if w.xw.bb != nil && len(w.xw.bb.B) > 0 {
+		_, err = w.dstW.Write(w.xw.bb.B)
+	}
+	w.xw.Reset()
+
+	return err
+}
+
+type xWriter struct {
+	bb *bytebufferpool.ByteBuffer
+}
+
+func (w *xWriter) Write(p []byte) (int, error) {
+	if w.bb == nil {
+		w.bb = bufferPool.Get()
+	}
+	w.bb.Write(p)
+	return len(p), nil
+}
+
+func (w *xWriter) Reset() {
+	if w.bb != nil {
+		bufferPool.Put(w.bb)
+		w.bb = nil
+	}
+}
+
+var bufferPool bytebufferpool.Pool
+
+func init() {
+	n := runtime.GOMAXPROCS(-1)
+	writerCh = make(chan *writer, n)
+	for i := 0; i < n; i++ {
+		go worker()
+	}
+}
+
+var writerCh chan *writer
+
+func worker() {
+	var err error
+	for w := range writerCh {
+		switch w.op {
+		case opWrite:
+			w.n, err = w.zw.Write(w.p)
+		case opFlush:
+			err = w.zw.Flush()
+		case opClose:
+			err = w.zw.Close()
+		case opReset:
+			w.zw.Reset(&w.xw)
+			err = nil
+		default:
+			panic(fmt.Sprintf("BUG: unexpected op: %d", w.op))
+		}
+		w.done <- err
+	}
+}

vendor/github.com/valyala/fasthttp/status.go

@@ -0,0 +1,176 @@
+package fasthttp
+
+import (
+	"fmt"
+	"sync/atomic"
+)
+
+// HTTP status codes were stolen from net/http.
+const (
+	StatusContinue           = 100 // RFC 7231, 6.2.1
+	StatusSwitchingProtocols = 101 // RFC 7231, 6.2.2
+	StatusProcessing         = 102 // RFC 2518, 10.1
+
+	StatusOK                   = 200 // RFC 7231, 6.3.1
+	StatusCreated              = 201 // RFC 7231, 6.3.2
+	StatusAccepted             = 202 // RFC 7231, 6.3.3
+	StatusNonAuthoritativeInfo = 203 // RFC 7231, 6.3.4
+	StatusNoContent            = 204 // RFC 7231, 6.3.5
+	StatusResetContent         = 205 // RFC 7231, 6.3.6
+	StatusPartialContent       = 206 // RFC 7233, 4.1
+	StatusMultiStatus          = 207 // RFC 4918, 11.1
+	StatusAlreadyReported      = 208 // RFC 5842, 7.1
+	StatusIMUsed               = 226 // RFC 3229, 10.4.1
+
+	StatusMultipleChoices   = 300 // RFC 7231, 6.4.1
+	StatusMovedPermanently  = 301 // RFC 7231, 6.4.2
+	StatusFound             = 302 // RFC 7231, 6.4.3
+	StatusSeeOther          = 303 // RFC 7231, 6.4.4
+	StatusNotModified       = 304 // RFC 7232, 4.1
+	StatusUseProxy          = 305 // RFC 7231, 6.4.5
+	_                       = 306 // RFC 7231, 6.4.6 (Unused)
+	StatusTemporaryRedirect = 307 // RFC 7231, 6.4.7
+	StatusPermanentRedirect = 308 // RFC 7538, 3
+
+	StatusBadRequest                   = 400 // RFC 7231, 6.5.1
+	StatusUnauthorized                 = 401 // RFC 7235, 3.1
+	StatusPaymentRequired              = 402 // RFC 7231, 6.5.2
+	StatusForbidden                    = 403 // RFC 7231, 6.5.3
+	StatusNotFound                     = 404 // RFC 7231, 6.5.4
+	StatusMethodNotAllowed             = 405 // RFC 7231, 6.5.5
+	StatusNotAcceptable                = 406 // RFC 7231, 6.5.6
+	StatusProxyAuthRequired            = 407 // RFC 7235, 3.2
+	StatusRequestTimeout               = 408 // RFC 7231, 6.5.7
+	StatusConflict                     = 409 // RFC 7231, 6.5.8
+	StatusGone                         = 410 // RFC 7231, 6.5.9
+	StatusLengthRequired               = 411 // RFC 7231, 6.5.10
+	StatusPreconditionFailed           = 412 // RFC 7232, 4.2
+	StatusRequestEntityTooLarge        = 413 // RFC 7231, 6.5.11
+	StatusRequestURITooLong            = 414 // RFC 7231, 6.5.12
+	StatusUnsupportedMediaType         = 415 // RFC 7231, 6.5.13
+	StatusRequestedRangeNotSatisfiable = 416 // RFC 7233, 4.4
+	StatusExpectationFailed            = 417 // RFC 7231, 6.5.14
+	StatusTeapot                       = 418 // RFC 7168, 2.3.3
+	StatusUnprocessableEntity          = 422 // RFC 4918, 11.2
+	StatusLocked                       = 423 // RFC 4918, 11.3
+	StatusFailedDependency             = 424 // RFC 4918, 11.4
+	StatusUpgradeRequired              = 426 // RFC 7231, 6.5.15
+	StatusPreconditionRequired         = 428 // RFC 6585, 3
+	StatusTooManyRequests              = 429 // RFC 6585, 4
+	StatusRequestHeaderFieldsTooLarge  = 431 // RFC 6585, 5
+	StatusUnavailableForLegalReasons   = 451 // RFC 7725, 3
+
+	StatusInternalServerError           = 500 // RFC 7231, 6.6.1
+	StatusNotImplemented                = 501 // RFC 7231, 6.6.2
+	StatusBadGateway                    = 502 // RFC 7231, 6.6.3
+	StatusServiceUnavailable            = 503 // RFC 7231, 6.6.4
+	StatusGatewayTimeout                = 504 // RFC 7231, 6.6.5
+	StatusHTTPVersionNotSupported       = 505 // RFC 7231, 6.6.6
+	StatusVariantAlsoNegotiates         = 506 // RFC 2295, 8.1
+	StatusInsufficientStorage           = 507 // RFC 4918, 11.5
+	StatusLoopDetected                  = 508 // RFC 5842, 7.2
+	StatusNotExtended                   = 510 // RFC 2774, 7
+	StatusNetworkAuthenticationRequired = 511 // RFC 6585, 6
+)
+
+var (
+	statusLines atomic.Value
+
+	statusMessages = map[int]string{
+		StatusContinue:           "Continue",
+		StatusSwitchingProtocols: "Switching Protocols",
+		StatusProcessing:         "Processing",
+
+		StatusOK:                   "OK",
+		StatusCreated:              "Created",
+		StatusAccepted:             "Accepted",
+		StatusNonAuthoritativeInfo: "Non-Authoritative Information",
+		StatusNoContent:            "No Content",
+		StatusResetContent:         "Reset Content",
+		StatusPartialContent:       "Partial Content",
+		StatusMultiStatus:          "Multi-Status",
+		StatusAlreadyReported:      "Already Reported",
+		StatusIMUsed:               "IM Used",
+
+		StatusMultipleChoices:   "Multiple Choices",
+		StatusMovedPermanently:  "Moved Permanently",
+		StatusFound:             "Found",
+		StatusSeeOther:          "See Other",
+		StatusNotModified:       "Not Modified",
+		StatusUseProxy:          "Use Proxy",
+		StatusTemporaryRedirect: "Temporary Redirect",
+		StatusPermanentRedirect: "Permanent Redirect",
+
+		StatusBadRequest:                   "Bad Request",
+		StatusUnauthorized:                 "Unauthorized",
+		StatusPaymentRequired:              "Payment Required",
+		StatusForbidden:                    "Forbidden",
+		StatusNotFound:                     "Not Found",
+		StatusMethodNotAllowed:             "Method Not Allowed",
+		StatusNotAcceptable:                "Not Acceptable",
+		StatusProxyAuthRequired:            "Proxy Authentication Required",
+		StatusRequestTimeout:               "Request Timeout",
+		StatusConflict:                     "Conflict",
+		StatusGone:                         "Gone",
+		StatusLengthRequired:               "Length Required",
+		StatusPreconditionFailed:           "Precondition Failed",
+		StatusRequestEntityTooLarge:        "Request Entity Too Large",
+		StatusRequestURITooLong:            "Request URI Too Long",
+		StatusUnsupportedMediaType:         "Unsupported Media Type",
+		StatusRequestedRangeNotSatisfiable: "Requested Range Not Satisfiable",
+		StatusExpectationFailed:            "Expectation Failed",
+		StatusTeapot:                       "I'm a teapot",
+		StatusUnprocessableEntity:          "Unprocessable Entity",
+		StatusLocked:                       "Locked",
+		StatusFailedDependency:             "Failed Dependency",
+		StatusUpgradeRequired:              "Upgrade Required",
+		StatusPreconditionRequired:         "Precondition Required",
+		StatusTooManyRequests:              "Too Many Requests",
+		StatusRequestHeaderFieldsTooLarge:  "Request Header Fields Too Large",
+		StatusUnavailableForLegalReasons:   "Unavailable For Legal Reasons",
+
+		StatusInternalServerError:           "Internal Server Error",
+		StatusNotImplemented:                "Not Implemented",
+		StatusBadGateway:                    "Bad Gateway",
+		StatusServiceUnavailable:            "Service Unavailable",
+		StatusGatewayTimeout:                "Gateway Timeout",
+		StatusHTTPVersionNotSupported:       "HTTP Version Not Supported",
+		StatusVariantAlsoNegotiates:         "Variant Also Negotiates",
+		StatusInsufficientStorage:           "Insufficient Storage",
+		StatusLoopDetected:                  "Loop Detected",
+		StatusNotExtended:                   "Not Extended",
+		StatusNetworkAuthenticationRequired: "Network Authentication Required",
+	}
+)
+
+// StatusMessage returns HTTP status message for the given status code.
+func StatusMessage(statusCode int) string {
+	s := statusMessages[statusCode]
+	if s == "" {
+		s = "Unknown Status Code"
+	}
+	return s
+}
+
+func init() {
+	statusLines.Store(make(map[int][]byte))
+}
+
+func statusLine(statusCode int) []byte {
+	m := statusLines.Load().(map[int][]byte)
+	h := m[statusCode]
+	if h != nil {
+		return h
+	}
+
+	statusText := StatusMessage(statusCode)
+
+	h = []byte(fmt.Sprintf("HTTP/1.1 %d %s\r\n", statusCode, statusText))
+	newM := make(map[int][]byte, len(m)+1)
+	for k, v := range m {
+		newM[k] = v
+	}
+	newM[statusCode] = h
+	statusLines.Store(newM)
+	return h
+}

vendor/github.com/valyala/fasthttp/stream.go

@@ -0,0 +1,54 @@
+package fasthttp
+
+import (
+	"bufio"
+	"io"
+	"sync"
+
+	"github.com/valyala/fasthttp/fasthttputil"
+)
+
+// StreamWriter must write data to w.
+//
+// Usually StreamWriter writes data to w in a loop (aka 'data streaming').
+//
+// StreamWriter must return immediately if w returns error.
+//
+// Since the written data is buffered, do not forget calling w.Flush
+// when the data must be propagated to reader.
+type StreamWriter func(w *bufio.Writer)
+
+// NewStreamReader returns a reader, which replays all the data generated by sw.
+//
+// The returned reader may be passed to Response.SetBodyStream.
+//
+// Close must be called on the returned reader after all the required data
+// has been read. Otherwise goroutine leak may occur.
+//
+// See also Response.SetBodyStreamWriter.
+func NewStreamReader(sw StreamWriter) io.ReadCloser {
+	pc := fasthttputil.NewPipeConns()
+	pw := pc.Conn1()
+	pr := pc.Conn2()
+
+	var bw *bufio.Writer
+	v := streamWriterBufPool.Get()
+	if v == nil {
+		bw = bufio.NewWriter(pw)
+	} else {
+		bw = v.(*bufio.Writer)
+		bw.Reset(pw)
+	}
+
+	go func() {
+		sw(bw)
+		bw.Flush()
+		pw.Close()
+
+		streamWriterBufPool.Put(bw)
+	}()
+
+	return pr
+}
+
+var streamWriterBufPool sync.Pool

vendor/github.com/valyala/fasthttp/strings.go

@@ -0,0 +1,71 @@
+package fasthttp
+
+var (
+	defaultServerName  = []byte("fasthttp")
+	defaultUserAgent   = []byte("fasthttp")
+	defaultContentType = []byte("text/plain; charset=utf-8")
+)
+
+var (
+	strSlash            = []byte("/")
+	strSlashSlash       = []byte("//")
+	strSlashDotDot      = []byte("/..")
+	strSlashDotSlash    = []byte("/./")
+	strSlashDotDotSlash = []byte("/../")
+	strCRLF             = []byte("\r\n")
+	strHTTP             = []byte("http")
+	strHTTPS            = []byte("https")
+	strHTTP11           = []byte("HTTP/1.1")
+	strColonSlashSlash  = []byte("://")
+	strColonSpace       = []byte(": ")
+	strGMT              = []byte("GMT")
+
+	strResponseContinue = []byte("HTTP/1.1 100 Continue\r\n\r\n")
+
+	strGet    = []byte("GET")
+	strHead   = []byte("HEAD")
+	strPost   = []byte("POST")
+	strPut    = []byte("PUT")
+	strDelete = []byte("DELETE")
+
+	strExpect           = []byte("Expect")
+	strConnection       = []byte("Connection")
+	strContentLength    = []byte("Content-Length")
+	strContentType      = []byte("Content-Type")
+	strDate             = []byte("Date")
+	strHost             = []byte("Host")
+	strReferer          = []byte("Referer")
+	strServer           = []byte("Server")
+	strTransferEncoding = []byte("Transfer-Encoding")
+	strContentEncoding  = []byte("Content-Encoding")
+	strAcceptEncoding   = []byte("Accept-Encoding")
+	strUserAgent        = []byte("User-Agent")
+	strCookie           = []byte("Cookie")
+	strSetCookie        = []byte("Set-Cookie")
+	strLocation         = []byte("Location")
+	strIfModifiedSince  = []byte("If-Modified-Since")
+	strLastModified     = []byte("Last-Modified")
+	strAcceptRanges     = []byte("Accept-Ranges")
+	strRange            = []byte("Range")
+	strContentRange     = []byte("Content-Range")
+
+	strCookieExpires  = []byte("expires")
+	strCookieDomain   = []byte("domain")
+	strCookiePath     = []byte("path")
+	strCookieHTTPOnly = []byte("HttpOnly")
+	strCookieSecure   = []byte("secure")
+
+	strClose               = []byte("close")
+	strGzip                = []byte("gzip")
+	strDeflate             = []byte("deflate")
+	strKeepAlive           = []byte("keep-alive")
+	strKeepAliveCamelCase  = []byte("Keep-Alive")
+	strUpgrade             = []byte("Upgrade")
+	strChunked             = []byte("chunked")
+	strIdentity            = []byte("identity")
+	str100Continue         = []byte("100-continue")
+	strPostArgsContentType = []byte("application/x-www-form-urlencoded")
+	strMultipartFormData   = []byte("multipart/form-data")
+	strBoundary            = []byte("boundary")
+	strBytes               = []byte("bytes")
+)

vendor/github.com/valyala/fasthttp/tcpdialer.go

@@ -0,0 +1,369 @@
+package fasthttp
+
+import (
+	"errors"
+	"net"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Dial dials the given TCP addr using tcp4.
+//
+// This function has the following additional features comparing to net.Dial:
+//
+//   * It reduces load on DNS resolver by caching resolved TCP addressed
+//     for DefaultDNSCacheDuration.
+//   * It dials all the resolved TCP addresses in round-robin manner until
+//     connection is established. This may be useful if certain addresses
+//     are temporarily unreachable.
+//   * It returns ErrDialTimeout if connection cannot be established during
+//     DefaultDialTimeout seconds. Use DialTimeout for customizing dial timeout.
+//
+// This dialer is intended for custom code wrapping before passing
+// to Client.Dial or HostClient.Dial.
+//
+// For instance, per-host counters and/or limits may be implemented
+// by such wrappers.
+//
+// The addr passed to the function must contain port. Example addr values:
+//
+//     * foobar.baz:443
+//     * foo.bar:80
+//     * aaa.com:8080
+func Dial(addr string) (net.Conn, error) {
+	return getDialer(DefaultDialTimeout, false)(addr)
+}
+
+// DialTimeout dials the given TCP addr using tcp4 using the given timeout.
+//
+// This function has the following additional features comparing to net.Dial:
+//
+//   * It reduces load on DNS resolver by caching resolved TCP addressed
+//     for DefaultDNSCacheDuration.
+//   * It dials all the resolved TCP addresses in round-robin manner until
+//     connection is established. This may be useful if certain addresses
+//     are temporarily unreachable.
+//
+// This dialer is intended for custom code wrapping before passing
+// to Client.Dial or HostClient.Dial.
+//
+// For instance, per-host counters and/or limits may be implemented
+// by such wrappers.
+//
+// The addr passed to the function must contain port. Example addr values:
+//
+//     * foobar.baz:443
+//     * foo.bar:80
+//     * aaa.com:8080
+func DialTimeout(addr string, timeout time.Duration) (net.Conn, error) {
+	return getDialer(timeout, false)(addr)
+}
+
+// DialDualStack dials the given TCP addr using both tcp4 and tcp6.
+//
+// This function has the following additional features comparing to net.Dial:
+//
+//   * It reduces load on DNS resolver by caching resolved TCP addressed
+//     for DefaultDNSCacheDuration.
+//   * It dials all the resolved TCP addresses in round-robin manner until
+//     connection is established. This may be useful if certain addresses
+//     are temporarily unreachable.
+//   * It returns ErrDialTimeout if connection cannot be established during
+//     DefaultDialTimeout seconds. Use DialDualStackTimeout for custom dial
+//     timeout.
+//
+// This dialer is intended for custom code wrapping before passing
+// to Client.Dial or HostClient.Dial.
+//
+// For instance, per-host counters and/or limits may be implemented
+// by such wrappers.
+//
+// The addr passed to the function must contain port. Example addr values:
+//
+//     * foobar.baz:443
+//     * foo.bar:80
+//     * aaa.com:8080
+func DialDualStack(addr string) (net.Conn, error) {
+	return getDialer(DefaultDialTimeout, true)(addr)
+}
+
+// DialDualStackTimeout dials the given TCP addr using both tcp4 and tcp6
+// using the given timeout.
+//
+// This function has the following additional features comparing to net.Dial:
+//
+//   * It reduces load on DNS resolver by caching resolved TCP addressed
+//     for DefaultDNSCacheDuration.
+//   * It dials all the resolved TCP addresses in round-robin manner until
+//     connection is established. This may be useful if certain addresses
+//     are temporarily unreachable.
+//
+// This dialer is intended for custom code wrapping before passing
+// to Client.Dial or HostClient.Dial.
+//
+// For instance, per-host counters and/or limits may be implemented
+// by such wrappers.
+//
+// The addr passed to the function must contain port. Example addr values:
+//
+//     * foobar.baz:443
+//     * foo.bar:80
+//     * aaa.com:8080
+func DialDualStackTimeout(addr string, timeout time.Duration) (net.Conn, error) {
+	return getDialer(timeout, true)(addr)
+}
+
+func getDialer(timeout time.Duration, dualStack bool) DialFunc {
+	if timeout <= 0 {
+		timeout = DefaultDialTimeout
+	}
+	timeoutRounded := int(timeout.Seconds()*10 + 9)
+
+	m := dialMap
+	if dualStack {
+		m = dialDualStackMap
+	}
+
+	dialMapLock.Lock()
+	d := m[timeoutRounded]
+	if d == nil {
+		dialer := dialerStd
+		if dualStack {
+			dialer = dialerDualStack
+		}
+		d = dialer.NewDial(timeout)
+		m[timeoutRounded] = d
+	}
+	dialMapLock.Unlock()
+	return d
+}
+
+var (
+	dialerStd       = &tcpDialer{}
+	dialerDualStack = &tcpDialer{DualStack: true}
+
+	dialMap          = make(map[int]DialFunc)
+	dialDualStackMap = make(map[int]DialFunc)
+	dialMapLock      sync.Mutex
+)
+
+type tcpDialer struct {
+	DualStack bool
+
+	tcpAddrsLock sync.Mutex
+	tcpAddrsMap  map[string]*tcpAddrEntry
+
+	concurrencyCh chan struct{}
+
+	once sync.Once
+}
+
+const maxDialConcurrency = 1000
+
+func (d *tcpDialer) NewDial(timeout time.Duration) DialFunc {
+	d.once.Do(func() {
+		d.concurrencyCh = make(chan struct{}, maxDialConcurrency)
+		d.tcpAddrsMap = make(map[string]*tcpAddrEntry)
+		go d.tcpAddrsClean()
+	})
+
+	return func(addr string) (net.Conn, error) {
+		addrs, idx, err := d.getTCPAddrs(addr)
+		if err != nil {
+			return nil, err
+		}
+		network := "tcp4"
+		if d.DualStack {
+			network = "tcp"
+		}
+
+		var conn net.Conn
+		n := uint32(len(addrs))
+		deadline := time.Now().Add(timeout)
+		for n > 0 {
+			conn, err = tryDial(network, &addrs[idx%n], deadline, d.concurrencyCh)
+			if err == nil {
+				return conn, nil
+			}
+			if err == ErrDialTimeout {
+				return nil, err
+			}
+			idx++
+			n--
+		}
+		return nil, err
+	}
+}
+
+func tryDial(network string, addr *net.TCPAddr, deadline time.Time, concurrencyCh chan struct{}) (net.Conn, error) {
+	timeout := -time.Since(deadline)
+	if timeout <= 0 {
+		return nil, ErrDialTimeout
+	}
+
+	select {
+	case concurrencyCh <- struct{}{}:
+	default:
+		tc := acquireTimer(timeout)
+		isTimeout := false
+		select {
+		case concurrencyCh <- struct{}{}:
+		case <-tc.C:
+			isTimeout = true
+		}
+		releaseTimer(tc)
+		if isTimeout {
+			return nil, ErrDialTimeout
+		}
+	}
+
+	timeout = -time.Since(deadline)
+	if timeout <= 0 {
+		<-concurrencyCh
+		return nil, ErrDialTimeout
+	}
+
+	chv := dialResultChanPool.Get()
+	if chv == nil {
+		chv = make(chan dialResult, 1)
+	}
+	ch := chv.(chan dialResult)
+	go func() {
+		var dr dialResult
+		dr.conn, dr.err = net.DialTCP(network, nil, addr)
+		ch <- dr
+		<-concurrencyCh
+	}()
+
+	var (
+		conn net.Conn
+		err  error
+	)
+
+	tc := acquireTimer(timeout)
+	select {
+	case dr := <-ch:
+		conn = dr.conn
+		err = dr.err
+		dialResultChanPool.Put(ch)
+	case <-tc.C:
+		err = ErrDialTimeout
+	}
+	releaseTimer(tc)
+
+	return conn, err
+}
+
+var dialResultChanPool sync.Pool
+
+type dialResult struct {
+	conn net.Conn
+	err  error
+}
+
+// ErrDialTimeout is returned when TCP dialing is timed out.
+var ErrDialTimeout = errors.New("dialing to the given TCP address timed out")
+
+// DefaultDialTimeout is timeout used by Dial and DialDualStack
+// for establishing TCP connections.
+const DefaultDialTimeout = 3 * time.Second
+
+type tcpAddrEntry struct {
+	addrs    []net.TCPAddr
+	addrsIdx uint32
+
+	resolveTime time.Time
+	pending     bool
+}
+
+// DefaultDNSCacheDuration is the duration for caching resolved TCP addresses
+// by Dial* functions.
+const DefaultDNSCacheDuration = time.Minute
+
+func (d *tcpDialer) tcpAddrsClean() {
+	expireDuration := 2 * DefaultDNSCacheDuration
+	for {
+		time.Sleep(time.Second)
+		t := time.Now()
+
+		d.tcpAddrsLock.Lock()
+		for k, e := range d.tcpAddrsMap {
+			if t.Sub(e.resolveTime) > expireDuration {
+				delete(d.tcpAddrsMap, k)
+			}
+		}
+		d.tcpAddrsLock.Unlock()
+	}
+}
+
+func (d *tcpDialer) getTCPAddrs(addr string) ([]net.TCPAddr, uint32, error) {
+	d.tcpAddrsLock.Lock()
+	e := d.tcpAddrsMap[addr]
+	if e != nil && !e.pending && time.Since(e.resolveTime) > DefaultDNSCacheDuration {
+		e.pending = true
+		e = nil
+	}
+	d.tcpAddrsLock.Unlock()
+
+	if e == nil {
+		addrs, err := resolveTCPAddrs(addr, d.DualStack)
+		if err != nil {
+			d.tcpAddrsLock.Lock()
+			e = d.tcpAddrsMap[addr]
+			if e != nil && e.pending {
+				e.pending = false
+			}
+			d.tcpAddrsLock.Unlock()
+			return nil, 0, err
+		}
+
+		e = &tcpAddrEntry{
+			addrs:       addrs,
+			resolveTime: time.Now(),
+		}
+
+		d.tcpAddrsLock.Lock()
+		d.tcpAddrsMap[addr] = e
+		d.tcpAddrsLock.Unlock()
+	}
+
+	idx := atomic.AddUint32(&e.addrsIdx, 1)
+	return e.addrs, idx, nil
+}
+
+func resolveTCPAddrs(addr string, dualStack bool) ([]net.TCPAddr, error) {
+	host, portS, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil, err
+	}
+	port, err := strconv.Atoi(portS)
+	if err != nil {
+		return nil, err
+	}
+
+	ips, err := net.LookupIP(host)
+	if err != nil {
+		return nil, err
+	}
+
+	n := len(ips)
+	addrs := make([]net.TCPAddr, 0, n)
+	for i := 0; i < n; i++ {
+		ip := ips[i]
+		if !dualStack && ip.To4() == nil {
+			continue
+		}
+		addrs = append(addrs, net.TCPAddr{
+			IP:   ip,
+			Port: port,
+		})
+	}
+	if len(addrs) == 0 {
+		return nil, errNoDNSEntries
+	}
+	return addrs, nil
+}
+
+var errNoDNSEntries = errors.New("couldn't find DNS entries for the given domain. Try using DialDualStack")

vendor/github.com/valyala/fasthttp/timer.go

@@ -0,0 +1,44 @@
+package fasthttp
+
+import (
+	"sync"
+	"time"
+)
+
+func initTimer(t *time.Timer, timeout time.Duration) *time.Timer {
+	if t == nil {
+		return time.NewTimer(timeout)
+	}
+	if t.Reset(timeout) {
+		panic("BUG: active timer trapped into initTimer()")
+	}
+	return t
+}
+
+func stopTimer(t *time.Timer) {
+	if !t.Stop() {
+		// Collect possibly added time from the channel
+		// if timer has been stopped and nobody collected its' value.
+		select {
+		case <-t.C:
+		default:
+		}
+	}
+}
+
+func acquireTimer(timeout time.Duration) *time.Timer {
+	v := timerPool.Get()
+	if v == nil {
+		return time.NewTimer(timeout)
+	}
+	t := v.(*time.Timer)
+	initTimer(t, timeout)
+	return t
+}
+
+func releaseTimer(t *time.Timer) {
+	stopTimer(t)
+	timerPool.Put(t)
+}
+
+var timerPool sync.Pool

vendor/github.com/valyala/fasthttp/uri.go

@@ -0,0 +1,520 @@
+package fasthttp
+
+import (
+	"bytes"
+	"io"
+	"sync"
+)
+
+// AcquireURI returns an empty URI instance from the pool.
+//
+// Release the URI with ReleaseURI after the URI is no longer needed.
+// This allows reducing GC load.
+func AcquireURI() *URI {
+	return uriPool.Get().(*URI)
+}
+
+// ReleaseURI releases the URI acquired via AcquireURI.
+//
+// The released URI mustn't be used after releasing it, otherwise data races
+// may occur.
+func ReleaseURI(u *URI) {
+	u.Reset()
+	uriPool.Put(u)
+}
+
+var uriPool = &sync.Pool{
+	New: func() interface{} {
+		return &URI{}
+	},
+}
+
+// URI represents URI :) .
+//
+// It is forbidden copying URI instances. Create new instance and use CopyTo
+// instead.
+//
+// URI instance MUST NOT be used from concurrently running goroutines.
+type URI struct {
+	noCopy noCopy
+
+	pathOriginal []byte
+	scheme       []byte
+	path         []byte
+	queryString  []byte
+	hash         []byte
+	host         []byte
+
+	queryArgs       Args
+	parsedQueryArgs bool
+
+	fullURI    []byte
+	requestURI []byte
+
+	h *RequestHeader
+}
+
+// CopyTo copies uri contents to dst.
+func (u *URI) CopyTo(dst *URI) {
+	dst.Reset()
+	dst.pathOriginal = append(dst.pathOriginal[:0], u.pathOriginal...)
+	dst.scheme = append(dst.scheme[:0], u.scheme...)
+	dst.path = append(dst.path[:0], u.path...)
+	dst.queryString = append(dst.queryString[:0], u.queryString...)
+	dst.hash = append(dst.hash[:0], u.hash...)
+	dst.host = append(dst.host[:0], u.host...)
+
+	u.queryArgs.CopyTo(&dst.queryArgs)
+	dst.parsedQueryArgs = u.parsedQueryArgs
+
+	// fullURI and requestURI shouldn't be copied, since they are created
+	// from scratch on each FullURI() and RequestURI() call.
+	dst.h = u.h
+}
+
+// Hash returns URI hash, i.e. qwe of http://aaa.com/foo/bar?baz=123#qwe .
+//
+// The returned value is valid until the next URI method call.
+func (u *URI) Hash() []byte {
+	return u.hash
+}
+
+// SetHash sets URI hash.
+func (u *URI) SetHash(hash string) {
+	u.hash = append(u.hash[:0], hash...)
+}
+
+// SetHashBytes sets URI hash.
+func (u *URI) SetHashBytes(hash []byte) {
+	u.hash = append(u.hash[:0], hash...)
+}
+
+// QueryString returns URI query string,
+// i.e. baz=123 of http://aaa.com/foo/bar?baz=123#qwe .
+//
+// The returned value is valid until the next URI method call.
+func (u *URI) QueryString() []byte {
+	return u.queryString
+}
+
+// SetQueryString sets URI query string.
+func (u *URI) SetQueryString(queryString string) {
+	u.queryString = append(u.queryString[:0], queryString...)
+	u.parsedQueryArgs = false
+}
+
+// SetQueryStringBytes sets URI query string.
+func (u *URI) SetQueryStringBytes(queryString []byte) {
+	u.queryString = append(u.queryString[:0], queryString...)
+	u.parsedQueryArgs = false
+}
+
+// Path returns URI path, i.e. /foo/bar of http://aaa.com/foo/bar?baz=123#qwe .
+//
+// The returned path is always urldecoded and normalized,
+// i.e. '//f%20obar/baz/../zzz' becomes '/f obar/zzz'.
+//
+// The returned value is valid until the next URI method call.
+func (u *URI) Path() []byte {
+	path := u.path
+	if len(path) == 0 {
+		path = strSlash
+	}
+	return path
+}
+
+// SetPath sets URI path.
+func (u *URI) SetPath(path string) {
+	u.pathOriginal = append(u.pathOriginal[:0], path...)
+	u.path = normalizePath(u.path, u.pathOriginal)
+}
+
+// SetPathBytes sets URI path.
+func (u *URI) SetPathBytes(path []byte) {
+	u.pathOriginal = append(u.pathOriginal[:0], path...)
+	u.path = normalizePath(u.path, u.pathOriginal)
+}
+
+// PathOriginal returns the original path from requestURI passed to URI.Parse().
+//
+// The returned value is valid until the next URI method call.
+func (u *URI) PathOriginal() []byte {
+	return u.pathOriginal
+}
+
+// Scheme returns URI scheme, i.e. http of http://aaa.com/foo/bar?baz=123#qwe .
+//
+// Returned scheme is always lowercased.
+//
+// The returned value is valid until the next URI method call.
+func (u *URI) Scheme() []byte {
+	scheme := u.scheme
+	if len(scheme) == 0 {
+		scheme = strHTTP
+	}
+	return scheme
+}
+
+// SetScheme sets URI scheme, i.e. http, https, ftp, etc.
+func (u *URI) SetScheme(scheme string) {
+	u.scheme = append(u.scheme[:0], scheme...)
+	lowercaseBytes(u.scheme)
+}
+
+// SetSchemeBytes sets URI scheme, i.e. http, https, ftp, etc.
+func (u *URI) SetSchemeBytes(scheme []byte) {
+	u.scheme = append(u.scheme[:0], scheme...)
+	lowercaseBytes(u.scheme)
+}
+
+// Reset clears uri.
+func (u *URI) Reset() {
+	u.pathOriginal = u.pathOriginal[:0]
+	u.scheme = u.scheme[:0]
+	u.path = u.path[:0]
+	u.queryString = u.queryString[:0]
+	u.hash = u.hash[:0]
+
+	u.host = u.host[:0]
+	u.queryArgs.Reset()
+	u.parsedQueryArgs = false
+
+	// There is no need in u.fullURI = u.fullURI[:0], since full uri
+	// is calucalted on each call to FullURI().
+
+	// There is no need in u.requestURI = u.requestURI[:0], since requestURI
+	// is calculated on each call to RequestURI().
+
+	u.h = nil
+}
+
+// Host returns host part, i.e. aaa.com of http://aaa.com/foo/bar?baz=123#qwe .
+//
+// Host is always lowercased.
+func (u *URI) Host() []byte {
+	if len(u.host) == 0 && u.h != nil {
+		u.host = append(u.host[:0], u.h.Host()...)
+		lowercaseBytes(u.host)
+		u.h = nil
+	}
+	return u.host
+}
+
+// SetHost sets host for the uri.
+func (u *URI) SetHost(host string) {
+	u.host = append(u.host[:0], host...)
+	lowercaseBytes(u.host)
+}
+
+// SetHostBytes sets host for the uri.
+func (u *URI) SetHostBytes(host []byte) {
+	u.host = append(u.host[:0], host...)
+	lowercaseBytes(u.host)
+}
+
+// Parse initializes URI from the given host and uri.
+//
+// host may be nil. In this case uri must contain fully qualified uri,
+// i.e. with scheme and host. http is assumed if scheme is omitted.
+//
+// uri may contain e.g. RequestURI without scheme and host if host is non-empty.
+func (u *URI) Parse(host, uri []byte) {
+	u.parse(host, uri, nil)
+}
+
+func (u *URI) parseQuick(uri []byte, h *RequestHeader, isTLS bool) {
+	u.parse(nil, uri, h)
+	if isTLS {
+		u.scheme = append(u.scheme[:0], strHTTPS...)
+	}
+}
+
+func (u *URI) parse(host, uri []byte, h *RequestHeader) {
+	u.Reset()
+	u.h = h
+
+	scheme, host, uri := splitHostURI(host, uri)
+	u.scheme = append(u.scheme, scheme...)
+	lowercaseBytes(u.scheme)
+	u.host = append(u.host, host...)
+	lowercaseBytes(u.host)
+
+	b := uri
+	queryIndex := bytes.IndexByte(b, '?')
+	fragmentIndex := bytes.IndexByte(b, '#')
+	// Ignore query in fragment part
+	if fragmentIndex >= 0 && queryIndex > fragmentIndex {
+		queryIndex = -1
+	}
+
+	if queryIndex < 0 && fragmentIndex < 0 {
+		u.pathOriginal = append(u.pathOriginal, b...)
+		u.path = normalizePath(u.path, u.pathOriginal)
+		return
+	}
+
+	if queryIndex >= 0 {
+		// Path is everything up to the start of the query
+		u.pathOriginal = append(u.pathOriginal, b[:queryIndex]...)
+		u.path = normalizePath(u.path, u.pathOriginal)
+
+		if fragmentIndex < 0 {
+			u.queryString = append(u.queryString, b[queryIndex+1:]...)
+		} else {
+			u.queryString = append(u.queryString, b[queryIndex+1:fragmentIndex]...)
+			u.hash = append(u.hash, b[fragmentIndex+1:]...)
+		}
+		return
+	}
+
+	// fragmentIndex >= 0 && queryIndex < 0
+	// Path is up to the start of fragment
+	u.pathOriginal = append(u.pathOriginal, b[:fragmentIndex]...)
+	u.path = normalizePath(u.path, u.pathOriginal)
+	u.hash = append(u.hash, b[fragmentIndex+1:]...)
+}
+
+func normalizePath(dst, src []byte) []byte {
+	dst = dst[:0]
+	dst = addLeadingSlash(dst, src)
+	dst = decodeArgAppend(dst, src, false)
+
+	// remove duplicate slashes
+	b := dst
+	bSize := len(b)
+	for {
+		n := bytes.Index(b, strSlashSlash)
+		if n < 0 {
+			break
+		}
+		b = b[n:]
+		copy(b, b[1:])
+		b = b[:len(b)-1]
+		bSize--
+	}
+	dst = dst[:bSize]
+
+	// remove /./ parts
+	b = dst
+	for {
+		n := bytes.Index(b, strSlashDotSlash)
+		if n < 0 {
+			break
+		}
+		nn := n + len(strSlashDotSlash) - 1
+		copy(b[n:], b[nn:])
+		b = b[:len(b)-nn+n]
+	}
+
+	// remove /foo/../ parts
+	for {
+		n := bytes.Index(b, strSlashDotDotSlash)
+		if n < 0 {
+			break
+		}
+		nn := bytes.LastIndexByte(b[:n], '/')
+		if nn < 0 {
+			nn = 0
+		}
+		n += len(strSlashDotDotSlash) - 1
+		copy(b[nn:], b[n:])
+		b = b[:len(b)-n+nn]
+	}
+
+	// remove trailing /foo/..
+	n := bytes.LastIndex(b, strSlashDotDot)
+	if n >= 0 && n+len(strSlashDotDot) == len(b) {
+		nn := bytes.LastIndexByte(b[:n], '/')
+		if nn < 0 {
+			return strSlash
+		}
+		b = b[:nn+1]
+	}
+
+	return b
+}
+
+// RequestURI returns RequestURI - i.e. URI without Scheme and Host.
+func (u *URI) RequestURI() []byte {
+	dst := appendQuotedPath(u.requestURI[:0], u.Path())
+	if u.queryArgs.Len() > 0 {
+		dst = append(dst, '?')
+		dst = u.queryArgs.AppendBytes(dst)
+	} else if len(u.queryString) > 0 {
+		dst = append(dst, '?')
+		dst = append(dst, u.queryString...)
+	}
+	if len(u.hash) > 0 {
+		dst = append(dst, '#')
+		dst = append(dst, u.hash...)
+	}
+	u.requestURI = dst
+	return u.requestURI
+}
+
+// LastPathSegment returns the last part of uri path after '/'.
+//
+// Examples:
+//
+//    * For /foo/bar/baz.html path returns baz.html.
+//    * For /foo/bar/ returns empty byte slice.
+//    * For /foobar.js returns foobar.js.
+func (u *URI) LastPathSegment() []byte {
+	path := u.Path()
+	n := bytes.LastIndexByte(path, '/')
+	if n < 0 {
+		return path
+	}
+	return path[n+1:]
+}
+
+// Update updates uri.
+//
+// The following newURI types are accepted:
+//
+//     * Absolute, i.e. http://foobar.com/aaa/bb?cc . In this case the original
+//       uri is replaced by newURI.
+//     * Absolute without scheme, i.e. //foobar.com/aaa/bb?cc. In this case
+//       the original scheme is preserved.
+//     * Missing host, i.e. /aaa/bb?cc . In this case only RequestURI part
+//       of the original uri is replaced.
+//     * Relative path, i.e.  xx?yy=abc . In this case the original RequestURI
+//       is updated according to the new relative path.
+func (u *URI) Update(newURI string) {
+	u.UpdateBytes(s2b(newURI))
+}
+
+// UpdateBytes updates uri.
+//
+// The following newURI types are accepted:
+//
+//     * Absolute, i.e. http://foobar.com/aaa/bb?cc . In this case the original
+//       uri is replaced by newURI.
+//     * Absolute without scheme, i.e. //foobar.com/aaa/bb?cc. In this case
+//       the original scheme is preserved.
+//     * Missing host, i.e. /aaa/bb?cc . In this case only RequestURI part
+//       of the original uri is replaced.
+//     * Relative path, i.e.  xx?yy=abc . In this case the original RequestURI
+//       is updated according to the new relative path.
+func (u *URI) UpdateBytes(newURI []byte) {
+	u.requestURI = u.updateBytes(newURI, u.requestURI)
+}
+
+func (u *URI) updateBytes(newURI, buf []byte) []byte {
+	if len(newURI) == 0 {
+		return buf
+	}
+
+	n := bytes.Index(newURI, strSlashSlash)
+	if n >= 0 {
+		// absolute uri
+		var b [32]byte
+		schemeOriginal := b[:0]
+		if len(u.scheme) > 0 {
+			schemeOriginal = append([]byte(nil), u.scheme...)
+		}
+		u.Parse(nil, newURI)
+		if len(schemeOriginal) > 0 && len(u.scheme) == 0 {
+			u.scheme = append(u.scheme[:0], schemeOriginal...)
+		}
+		return buf
+	}
+
+	if newURI[0] == '/' {
+		// uri without host
+		buf = u.appendSchemeHost(buf[:0])
+		buf = append(buf, newURI...)
+		u.Parse(nil, buf)
+		return buf
+	}
+
+	// relative path
+	switch newURI[0] {
+	case '?':
+		// query string only update
+		u.SetQueryStringBytes(newURI[1:])
+		return append(buf[:0], u.FullURI()...)
+	case '#':
+		// update only hash
+		u.SetHashBytes(newURI[1:])
+		return append(buf[:0], u.FullURI()...)
+	default:
+		// update the last path part after the slash
+		path := u.Path()
+		n = bytes.LastIndexByte(path, '/')
+		if n < 0 {
+			panic("BUG: path must contain at least one slash")
+		}
+		buf = u.appendSchemeHost(buf[:0])
+		buf = appendQuotedPath(buf, path[:n+1])
+		buf = append(buf, newURI...)
+		u.Parse(nil, buf)
+		return buf
+	}
+}
+
+// FullURI returns full uri in the form {Scheme}://{Host}{RequestURI}#{Hash}.
+func (u *URI) FullURI() []byte {
+	u.fullURI = u.AppendBytes(u.fullURI[:0])
+	return u.fullURI
+}
+
+// AppendBytes appends full uri to dst and returns the extended dst.
+func (u *URI) AppendBytes(dst []byte) []byte {
+	dst = u.appendSchemeHost(dst)
+	return append(dst, u.RequestURI()...)
+}
+
+func (u *URI) appendSchemeHost(dst []byte) []byte {
+	dst = append(dst, u.Scheme()...)
+	dst = append(dst, strColonSlashSlash...)
+	return append(dst, u.Host()...)
+}
+
+// WriteTo writes full uri to w.
+//
+// WriteTo implements io.WriterTo interface.
+func (u *URI) WriteTo(w io.Writer) (int64, error) {
+	n, err := w.Write(u.FullURI())
+	return int64(n), err
+}
+
+// String returns full uri.
+func (u *URI) String() string {
+	return string(u.FullURI())
+}
+
+func splitHostURI(host, uri []byte) ([]byte, []byte, []byte) {
+	n := bytes.Index(uri, strSlashSlash)
+	if n < 0 {
+		return strHTTP, host, uri
+	}
+	scheme := uri[:n]
+	if bytes.IndexByte(scheme, '/') >= 0 {
+		return strHTTP, host, uri
+	}
+	if len(scheme) > 0 && scheme[len(scheme)-1] == ':' {
+		scheme = scheme[:len(scheme)-1]
+	}
+	n += len(strSlashSlash)
+	uri = uri[n:]
+	n = bytes.IndexByte(uri, '/')
+	if n < 0 {
+		return scheme, uri, strSlash
+	}
+	return scheme, uri[:n], uri[n:]
+}
+
+// QueryArgs returns query args.
+func (u *URI) QueryArgs() *Args {
+	u.parseQueryArgs()
+	return &u.queryArgs
+}
+
+func (u *URI) parseQueryArgs() {
+	if u.parsedQueryArgs {
+		return
+	}
+	u.queryArgs.ParseBytes(u.queryString)
+	u.parsedQueryArgs = true
+}

vendor/github.com/valyala/fasthttp/uri_unix.go

@@ -0,0 +1,12 @@
+// +build !windows
+
+package fasthttp
+
+func addLeadingSlash(dst, src []byte) []byte {
+	// add leading slash for unix paths
+	if len(src) == 0 || src[0] != '/' {
+		dst = append(dst, '/')
+	}
+
+	return dst
+}

vendor/github.com/valyala/fasthttp/uri_windows.go

@@ -0,0 +1,12 @@
+// +build windows
+
+package fasthttp
+
+func addLeadingSlash(dst, src []byte) []byte {
+	// zero length and "C:/" case
+	if len(src) == 0 || (len(src) > 2 && src[1] != ':') {
+		dst = append(dst, '/')
+	}
+
+	return dst
+}

vendor/github.com/valyala/fasthttp/userdata.go

@@ -0,0 +1,71 @@
+package fasthttp
+
+import (
+	"io"
+)
+
+type userDataKV struct {
+	key   []byte
+	value interface{}
+}
+
+type userData []userDataKV
+
+func (d *userData) Set(key string, value interface{}) {
+	args := *d
+	n := len(args)
+	for i := 0; i < n; i++ {
+		kv := &args[i]
+		if string(kv.key) == key {
+			kv.value = value
+			return
+		}
+	}
+
+	c := cap(args)
+	if c > n {
+		args = args[:n+1]
+		kv := &args[n]
+		kv.key = append(kv.key[:0], key...)
+		kv.value = value
+		*d = args
+		return
+	}
+
+	kv := userDataKV{}
+	kv.key = append(kv.key[:0], key...)
+	kv.value = value
+	*d = append(args, kv)
+}
+
+func (d *userData) SetBytes(key []byte, value interface{}) {
+	d.Set(b2s(key), value)
+}
+
+func (d *userData) Get(key string) interface{} {
+	args := *d
+	n := len(args)
+	for i := 0; i < n; i++ {
+		kv := &args[i]
+		if string(kv.key) == key {
+			return kv.value
+		}
+	}
+	return nil
+}
+
+func (d *userData) GetBytes(key []byte) interface{} {
+	return d.Get(b2s(key))
+}
+
+func (d *userData) Reset() {
+	args := *d
+	n := len(args)
+	for i := 0; i < n; i++ {
+		v := args[i].value
+		if vc, ok := v.(io.Closer); ok {
+			vc.Close()
+		}
+	}
+	*d = (*d)[:0]
+}

vendor/github.com/valyala/fasthttp/workerpool.go

@@ -0,0 +1,231 @@
+package fasthttp
+
+import (
+	"net"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+)
+
+// workerPool serves incoming connections via a pool of workers
+// in FILO order, i.e. the most recently stopped worker will serve the next
+// incoming connection.
+//
+// Such a scheme keeps CPU caches hot (in theory).
+type workerPool struct {
+	// Function for serving server connections.
+	// It must leave c unclosed.
+	WorkerFunc func(c net.Conn) error
+
+	MaxWorkersCount int
+
+	LogAllErrors bool
+
+	MaxIdleWorkerDuration time.Duration
+
+	Logger Logger
+
+	lock         sync.Mutex
+	workersCount int
+	mustStop     bool
+
+	ready []*workerChan
+
+	stopCh chan struct{}
+
+	workerChanPool sync.Pool
+}
+
+type workerChan struct {
+	lastUseTime time.Time
+	ch          chan net.Conn
+}
+
+func (wp *workerPool) Start() {
+	if wp.stopCh != nil {
+		panic("BUG: workerPool already started")
+	}
+	wp.stopCh = make(chan struct{})
+	stopCh := wp.stopCh
+	go func() {
+		var scratch []*workerChan
+		for {
+			wp.clean(&scratch)
+			select {
+			case <-stopCh:
+				return
+			default:
+				time.Sleep(wp.getMaxIdleWorkerDuration())
+			}
+		}
+	}()
+}
+
+func (wp *workerPool) Stop() {
+	if wp.stopCh == nil {
+		panic("BUG: workerPool wasn't started")
+	}
+	close(wp.stopCh)
+	wp.stopCh = nil
+
+	// Stop all the workers waiting for incoming connections.
+	// Do not wait for busy workers - they will stop after
+	// serving the connection and noticing wp.mustStop = true.
+	wp.lock.Lock()
+	ready := wp.ready
+	for i, ch := range ready {
+		ch.ch <- nil
+		ready[i] = nil
+	}
+	wp.ready = ready[:0]
+	wp.mustStop = true
+	wp.lock.Unlock()
+}
+
+func (wp *workerPool) getMaxIdleWorkerDuration() time.Duration {
+	if wp.MaxIdleWorkerDuration <= 0 {
+		return 10 * time.Second
+	}
+	return wp.MaxIdleWorkerDuration
+}
+
+func (wp *workerPool) clean(scratch *[]*workerChan) {
+	maxIdleWorkerDuration := wp.getMaxIdleWorkerDuration()
+
+	// Clean least recently used workers if they didn't serve connections
+	// for more than maxIdleWorkerDuration.
+	currentTime := time.Now()
+
+	wp.lock.Lock()
+	ready := wp.ready
+	n := len(ready)
+	i := 0
+	for i < n && currentTime.Sub(ready[i].lastUseTime) > maxIdleWorkerDuration {
+		i++
+	}
+	*scratch = append((*scratch)[:0], ready[:i]...)
+	if i > 0 {
+		m := copy(ready, ready[i:])
+		for i = m; i < n; i++ {
+			ready[i] = nil
+		}
+		wp.ready = ready[:m]
+	}
+	wp.lock.Unlock()
+
+	// Notify obsolete workers to stop.
+	// This notification must be outside the wp.lock, since ch.ch
+	// may be blocking and may consume a lot of time if many workers
+	// are located on non-local CPUs.
+	tmp := *scratch
+	for i, ch := range tmp {
+		ch.ch <- nil
+		tmp[i] = nil
+	}
+}
+
+func (wp *workerPool) Serve(c net.Conn) bool {
+	ch := wp.getCh()
+	if ch == nil {
+		return false
+	}
+	ch.ch <- c
+	return true
+}
+
+var workerChanCap = func() int {
+	// Use blocking workerChan if GOMAXPROCS=1.
+	// This immediately switches Serve to WorkerFunc, which results
+	// in higher performance (under go1.5 at least).
+	if runtime.GOMAXPROCS(0) == 1 {
+		return 0
+	}
+
+	// Use non-blocking workerChan if GOMAXPROCS>1,
+	// since otherwise the Serve caller (Acceptor) may lag accepting
+	// new connections if WorkerFunc is CPU-bound.
+	return 1
+}()
+
+func (wp *workerPool) getCh() *workerChan {
+	var ch *workerChan
+	createWorker := false
+
+	wp.lock.Lock()
+	ready := wp.ready
+	n := len(ready) - 1
+	if n < 0 {
+		if wp.workersCount < wp.MaxWorkersCount {
+			createWorker = true
+			wp.workersCount++
+		}
+	} else {
+		ch = ready[n]
+		ready[n] = nil
+		wp.ready = ready[:n]
+	}
+	wp.lock.Unlock()
+
+	if ch == nil {
+		if !createWorker {
+			return nil
+		}
+		vch := wp.workerChanPool.Get()
+		if vch == nil {
+			vch = &workerChan{
+				ch: make(chan net.Conn, workerChanCap),
+			}
+		}
+		ch = vch.(*workerChan)
+		go func() {
+			wp.workerFunc(ch)
+			wp.workerChanPool.Put(vch)
+		}()
+	}
+	return ch
+}
+
+func (wp *workerPool) release(ch *workerChan) bool {
+	ch.lastUseTime = time.Now()
+	wp.lock.Lock()
+	if wp.mustStop {
+		wp.lock.Unlock()
+		return false
+	}
+	wp.ready = append(wp.ready, ch)
+	wp.lock.Unlock()
+	return true
+}
+
+func (wp *workerPool) workerFunc(ch *workerChan) {
+	var c net.Conn
+
+	var err error
+	for c = range ch.ch {
+		if c == nil {
+			break
+		}
+
+		if err = wp.WorkerFunc(c); err != nil && err != errHijacked {
+			errStr := err.Error()
+			if wp.LogAllErrors || !(strings.Contains(errStr, "broken pipe") ||
+				strings.Contains(errStr, "reset by peer") ||
+				strings.Contains(errStr, "i/o timeout")) {
+				wp.Logger.Printf("error when serving connection %q<->%q: %s", c.LocalAddr(), c.RemoteAddr(), err)
+			}
+		}
+		if err != errHijacked {
+			c.Close()
+		}
+		c = nil
+
+		if !wp.release(ch) {
+			break
+		}
+	}
+
+	wp.lock.Lock()
+	wp.workersCount--
+	wp.lock.Unlock()
+}