http: send errors as trailer iff status is 200, else as values

Author: keks

http/client.go

@@ -123,21 +123,7 @@ func (c *client) Execute(req *cmds.Request, re cmds.ResponseEmitter, env cmds.En
 	return cmds.Copy(re, res)
 }
 
-func (c *client) Send(req *cmds.Request) (cmds.Response, error) {
-	if req.Context == nil {
-		log.Warningf("no context set in request")
-		req.Context = context.Background()
-	}
-
-	// save user-provided encoding
-	previousUserProvidedEncoding, found := req.Options[cmds.EncLong].(string)
-
-	// override with json to send to server
-	req.SetOption(cmds.EncLong, cmds.JSON)
-
-	// stream channel output
-	req.SetOption(cmds.ChanOpt, true)
-
+func (c *client) toHTTPRequest(req *cmds.Request) (*http.Request, error) {
 	query, err := getQuery(req)
 	if err != nil {
 		return nil, err
@@ -176,17 +162,43 @@ func (c *client) Send(req *cmds.Request) (cmds.Response, error) {
 	httpReq = httpReq.WithContext(req.Context)
 	httpReq.Close = true
 
+	return httpReq, nil
+}
+
+func (c *client) Send(req *cmds.Request) (cmds.Response, error) {
+	if req.Context == nil {
+		log.Warningf("no context set in request")
+		req.Context = context.Background()
+	}
+
+	// save user-provided encoding
+	previousUserProvidedEncoding, found := req.Options[cmds.EncLong].(string)
+
+	// override with json to send to server
+	req.SetOption(cmds.EncLong, cmds.JSON)
+
+	// stream channel output
+	req.SetOption(cmds.ChanOpt, true)
+
+	// build http request
+	httpReq, err := c.toHTTPRequest(req)
+	if err != nil {
+		return nil, err
+	}
+
+	// send http request
 	httpRes, err := c.httpClient.Do(httpReq)
 	if err != nil {
 		return nil, err
 	}
 
-	// using the overridden JSON encoding in request
+	// parse using the overridden JSON encoding in request
 	res, err := parseResponse(httpRes, req)
 	if err != nil {
 		return nil, err
 	}
 
+	// reset request encoding to what it was before
 	if found && len(previousUserProvidedEncoding) > 0 {
 		// reset to user provided encoding after sending request
 		// NB: if user has provided an encoding but it is the empty string,

http/errors_test.go

@@ -0,0 +1,111 @@
+package http
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/ipfs/go-ipfs-cmds"
+)
+
+func TestErrors(t *testing.T) {
+	type testcase struct {
+		path       []string
+		bodyStr    string
+		status     string
+		errTrailer string
+	}
+
+	tcs := []testcase{
+		{
+			path: []string{"version"},
+			bodyStr: `{` +
+				`"Version":"0.1.2",` +
+				`"Commit":"c0mm17",` +
+				`"Repo":"4",` +
+				`"System":"` + runtime.GOARCH + "/" + runtime.GOOS + `",` +
+				`"Golang":"` + runtime.Version() + `"}` + "\n",
+			status: "200 OK",
+		},
+
+		// TODO this error should be sent as a value, because it is non-200
+		{
+			path:    []string{"error"},
+			status:  "500 Internal Server Error",
+			bodyStr: `{"Message":"an error occurred","Code":0,"Type":"error"}` + "\n",
+		},
+
+		{
+			path:       []string{"lateerror"},
+			status:     "200 OK",
+			bodyStr:    `"some value"` + "\n",
+			errTrailer: "an error occurred",
+		},
+
+		{
+			path:    []string{"doubleclose"},
+			status:  "200 OK",
+			bodyStr: `"some value"` + "\n",
+		},
+
+		{
+			path:    []string{"single"},
+			status:  "200 OK",
+			bodyStr: `"some value"` + "\n",
+		},
+
+		{
+			path:    []string{"reader"},
+			status:  "200 OK",
+			bodyStr: "the reader call returns a reader.",
+		},
+	}
+
+	mkTest := func(tc testcase) func(*testing.T) {
+		return func(t *testing.T) {
+			_, srv := getTestServer(t, nil) // handler_test:/^func getTestServer/
+			c := NewClient(srv.URL)
+			req, err := cmds.NewRequest(context.Background(), tc.path, nil, nil, nil, cmdRoot)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			httpReq, err := c.(*client).toHTTPRequest(req)
+			if err != nil {
+				t.Fatal("unexpected error:", err)
+			}
+
+			httpClient := http.DefaultClient
+
+			res, err := httpClient.Do(httpReq)
+			if err != nil {
+				t.Fatal("unexpected error", err)
+			}
+
+			if res.Status != tc.status {
+				t.Errorf("expected status %v, got %v", tc.status, res.Status)
+			}
+
+			body, err := ioutil.ReadAll(res.Body)
+			if err != nil {
+				t.Fatal("err reading response body", err)
+			}
+
+			if bodyStr := string(body); bodyStr != tc.bodyStr {
+				t.Errorf("expected body string \n\n%v\n\n, got\n\n%v", tc.bodyStr, bodyStr)
+			}
+
+			if errTrailer := res.Trailer.Get(StreamErrHeader); errTrailer != tc.errTrailer {
+				t.Errorf("expected error header %q, got %q", tc.errTrailer, errTrailer)
+			}
+		}
+	}
+
+	for i, tc := range tcs {
+		t.Run(fmt.Sprintf("%d-%s", i, strings.Join(tc.path, "/")), mkTest(tc))
+	}
+}

http/http_test.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"reflect"
 	"runtime"
+	"strings"
 	"testing"
 
 	"github.com/ipfs/go-ipfs-cmds"
@@ -71,6 +72,7 @@ func TestHTTP(t *testing.T) {
 			}
 
 			v, err := res.Next()
+			t.Log("v:", v, "err:", err)
 			if tc.err != nil {
 				if err == nil {
 					t.Error("got nil error, expected:", tc.err)
@@ -132,6 +134,6 @@ func TestHTTP(t *testing.T) {
 	}
 
 	for i, tc := range tcs {
-		t.Run(fmt.Sprint(i), mkTest(tc))
+		t.Run(fmt.Sprintf("%d-%s", i, strings.Join(tc.path, "/")), mkTest(tc))
 	}
 }

http/parse.go

@@ -218,7 +218,10 @@ func parseResponse(httpRes *http.Response, req *cmds.Request) (cmds.Response, er
 			return nil, fmt.Errorf("unknown error content type: %s", contentType)
 		default:
 			// handle errors from headers
-			e.Message = httpRes.Header.Get(StreamErrHeader)
+			err := res.dec.Decode(e)
+			if err != nil {
+				log.Errorf("error parsing error: ", err.Error())
+			}
 		}
 
 		res.initErr = e

http/responseemitter.go

@@ -70,7 +70,6 @@ type responseEmitter struct {
 }
 
 func (re *responseEmitter) Emit(value interface{}) error {
-
 	// Initially this library allowed commands to return errors by sending an
 	// error value along a stream. We removed that in favour of CloseWithError,
 	// so we want to make sure we catch situations where some code still uses the
@@ -112,19 +111,23 @@ func (re *responseEmitter) Emit(value interface{}) error {
 		isSingle = true
 	}
 
+	if f, ok := re.w.(http.Flusher); ok {
+		defer f.Flush()
+	}
+
 	switch v := value.(type) {
+	case error:
+		return re.closeWithError(v)
 	case io.Reader:
 		err = flushCopy(re.w, v)
 	default:
 		err = re.enc.Encode(value)
 	}
 
-	if f, ok := re.w.(http.Flusher); ok {
-		f.Flush()
-	}
-
 	if isSingle {
-		err = re.closeWithError(err)
+		// always close singles with nil error.
+		// encoding errors go to caller.
+		err = re.closeWithError(nil)
 	}
 
 	return err
@@ -148,16 +151,13 @@ func (re *responseEmitter) CloseWithError(err error) error {
 	re.l.Lock()
 	defer re.l.Unlock()
 
-	if re.closed {
-		return cmds.ErrClosingClosedEmitter
-	}
-
 	return re.closeWithError(err)
 }
 
 func (re *responseEmitter) closeWithError(err error) error {
-	// encoding error, only set if err != nil/EOF
-	var encErr error
+	if re.closed {
+		return cmds.ErrClosingClosedEmitter
+	}
 
 	if err == io.EOF {
 		err = nil
@@ -166,27 +166,24 @@ func (re *responseEmitter) closeWithError(err error) error {
 		err = &e
 	}
 
+	setErrTrailer := true
+
 	// use preamble directly, we're already in critical section
 	// preamble needs to be before branch below, because the headers need to be written before writing the response
-	re.once.Do(func() { re.doPreamble(err) })
+	re.once.Do(func() {
+		re.doPreamble(err)
 
-	if err != nil {
-		re.w.Header().Set(StreamErrHeader, err.Error())
+		// do not set error trailer if we send the error as value in preamble
+		setErrTrailer = false
+	})
 
-		// also send the error as a value if we have an encoder
-		if re.enc != nil {
-			e, ok := err.(*cmdkit.Error)
-			if !ok {
-				e = &cmdkit.Error{Message: err.Error()}
-			}
-
-			encErr = re.enc.Encode(e)
-		}
+	if setErrTrailer && err != nil {
+		re.w.Header().Set(StreamErrHeader, err.Error())
 	}
 
 	re.closed = true
 
-	return encErr
+	return nil
 }
 
 // Flush the http connection
@@ -229,10 +226,8 @@ func (re *responseEmitter) doPreamble(value interface{}) {
 		} else {
 			status = http.StatusInternalServerError
 		}
-		h.Set(StreamErrHeader, err.Message)
 	case error:
 		status = http.StatusInternalServerError
-		h.Set(StreamErrHeader, v.Error())
 	default:
 		h.Set(channelHeader, "1")
 	}
@@ -259,6 +254,19 @@ func (re *responseEmitter) doPreamble(value interface{}) {
 	h.Set("Access-Control-Expose-Headers", AllowedExposedHeaders)
 
 	re.w.WriteHeader(status)
+
+	if err, ok := value.(error); ok {
+		if _, ok := err.(*cmdkit.Error); !ok {
+			err = &cmdkit.Error{Message: err.Error()}
+		}
+
+		err = re.enc.Encode(err)
+		if err != nil {
+			log.Error("error sending error value after non-200 response", err)
+		}
+
+		re.closed = true
+	}
 }
 
 type responseWriterer interface {