Restore the Response and Request when read from Transport

Since the Request.Body and Response.Body are read from any transport.RoundTrip,
it is needed to restore them before reusing it again;
otherwise, the Request.Body or Response.Body won't be readable.

Signed-off-by: David Pordomingo <[email protected]>

examples/cmd/logtransport.go

@@ -1,12 +1,12 @@
 package main
 
 import (
-	"bytes"
-	"io/ioutil"
 	"net/http"
 	"time"
 
 	"gopkg.in/src-d/go-log.v1"
+
+	"github.com/src-d/metadata-retrieval/utils"
 )
 
 func setLogTransport(client *http.Client, logger log.Logger) {
@@ -21,8 +21,9 @@ type logTransport struct {
 func (t *logTransport) RoundTrip(r *http.Request) (*http.Response, error) {
 	t0 := time.Now()
 
-	reqBody, _ := ioutil.ReadAll(r.Body)
-	r.Body = ioutil.NopCloser(bytes.NewBuffer(reqBody))
+	// Since the Request has been read, it is needed to restore it
+	// before reusing it; otherwise, its body will be unreadable again in other Transports.
+	reqBody, _ := utils.ReadRequestAndRestore(r)
 
 	resp, err := t.T.RoundTrip(r)
 	if err != nil {
@@ -32,7 +33,9 @@ func (t *logTransport) RoundTrip(r *http.Request) (*http.Response, error) {
 		return resp, err
 	}
 
-	respBody, err := ioutil.ReadAll(resp.Body)
+	// Since the Response has been read, it is needed to restore it
+	// before reusing it; otherwise, its body will be unreadable again in other Transports.
+	respBody, err := utils.ReadResponseAndRestore(resp)
 	if err != nil {
 		return resp, err
 	}
@@ -41,7 +44,5 @@ func (t *logTransport) RoundTrip(r *http.Request) (*http.Response, error) {
 		log.Fields{"elapsed": time.Since(t0), "response-code": resp.StatusCode, "url": r.URL, "request-body": string(reqBody), "response-body": string(respBody)},
 	).Debugf("HTTP response")
 
-	resp.Body = ioutil.NopCloser(bytes.NewBuffer(respBody))
-
 	return resp, err
 }

github/ratelimit.go

@@ -193,7 +193,7 @@ func asErrRateLimit(resp *http.Response) *ErrRateLimit {
 
 // readAPIErrorResponse reads the response.Body into the passed errorResponse
 func readAPIErrorResponse(resp *http.Response, errorResponse *apiErrorResponse) error {
-	bodyContent, err := utils.BodyContentAndRestore(resp)
+	bodyContent, err := utils.ReadResponseAndRestore(resp)
 	if err != nil {
 		return err
 	}

github/retry.go

@@ -5,6 +5,8 @@ import (
 	"time"
 
 	"gopkg.in/src-d/go-log.v1"
+
+	"github.com/src-d/metadata-retrieval/utils"
 )
 
 // SetRetryTransport wraps the passed client.Transport with a RetryTransport
@@ -27,6 +29,12 @@ func (t *retryTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 			return err
 		}
 
+		// Since the Request has been read, it is needed to restore it
+		// before reusing it; otherwise, its body will be unreadable again.
+		if _, err := utils.ReadRequestAndRestore(req); err != nil {
+			return nil
+		}
+
 		if r.StatusCode >= 500 {
 			return err
 		}

utils/utils.go

@@ -2,14 +2,15 @@ package utils
 
 import (
 	"bytes"
+	"io"
 	"io/ioutil"
 	"net/http"
 )
 
-// BodyContentAndRestore reads the content of the Response.Body, and restores it
+// ReadResponseAndRestore reads the content of the Response.Body, and restores it
 // to allow its reuse (e.g. when readen from Transport)
 // https://github.com/google/go-github/pull/986
-func BodyContentAndRestore(resp *http.Response) ([]byte, error) {
+func ReadResponseAndRestore(resp *http.Response) ([]byte, error) {
 	content, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
@@ -19,3 +20,27 @@ func BodyContentAndRestore(resp *http.Response) ([]byte, error) {
 
 	return content, nil
 }
+
+// ReadRequestAndRestore reads the content of the Response.Body, and restores it
+// to allow its reuse (e.g. when readen from Transport)
+// https://github.com/google/go-github/pull/986
+func ReadRequestAndRestore(req *http.Request) ([]byte, error) {
+	reader, content, err := ReadAndGetNew(req.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Body = reader
+	return content, nil
+}
+
+// ReadAndGetNew reads the content of the pased reader, and returns a brand new one
+// with the same content with a no-op Close method
+func ReadAndGetNew(reader io.Reader) (io.ReadCloser, []byte, error) {
+	content, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return ioutil.NopCloser(bytes.NewReader(content)), content, nil
+}