glide up

vendor/github.com/go-kit/kit/transport/http/client.go

@@ -1,14 +1,10 @@
 package http
 
 import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"encoding/xml"
-	"io/ioutil"
 	"net/http"
 	"net/url"
 
+	"golang.org/x/net/context"
 	"golang.org/x/net/context/ctxhttp"
 
 	"github.com/go-kit/kit/endpoint"
@@ -62,14 +58,14 @@ func SetClient(client *http.Client) ClientOption {
 // ClientBefore sets the RequestFuncs that are applied to the outgoing HTTP
 // request before it's invoked.
 func ClientBefore(before ...RequestFunc) ClientOption {
-	return func(c *Client) { c.before = append(c.before, before...) }
+	return func(c *Client) { c.before = before }
 }
 
 // ClientAfter sets the ClientResponseFuncs applied to the incoming HTTP
 // request prior to it being decoded. This is useful for obtaining anything off
 // of the response and adding onto the context prior to decoding.
 func ClientAfter(after ...ClientResponseFunc) ClientOption {
-	return func(c *Client) { c.after = append(c.after, after...) }
+	return func(c *Client) { c.after = after }
 }
 
 // BufferedStream sets whether the Response.Body is left open, allowing it
@@ -86,11 +82,11 @@ func (c Client) Endpoint() endpoint.Endpoint {
 
 		req, err := http.NewRequest(c.method, c.tgt.String(), nil)
 		if err != nil {
-			return nil, err
+			return nil, Error{Domain: DomainNewRequest, Err: err}
 		}
 
 		if err = c.enc(ctx, req, request); err != nil {
-			return nil, err
+			return nil, Error{Domain: DomainEncode, Err: err}
 		}
 
 		for _, f := range c.before {
@@ -99,7 +95,7 @@ func (c Client) Endpoint() endpoint.Endpoint {
 
 		resp, err := ctxhttp.Do(ctx, c.client, req)
 		if err != nil {
-			return nil, err
+			return nil, Error{Domain: DomainDo, Err: err}
 		}
 		if !c.bufferedStream {
 			defer resp.Body.Close()
@@ -111,40 +107,9 @@ func (c Client) Endpoint() endpoint.Endpoint {
 
 		response, err := c.dec(ctx, resp)
 		if err != nil {
-			return nil, err
+			return nil, Error{Domain: DomainDecode, Err: err}
 		}
 
 		return response, nil
 	}
 }
-
-// EncodeJSONRequest is an EncodeRequestFunc that serializes the request as a
-// JSON object to the Request body. Many JSON-over-HTTP services can use it as
-// a sensible default. If the request implements Headerer, the provided headers
-// will be applied to the request.
-func EncodeJSONRequest(c context.Context, r *http.Request, request interface{}) error {
-	r.Header.Set("Content-Type", "application/json; charset=utf-8")
-	if headerer, ok := request.(Headerer); ok {
-		for k := range headerer.Headers() {
-			r.Header.Set(k, headerer.Headers().Get(k))
-		}
-	}
-	var b bytes.Buffer
-	r.Body = ioutil.NopCloser(&b)
-	return json.NewEncoder(&b).Encode(request)
-}
-
-// EncodeXMLRequest is an EncodeRequestFunc that serializes the request as a
-// XML object to the Request body. If the request implements Headerer,
-// the provided headers will be applied to the request.
-func EncodeXMLRequest(c context.Context, r *http.Request, request interface{}) error {
-	r.Header.Set("Content-Type", "text/xml; charset=utf-8")
-	if headerer, ok := request.(Headerer); ok {
-		for k := range headerer.Headers() {
-			r.Header.Set(k, headerer.Headers().Get(k))
-		}
-	}
-	var b bytes.Buffer
-	r.Body = ioutil.NopCloser(&b)
-	return xml.NewEncoder(&b).Encode(request)
-}

vendor/github.com/go-kit/kit/transport/http/client_test.go

@@ -1,15 +1,15 @@
 package http_test
 
 import (
-	"context"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"testing"
 	"time"
 
+	"golang.org/x/net/context"
+
 	httptransport "github.com/go-kit/kit/transport/http"
 )
 
@@ -140,68 +140,6 @@ func TestHTTPClientBufferedStream(t *testing.T) {
 	}
 }
 
-func TestEncodeJSONRequest(t *testing.T) {
-	var header http.Header
-	var body string
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		b, err := ioutil.ReadAll(r.Body)
-		if err != nil && err != io.EOF {
-			t.Fatal(err)
-		}
-		header = r.Header
-		body = string(b)
-	}))
-
-	defer server.Close()
-
-	serverURL, err := url.Parse(server.URL)
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	client := httptransport.NewClient(
-		"POST",
-		serverURL,
-		httptransport.EncodeJSONRequest,
-		func(context.Context, *http.Response) (interface{}, error) { return nil, nil },
-	).Endpoint()
-
-	for _, test := range []struct {
-		value interface{}
-		body  string
-	}{
-		{nil, "null\n"},
-		{12, "12\n"},
-		{1.2, "1.2\n"},
-		{true, "true\n"},
-		{"test", "\"test\"\n"},
-		{enhancedRequest{Foo: "foo"}, "{\"foo\":\"foo\"}\n"},
-	} {
-		if _, err := client(context.Background(), test.value); err != nil {
-			t.Error(err)
-			continue
-		}
-
-		if body != test.body {
-			t.Errorf("%v: actual %#v, expected %#v", test.value, body, test.body)
-		}
-	}
-
-	if _, err := client(context.Background(), enhancedRequest{Foo: "foo"}); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, ok := header["X-Edward"]; !ok {
-		t.Fatalf("X-Edward value: actual %v, expected %v", nil, []string{"Snowden"})
-	}
-
-	if v := header.Get("X-Edward"); v != "Snowden" {
-		t.Errorf("X-Edward string: actual %v, expected %v", v, "Snowden")
-	}
-}
-
 func mustParse(s string) *url.URL {
 	u, err := url.Parse(s)
 	if err != nil {
@@ -209,9 +147,3 @@ func mustParse(s string) *url.URL {
 	}
 	return u
 }
-
-type enhancedRequest struct {
-	Foo string `json:"foo"`
-}
-
-func (e enhancedRequest) Headers() http.Header { return http.Header{"X-Edward": []string{"Snowden"}} }

vendor/github.com/go-kit/kit/transport/http/encode_decode.go

@@ -1,8 +1,9 @@
 package http
 
 import (
-	"context"
 	"net/http"
+
+	"golang.org/x/net/context"
 )
 
 // DecodeRequestFunc extracts a user-domain request object from an HTTP

vendor/github.com/go-kit/kit/transport/http/err.go

@@ -0,0 +1,33 @@
+package http
+
+import (
+	"fmt"
+)
+
+const (
+	// DomainNewRequest is an error during request generation.
+	DomainNewRequest = "NewRequest"
+
+	// DomainEncode is an error during request or response encoding.
+	DomainEncode = "Encode"
+
+	// DomainDo is an error during the execution phase of the request.
+	DomainDo = "Do"
+
+	// DomainDecode is an error during request or response decoding.
+	DomainDecode = "Decode"
+)
+
+// Error is an error that occurred at some phase within the transport.
+type Error struct {
+	// Domain is the phase in which the error was generated.
+	Domain string
+
+	// Err is the concrete error.
+	Err error
+}
+
+// Error implements the error interface.
+func (e Error) Error() string {
+	return fmt.Sprintf("%s: %s", e.Domain, e.Err)
+}

vendor/github.com/go-kit/kit/transport/http/err_test.go

@@ -0,0 +1,56 @@
+package http_test
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"testing"
+
+	"golang.org/x/net/context"
+
+	httptransport "github.com/go-kit/kit/transport/http"
+)
+
+func TestClientEndpointEncodeError(t *testing.T) {
+	var (
+		sampleErr = errors.New("Oh no, an error")
+		enc       = func(context.Context, *http.Request, interface{}) error { return sampleErr }
+		dec       = func(context.Context, *http.Response) (interface{}, error) { return nil, nil }
+	)
+
+	u := &url.URL{
+		Scheme: "https",
+		Host:   "localhost",
+		Path:   "/does/not/matter",
+	}
+
+	c := httptransport.NewClient(
+		"GET",
+		u,
+		enc,
+		dec,
+	)
+
+	_, err := c.Endpoint()(context.Background(), nil)
+	if err == nil {
+		t.Fatal("err == nil")
+	}
+
+	e, ok := err.(httptransport.Error)
+	if !ok {
+		t.Fatal("err is not of type github.com/go-kit/kit/transport/http.Error")
+	}
+
+	if want, have := sampleErr, e.Err; want != have {
+		t.Fatalf("want %v, have %v", want, have)
+	}
+}
+
+func ExampleErrorOutput() {
+	sampleErr := errors.New("oh no, an error")
+	err := httptransport.Error{Domain: httptransport.DomainDo, Err: sampleErr}
+	fmt.Println(err)
+	// Output:
+	// Do: oh no, an error
+}

