vendor: add github.com/gregjones/httpcache/redis

vendor/github.com/gregjones/httpcache/httpcache.go

@@ -11,6 +11,8 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"io"
+	"io/ioutil"
 	"net/http"
 	"net/http/httputil"
 	"strings"
@@ -227,9 +229,25 @@ func (t *Transport) RoundTrip(req *http.Request) (resp *http.Response, err error
 				resp.Header.Set(fakeHeader, reqValue)
 			}
 		}
-		respBytes, err := httputil.DumpResponse(resp, true)
-		if err == nil {
-			t.Cache.Set(cacheKey, respBytes)
+		switch req.Method {
+		case "GET":
+			// Delay caching until EOF is reached.
+			resp.Body = &cachingReadCloser{
+				R: resp.Body,
+				OnEOF: func(r io.Reader) {
+					resp := *resp
+					resp.Body = ioutil.NopCloser(r)
+					respBytes, err := httputil.DumpResponse(&resp, true)
+					if err == nil {
+						t.Cache.Set(cacheKey, respBytes)
+					}
+				},
+			}
+		default:
+			respBytes, err := httputil.DumpResponse(resp, true)
+			if err == nil {
+				t.Cache.Set(cacheKey, respBytes)
+			}
 		}
 	} else {
 		t.Cache.Delete(cacheKey)
@@ -498,6 +516,35 @@ func headerAllCommaSepValues(headers http.Header, name string) []string {
 	return vals
 }
 
+// cachingReadCloser is a wrapper around ReadCloser R that calls OnEOF
+// handler with a full copy of the content read from R when EOF is
+// reached.
+type cachingReadCloser struct {
+	// Underlying ReadCloser.
+	R io.ReadCloser
+	// OnEOF is called with a copy of the content of R when EOF is reached.
+	OnEOF func(io.Reader)
+
+	buf bytes.Buffer // buf stores a copy of the content of R.
+}
+
+// Read reads the next len(p) bytes from R or until R is drained. The
+// return value n is the number of bytes read. If R has no data to
+// return, err is io.EOF and OnEOF is called with a full copy of what
+// has been read so far.
+func (r *cachingReadCloser) Read(p []byte) (n int, err error) {
+	n, err = r.R.Read(p)
+	r.buf.Write(p[:n])
+	if err == io.EOF {
+		r.OnEOF(bytes.NewReader(r.buf.Bytes()))
+	}
+	return n, err
+}
+
+func (r *cachingReadCloser) Close() error {
+	return r.R.Close()
+}
+
 // NewMemoryCacheTransport returns a new Transport using the in-memory cache implementation
 func NewMemoryCacheTransport() *Transport {
 	c := NewMemoryCache()

vendor/github.com/gregjones/httpcache/redis/redis.go

@@ -0,0 +1,43 @@
+// Package redis provides a redis interface for http caching.
+package redis
+
+import (
+	"github.com/garyburd/redigo/redis"
+	"github.com/gregjones/httpcache"
+)
+
+// cache is an implementation of httpcache.Cache that caches responses in a
+// redis server.
+type cache struct {
+	redis.Conn
+}
+
+// cacheKey modifies an httpcache key for use in redis. Specifically, it
+// prefixes keys to avoid collision with other data stored in redis.
+func cacheKey(key string) string {
+	return "rediscache:" + key
+}
+
+// Get returns the response corresponding to key if present.
+func (c cache) Get(key string) (resp []byte, ok bool) {
+	item, err := redis.Bytes(c.Do("GET", cacheKey(key)))
+	if err != nil {
+		return nil, false
+	}
+	return item, true
+}
+
+// Set saves a response to the cache as key.
+func (c cache) Set(key string, resp []byte) {
+	c.Do("SET", cacheKey(key), resp)
+}
+
+// Delete removes the response with key from the cache.
+func (c cache) Delete(key string) {
+	c.Do("DEL", cacheKey(key))
+}
+
+// NewWithClient returns a new Cache with the given redis connection.
+func NewWithClient(client redis.Conn) httpcache.Cache {
+	return cache{client}
+}