vendor/github.com/go-kit/kit/transport/http/example_test.go

@@ -1,36 +0,0 @@
-package http
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-)
-
-func ExamplePopulateRequestContext() {
-	handler := NewServer(
-		func(ctx context.Context, request interface{}) (response interface{}, err error) {
-			fmt.Println("Method", ctx.Value(ContextKeyRequestMethod).(string))
-			fmt.Println("RequestPath", ctx.Value(ContextKeyRequestPath).(string))
-			fmt.Println("RequestURI", ctx.Value(ContextKeyRequestURI).(string))
-			fmt.Println("X-Request-ID", ctx.Value(ContextKeyRequestXRequestID).(string))
-			return struct{}{}, nil
-		},
-		func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
-		func(context.Context, http.ResponseWriter, interface{}) error { return nil },
-		ServerBefore(PopulateRequestContext),
-	)
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-
-	req, _ := http.NewRequest("PATCH", fmt.Sprintf("%s/search?q=sympatico", server.URL), nil)
-	req.Header.Set("X-Request-Id", "a1b2c3d4e5")
-	http.DefaultClient.Do(req)
-
-	// Output:
-	// Method PATCH
-	// RequestPath /search
-	// RequestURI /search?q=sympatico
-	// X-Request-ID a1b2c3d4e5
-}

vendor/github.com/go-kit/kit/transport/http/request_response_funcs.go

@@ -1,8 +1,9 @@
 package http
 
 import (
-	"context"
 	"net/http"
+
+	"golang.org/x/net/context"
 )
 
 // RequestFunc may take information from an HTTP request and put it into a
@@ -21,13 +22,13 @@ type ServerResponseFunc func(context.Context, http.ResponseWriter) context.Conte
 // clients, after a request has been made, but prior to it being decoded.
 type ClientResponseFunc func(context.Context, *http.Response) context.Context
 
-// SetContentType returns a ServerResponseFunc that sets the Content-Type header
-// to the provided value.
+// SetContentType returns a ResponseFunc that sets the Content-Type header to
+// the provided value.
 func SetContentType(contentType string) ServerResponseFunc {
 	return SetResponseHeader("Content-Type", contentType)
 }
 
-// SetResponseHeader returns a ServerResponseFunc that sets the given header.
+// SetResponseHeader returns a ResponseFunc that sets the specified header.
 func SetResponseHeader(key, val string) ServerResponseFunc {
 	return func(ctx context.Context, w http.ResponseWriter) context.Context {
 		w.Header().Set(key, val)
@@ -35,94 +36,10 @@ func SetResponseHeader(key, val string) ServerResponseFunc {
 	}
 }
 
-// SetRequestHeader returns a RequestFunc that sets the given header.
+// SetRequestHeader returns a RequestFunc that sets the specified header.
 func SetRequestHeader(key, val string) RequestFunc {
 	return func(ctx context.Context, r *http.Request) context.Context {
 		r.Header.Set(key, val)
 		return ctx
 	}
 }
-
-// PopulateRequestContext is a RequestFunc that populates several values into
-// the context from the HTTP request. Those values may be extracted using the
-// corresponding ContextKey type in this package.
-func PopulateRequestContext(ctx context.Context, r *http.Request) context.Context {
-	for k, v := range map[contextKey]string{
-		ContextKeyRequestMethod:          r.Method,
-		ContextKeyRequestURI:             r.RequestURI,
-		ContextKeyRequestPath:            r.URL.Path,
-		ContextKeyRequestProto:           r.Proto,
-		ContextKeyRequestHost:            r.Host,
-		ContextKeyRequestRemoteAddr:      r.RemoteAddr,
-		ContextKeyRequestXForwardedFor:   r.Header.Get("X-Forwarded-For"),
-		ContextKeyRequestXForwardedProto: r.Header.Get("X-Forwarded-Proto"),
-		ContextKeyRequestAuthorization:   r.Header.Get("Authorization"),
-		ContextKeyRequestReferer:         r.Header.Get("Referer"),
-		ContextKeyRequestUserAgent:       r.Header.Get("User-Agent"),
-		ContextKeyRequestXRequestID:      r.Header.Get("X-Request-Id"),
-	} {
-		ctx = context.WithValue(ctx, k, v)
-	}
-	return ctx
-}
-
-type contextKey int
-
-const (
-	// ContextKeyRequestMethod is populated in the context by
-	// PopulateRequestContext. Its value is r.Method.
-	ContextKeyRequestMethod contextKey = iota
-
-	// ContextKeyRequestURI is populated in the context by
-	// PopulateRequestContext. Its value is r.RequestURI.
-	ContextKeyRequestURI
-
-	// ContextKeyRequestPath is populated in the context by
-	// PopulateRequestContext. Its value is r.URL.Path.
-	ContextKeyRequestPath
-
-	// ContextKeyRequestProto is populated in the context by
-	// PopulateRequestContext. Its value is r.Proto.
-	ContextKeyRequestProto
-
-	// ContextKeyRequestHost is populated in the context by
-	// PopulateRequestContext. Its value is r.Host.
-	ContextKeyRequestHost
-
-	// ContextKeyRequestRemoteAddr is populated in the context by
-	// PopulateRequestContext. Its value is r.RemoteAddr.
-	ContextKeyRequestRemoteAddr
-
-	// ContextKeyRequestXForwardedFor is populated in the context by
-	// PopulateRequestContext. Its value is r.Header.Get("X-Forwarded-For").
-	ContextKeyRequestXForwardedFor
-
-	// ContextKeyRequestXForwardedProto is populated in the context by
-	// PopulateRequestContext. Its value is r.Header.Get("X-Forwarded-Proto").
-	ContextKeyRequestXForwardedProto
-
-	// ContextKeyRequestAuthorization is populated in the context by
-	// PopulateRequestContext. Its value is r.Header.Get("Authorization").
-	ContextKeyRequestAuthorization
-
-	// ContextKeyRequestReferer is populated in the context by
-	// PopulateRequestContext. Its value is r.Header.Get("Referer").
-	ContextKeyRequestReferer
-
-	// ContextKeyRequestUserAgent is populated in the context by
-	// PopulateRequestContext. Its value is r.Header.Get("User-Agent").
-	ContextKeyRequestUserAgent
-
-	// ContextKeyRequestXRequestID is populated in the context by
-	// PopulateRequestContext. Its value is r.Header.Get("X-Request-Id").
-	ContextKeyRequestXRequestID
-
-	// ContextKeyResponseHeaders is populated in the context whenever a
-	// ServerFinalizerFunc is specified. Its value is of type http.Header, and
-	// is captured only once the entire response has been written.
-	ContextKeyResponseHeaders
-
-	// ContextKeyResponseSize is populated in the context whenever a
-	// ServerFinalizerFunc is specified. Its value is of type int64.
-	ContextKeyResponseSize
-)

vendor/github.com/go-kit/kit/transport/http/request_response_funcs_test.go

@@ -1,10 +1,11 @@
 package http_test
 
 import (
-	"context"
 	"net/http/httptest"
 	"testing"
 
+	"golang.org/x/net/context"
+
 	httptransport "github.com/go-kit/kit/transport/http"
 )
 

vendor/github.com/go-kit/kit/transport/http/server.go

@@ -1,39 +1,41 @@
 package http
 
 import (
-	"context"
-	"encoding/json"
 	"net/http"
 
+	"golang.org/x/net/context"
+
 	"github.com/go-kit/kit/endpoint"
 	"github.com/go-kit/kit/log"
 )
 
 // Server wraps an endpoint and implements http.Handler.
 type Server struct {
+	ctx          context.Context
 	e            endpoint.Endpoint
 	dec          DecodeRequestFunc
 	enc          EncodeResponseFunc
 	before       []RequestFunc
 	after        []ServerResponseFunc
 	errorEncoder ErrorEncoder
-	finalizer    ServerFinalizerFunc
 	logger       log.Logger
 }
 
 // NewServer constructs a new server, which implements http.Server and wraps
 // the provided endpoint.
 func NewServer(
+	ctx context.Context,
 	e endpoint.Endpoint,
 	dec DecodeRequestFunc,
 	enc EncodeResponseFunc,
 	options ...ServerOption,
 ) *Server {
 	s := &Server{
+		ctx:          ctx,
 		e:            e,
 		dec:          dec,
 		enc:          enc,
-		errorEncoder: DefaultErrorEncoder,
+		errorEncoder: defaultErrorEncoder,
 		logger:       log.NewNopLogger(),
 	}
 	for _, option := range options {
@@ -48,51 +50,33 @@ type ServerOption func(*Server)
 // ServerBefore functions are executed on the HTTP request object before the
 // request is decoded.
 func ServerBefore(before ...RequestFunc) ServerOption {
-	return func(s *Server) { s.before = append(s.before, before...) }
+	return func(s *Server) { s.before = before }
 }
 
 // ServerAfter functions are executed on the HTTP response writer after the
 // endpoint is invoked, but before anything is written to the client.
 func ServerAfter(after ...ServerResponseFunc) ServerOption {
-	return func(s *Server) { s.after = append(s.after, after...) }
+	return func(s *Server) { s.after = after }
 }
 
 // ServerErrorEncoder is used to encode errors to the http.ResponseWriter
 // whenever they're encountered in the processing of a request. Clients can
 // use this to provide custom error formatting and response codes. By default,
-// errors will be written with the DefaultErrorEncoder.
+// errors will be written as plain text with an appropriate, if generic,
+// status code.
 func ServerErrorEncoder(ee ErrorEncoder) ServerOption {
 	return func(s *Server) { s.errorEncoder = ee }
 }
 
 // ServerErrorLogger is used to log non-terminal errors. By default, no errors
-// are logged. This is intended as a diagnostic measure. Finer-grained control
-// of error handling, including logging in more detail, should be performed in a
-// custom ServerErrorEncoder or ServerFinalizer, both of which have access to
-// the context.
+// are logged.
 func ServerErrorLogger(logger log.Logger) ServerOption {
 	return func(s *Server) { s.logger = logger }
 }
 
-// ServerFinalizer is executed at the end of every HTTP request.
-// By default, no finalizer is registered.
-func ServerFinalizer(f ServerFinalizerFunc) ServerOption {
-	return func(s *Server) { s.finalizer = f }
-}
-
 // ServeHTTP implements http.Handler.
 func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	if s.finalizer != nil {
-		iw := &interceptingWriter{w, http.StatusOK, 0}
-		defer func() {
-			ctx = context.WithValue(ctx, ContextKeyResponseHeaders, iw.Header())
-			ctx = context.WithValue(ctx, ContextKeyResponseSize, iw.written)
-			s.finalizer(ctx, iw.code, r)
-		}()
-		w = iw
-	}
+	ctx := s.ctx
 
 	for _, f := range s.before {
 		ctx = f(ctx, r)
@@ -101,14 +85,14 @@ func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	request, err := s.dec(ctx, r)
 	if err != nil {
 		s.logger.Log("err", err)
-		s.errorEncoder(ctx, err, w)
+		s.errorEncoder(ctx, Error{Domain: DomainDecode, Err: err}, w)
 		return
 	}
 
 	response, err := s.e(ctx, request)
 	if err != nil {
 		s.logger.Log("err", err)
-		s.errorEncoder(ctx, err, w)
+		s.errorEncoder(ctx, Error{Domain: DomainDo, Err: err}, w)
 		return
 	}
 
@@ -118,104 +102,32 @@ func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	if err := s.enc(ctx, w, response); err != nil {
 		s.logger.Log("err", err)
-		s.errorEncoder(ctx, err, w)
+		s.errorEncoder(ctx, Error{Domain: DomainEncode, Err: err}, w)
 		return
 	}
 }
 
 // ErrorEncoder is responsible for encoding an error to the ResponseWriter.
-// Users are encouraged to use custom ErrorEncoders to encode HTTP errors to
-// their clients, and will likely want to pass and check for their own error
-// types. See the example shipping/handling service.
+//
+// In the server implementation, only kit/transport/http.Error values are ever
+// passed to this function, so you might be tempted to have this function take
+// one of those directly. But, users are encouraged to use custom ErrorEncoders
+// to encode all HTTP errors to their clients, and so may want to pass and check
+// for their own error types. See the example shipping/handling service.
 type ErrorEncoder func(ctx context.Context, err error, w http.ResponseWriter)
 
-// ServerFinalizerFunc can be used to perform work at the end of an HTTP
-// request, after the response has been written to the client. The principal
-// intended use is for request logging. In addition to the response code
-// provided in the function signature, additional response parameters are
-// provided in the context under keys with the ContextKeyResponse prefix.
-type ServerFinalizerFunc func(ctx context.Context, code int, r *http.Request)
-
-// EncodeJSONResponse is a EncodeResponseFunc that serializes the response as a
-// JSON object to the ResponseWriter. Many JSON-over-HTTP services can use it as
-// a sensible default. If the response implements Headerer, the provided headers
-// will be applied to the response. If the response implements StatusCoder, the
-// provided StatusCode will be used instead of 200.
-func EncodeJSONResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	if headerer, ok := response.(Headerer); ok {
-		for k := range headerer.Headers() {
-			w.Header().Set(k, headerer.Headers().Get(k))
+func defaultErrorEncoder(_ context.Context, err error, w http.ResponseWriter) {
+	switch e := err.(type) {
+	case Error:
+		switch e.Domain {
+		case DomainDecode:
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		case DomainDo:
+			http.Error(w, err.Error(), http.StatusServiceUnavailable) // too aggressive?
+		default:
+			http.Error(w, err.Error(), http.StatusInternalServerError)
 		}
+	default:
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 	}
-	code := http.StatusOK
-	if sc, ok := response.(StatusCoder); ok {
-		code = sc.StatusCode()
-	}
-	w.WriteHeader(code)
-	if code == http.StatusNoContent {
-		return nil
-	}
-	return json.NewEncoder(w).Encode(response)
-}
-
-// DefaultErrorEncoder writes the error to the ResponseWriter, by default a
-// content type of text/plain, a body of the plain text of the error, and a
-// status code of 500. If the error implements Headerer, the provided headers
-// will be applied to the response. If the error implements json.Marshaler, and
-// the marshaling succeeds, a content type of application/json and the JSON
-// encoded form of the error will be used. If the error implements StatusCoder,
-// the provided StatusCode will be used instead of 500.
-func DefaultErrorEncoder(_ context.Context, err error, w http.ResponseWriter) {
-	contentType, body := "text/plain; charset=utf-8", []byte(err.Error())
-	if marshaler, ok := err.(json.Marshaler); ok {
-		if jsonBody, marshalErr := marshaler.MarshalJSON(); marshalErr == nil {
-			contentType, body = "application/json; charset=utf-8", jsonBody
-		}
-	}
-	w.Header().Set("Content-Type", contentType)
-	if headerer, ok := err.(Headerer); ok {
-		for k := range headerer.Headers() {
-			w.Header().Set(k, headerer.Headers().Get(k))
-		}
-	}
-	code := http.StatusInternalServerError
-	if sc, ok := err.(StatusCoder); ok {
-		code = sc.StatusCode()
-	}
-	w.WriteHeader(code)
-	w.Write(body)
-}
-
-// StatusCoder is checked by DefaultErrorEncoder. If an error value implements
-// StatusCoder, the StatusCode will be used when encoding the error. By default,
-// StatusInternalServerError (500) is used.
-type StatusCoder interface {
-	StatusCode() int
-}
-
-// Headerer is checked by DefaultErrorEncoder. If an error value implements
-// Headerer, the provided headers will be applied to the response writer, after
-// the Content-Type is set.
-type Headerer interface {
-	Headers() http.Header
-}
-
-type interceptingWriter struct {
-	http.ResponseWriter
-	code    int
-	written int64
-}
-
-// WriteHeader may not be explicitly called, so care must be taken to
-// initialize w.code to its default value of http.StatusOK.
-func (w *interceptingWriter) WriteHeader(code int) {
-	w.code = code
-	w.ResponseWriter.WriteHeader(code)
-}
-
-func (w *interceptingWriter) Write(p []byte) (int, error) {
-	n, err := w.ResponseWriter.Write(p)
-	w.written += int64(n)
-	return n, err
 }

vendor/github.com/go-kit/kit/transport/http/server_test.go

@@ -1,21 +1,20 @@
 package http_test
 
 import (
-	"context"
 	"errors"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
-	"strings"
 	"testing"
-	"time"
 
-	"github.com/go-kit/kit/endpoint"
+	"golang.org/x/net/context"
+
 	httptransport "github.com/go-kit/kit/transport/http"
 )
 
 func TestServerBadDecode(t *testing.T) {
 	handler := httptransport.NewServer(
+		context.Background(),
 		func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil },
 		func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, errors.New("dang") },
 		func(context.Context, http.ResponseWriter, interface{}) error { return nil },
@@ -23,13 +22,14 @@ func TestServerBadDecode(t *testing.T) {
 	server := httptest.NewServer(handler)
 	defer server.Close()
 	resp, _ := http.Get(server.URL)
-	if want, have := http.StatusInternalServerError, resp.StatusCode; want != have {
+	if want, have := http.StatusBadRequest, resp.StatusCode; want != have {
 		t.Errorf("want %d, have %d", want, have)
 	}
 }
 
 func TestServerBadEndpoint(t *testing.T) {
 	handler := httptransport.NewServer(
+		context.Background(),
 		func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errors.New("dang") },
 		func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
 		func(context.Context, http.ResponseWriter, interface{}) error { return nil },
@@ -37,13 +37,14 @@ func TestServerBadEndpoint(t *testing.T) {
 	server := httptest.NewServer(handler)
 	defer server.Close()
 	resp, _ := http.Get(server.URL)
-	if want, have := http.StatusInternalServerError, resp.StatusCode; want != have {
+	if want, have := http.StatusServiceUnavailable, resp.StatusCode; want != have {
 		t.Errorf("want %d, have %d", want, have)
 	}
 }
 
 func TestServerBadEncode(t *testing.T) {
 	handler := httptransport.NewServer(
+		context.Background(),
 		func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil },
 		func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
 		func(context.Context, http.ResponseWriter, interface{}) error { return errors.New("dang") },
@@ -59,12 +60,13 @@ func TestServerBadEncode(t *testing.T) {
 func TestServerErrorEncoder(t *testing.T) {
 	errTeapot := errors.New("teapot")
 	code := func(err error) int {
-		if err == errTeapot {
+		if e, ok := err.(httptransport.Error); ok && e.Err == errTeapot {
 			return http.StatusTeapot
 		}
 		return http.StatusInternalServerError
 	}
 	handler := httptransport.NewServer(
+		context.Background(),
 		func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errTeapot },
 		func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
 		func(context.Context, http.ResponseWriter, interface{}) error { return nil },
@@ -79,7 +81,7 @@ func TestServerErrorEncoder(t *testing.T) {
 }
 
 func TestServerHappyPath(t *testing.T) {
-	step, response := testServer(t)
+	_, step, response := testServer(t)
 	step()
 	resp := <-response
 	defer resp.Body.Close()
@@ -89,245 +91,14 @@ func TestServerHappyPath(t *testing.T) {
 	}
 }
 
-func TestMultipleServerBefore(t *testing.T) {
+func testServer(t *testing.T) (cancel, step func(), resp <-chan *http.Response) {
 	var (
-		headerKey    = "X-Henlo-Lizer"
-		headerVal    = "Helllo you stinky lizard"
-		statusCode   = http.StatusTeapot
-		responseBody = "go eat a fly ugly\n"
-		done         = make(chan struct{})
-	)
-	handler := httptransport.NewServer(
-		endpoint.Nop,
-		func(context.Context, *http.Request) (interface{}, error) {
-			return struct{}{}, nil
-		},
-		func(_ context.Context, w http.ResponseWriter, _ interface{}) error {
-			w.Header().Set(headerKey, headerVal)
-			w.WriteHeader(statusCode)
-			w.Write([]byte(responseBody))
-			return nil
-		},
-		httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context {
-			ctx = context.WithValue(ctx, "one", 1)
-
-			return ctx
-		}),
-		httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context {
-			if _, ok := ctx.Value("one").(int); !ok {
-				t.Error("Value was not set properly when multiple ServerBefores are used")
-			}
-
-			close(done)
-			return ctx
-		}),
-	)
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-	go http.Get(server.URL)
-
-	select {
-	case <-done:
-	case <-time.After(time.Second):
-		t.Fatal("timeout waiting for finalizer")
-	}
-}
-
-func TestMultipleServerAfter(t *testing.T) {
-	var (
-		headerKey    = "X-Henlo-Lizer"
-		headerVal    = "Helllo you stinky lizard"
-		statusCode   = http.StatusTeapot
-		responseBody = "go eat a fly ugly\n"
-		done         = make(chan struct{})
-	)
-	handler := httptransport.NewServer(
-		endpoint.Nop,
-		func(context.Context, *http.Request) (interface{}, error) {
-			return struct{}{}, nil
-		},
-		func(_ context.Context, w http.ResponseWriter, _ interface{}) error {
-			w.Header().Set(headerKey, headerVal)
-			w.WriteHeader(statusCode)
-			w.Write([]byte(responseBody))
-			return nil
-		},
-		httptransport.ServerAfter(func(ctx context.Context, w http.ResponseWriter) context.Context {
-			ctx = context.WithValue(ctx, "one", 1)
-
-			return ctx
-		}),
-		httptransport.ServerAfter(func(ctx context.Context, w http.ResponseWriter) context.Context {
-			if _, ok := ctx.Value("one").(int); !ok {
-				t.Error("Value was not set properly when multiple ServerAfters are used")
-			}
-
-			close(done)
-			return ctx
-		}),
-	)
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-	go http.Get(server.URL)
-
-	select {
-	case <-done:
-	case <-time.After(time.Second):
-		t.Fatal("timeout waiting for finalizer")
-	}
-}
-
-func TestServerFinalizer(t *testing.T) {
-	var (
-		headerKey    = "X-Henlo-Lizer"
-		headerVal    = "Helllo you stinky lizard"
-		statusCode   = http.StatusTeapot
-		responseBody = "go eat a fly ugly\n"
-		done         = make(chan struct{})
-	)
-	handler := httptransport.NewServer(
-		endpoint.Nop,
-		func(context.Context, *http.Request) (interface{}, error) {
-			return struct{}{}, nil
-		},
-		func(_ context.Context, w http.ResponseWriter, _ interface{}) error {
-			w.Header().Set(headerKey, headerVal)
-			w.WriteHeader(statusCode)
-			w.Write([]byte(responseBody))
-			return nil
-		},
-		httptransport.ServerFinalizer(func(ctx context.Context, code int, _ *http.Request) {
-			if want, have := statusCode, code; want != have {
-				t.Errorf("StatusCode: want %d, have %d", want, have)
-			}
-
-			responseHeader := ctx.Value(httptransport.ContextKeyResponseHeaders).(http.Header)
-			if want, have := headerVal, responseHeader.Get(headerKey); want != have {
-				t.Errorf("%s: want %q, have %q", headerKey, want, have)
-			}
-
-			responseSize := ctx.Value(httptransport.ContextKeyResponseSize).(int64)
-			if want, have := int64(len(responseBody)), responseSize; want != have {
-				t.Errorf("response size: want %d, have %d", want, have)
-			}
-
-			close(done)
-		}),
-	)
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-	go http.Get(server.URL)
-
-	select {
-	case <-done:
-	case <-time.After(time.Second):
-		t.Fatal("timeout waiting for finalizer")
-	}
-}
-
-type enhancedResponse struct {
-	Foo string `json:"foo"`
-}
-
-func (e enhancedResponse) StatusCode() int      { return http.StatusPaymentRequired }
-func (e enhancedResponse) Headers() http.Header { return http.Header{"X-Edward": []string{"Snowden"}} }
-
-func TestEncodeJSONResponse(t *testing.T) {
-	handler := httptransport.NewServer(
-		func(context.Context, interface{}) (interface{}, error) { return enhancedResponse{Foo: "bar"}, nil },
-		func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
-		httptransport.EncodeJSONResponse,
-	)
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-
-	resp, err := http.Get(server.URL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if want, have := http.StatusPaymentRequired, resp.StatusCode; want != have {
-		t.Errorf("StatusCode: want %d, have %d", want, have)
-	}
-	if want, have := "Snowden", resp.Header.Get("X-Edward"); want != have {
-		t.Errorf("X-Edward: want %q, have %q", want, have)
-	}
-	buf, _ := ioutil.ReadAll(resp.Body)
-	if want, have := `{"foo":"bar"}`, strings.TrimSpace(string(buf)); want != have {
-		t.Errorf("Body: want %s, have %s", want, have)
-	}
-}
-
-type noContentResponse struct{}
-
-func (e noContentResponse) StatusCode() int { return http.StatusNoContent }
-
-func TestEncodeNoContent(t *testing.T) {
-	handler := httptransport.NewServer(
-		func(context.Context, interface{}) (interface{}, error) { return noContentResponse{}, nil },
-		func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
-		httptransport.EncodeJSONResponse,
-	)
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-
-	resp, err := http.Get(server.URL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if want, have := http.StatusNoContent, resp.StatusCode; want != have {
-		t.Errorf("StatusCode: want %d, have %d", want, have)
-	}
-	buf, _ := ioutil.ReadAll(resp.Body)
-	if want, have := 0, len(buf); want != have {
-		t.Errorf("Body: want no content, have %d bytes", have)
-	}
-}
-
-type enhancedError struct{}
-
-func (e enhancedError) Error() string                { return "enhanced error" }
-func (e enhancedError) StatusCode() int              { return http.StatusTeapot }
-func (e enhancedError) MarshalJSON() ([]byte, error) { return []byte(`{"err":"enhanced"}`), nil }
-func (e enhancedError) Headers() http.Header         { return http.Header{"X-Enhanced": []string{"1"}} }
-
-func TestEnhancedError(t *testing.T) {
-	handler := httptransport.NewServer(
-		func(context.Context, interface{}) (interface{}, error) { return nil, enhancedError{} },
-		func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
-		func(_ context.Context, w http.ResponseWriter, _ interface{}) error { return nil },
-	)
-
-	server := httptest.NewServer(handler)
-	defer server.Close()
-
-	resp, err := http.Get(server.URL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer resp.Body.Close()
-	if want, have := http.StatusTeapot, resp.StatusCode; want != have {
-		t.Errorf("StatusCode: want %d, have %d", want, have)
-	}
-	if want, have := "1", resp.Header.Get("X-Enhanced"); want != have {
-		t.Errorf("X-Enhanced: want %q, have %q", want, have)
-	}
-	buf, _ := ioutil.ReadAll(resp.Body)
-	if want, have := `{"err":"enhanced"}`, strings.TrimSpace(string(buf)); want != have {
-		t.Errorf("Body: want %s, have %s", want, have)
-	}
-}
-
-func testServer(t *testing.T) (step func(), resp <-chan *http.Response) {
-	var (
-		stepch   = make(chan bool)
-		endpoint = func(context.Context, interface{}) (interface{}, error) { <-stepch; return struct{}{}, nil }
-		response = make(chan *http.Response)
-		handler  = httptransport.NewServer(
+		ctx, cancelfn = context.WithCancel(context.Background())
+		stepch        = make(chan bool)
+		endpoint      = func(context.Context, interface{}) (interface{}, error) { <-stepch; return struct{}{}, nil }
+		response      = make(chan *http.Response)
+		handler       = httptransport.NewServer(
+			ctx,
 			endpoint,
 			func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
 			func(context.Context, http.ResponseWriter, interface{}) error { return nil },
@@ -345,5 +116,5 @@ func testServer(t *testing.T) (step func(), resp <-chan *http.Response) {
 		}
 		response <- resp
 	}()
-	return func() { stepch <- true }, response
+	return cancelfn, func() { stepch <- true }, response
 }