Codebase list golang-github-go-kit-kit / 5f48909
transport/http: encoders and decoders take context This is necessary to pass context through to the error encoder. Also, update (fix) all examples. Peter Bourgon 7 years ago
17 changed file(s) with 100 addition(s) and 87 deletion(s). Raw diff Collapse all Expand all
169169 log.Fatal(http.ListenAndServe(":8080", nil))
170170 }
171171
172 func decodeUppercaseRequest(r *http.Request) (interface{}, error) {
172 func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) {
173173 var request uppercaseRequest
174174 if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
175175 return nil, err
177177 return request, nil
178178 }
179179
180 func decodeCountRequest(r *http.Request) (interface{}, error) {
180 func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) {
181181 var request countRequest
182182 if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
183183 return nil, err
185185 return request, nil
186186 }
187187
188 func encodeResponse(w http.ResponseWriter, response interface{}) error {
188 func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
189189 return json.NewEncoder(w).Encode(response)
190190 }
191191 ```
44 "encoding/json"
55 "io/ioutil"
66 "net/http"
7
8 "golang.org/x/net/context"
79 )
810
911 // DecodeSumRequest decodes the request from the provided HTTP request, simply
1012 // by JSON decoding from the request body. It's designed to be used in
1113 // transport/http.Server.
12 func DecodeSumRequest(r *http.Request) (interface{}, error) {
14 func DecodeSumRequest(_ context.Context, r *http.Request) (interface{}, error) {
1315 var request SumRequest
1416 err := json.NewDecoder(r.Body).Decode(&request)
1517 return &request, err
1820 // EncodeSumResponse encodes the response to the provided HTTP response
1921 // writer, simply by JSON encoding to the writer. It's designed to be used in
2022 // transport/http.Server.
21 func EncodeSumResponse(w http.ResponseWriter, response interface{}) error {
23 func EncodeSumResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
2224 return json.NewEncoder(w).Encode(response)
2325 }
2426
2527 // DecodeConcatRequest decodes the request from the provided HTTP request,
2628 // simply by JSON decoding from the request body. It's designed to be used in
2729 // transport/http.Server.
28 func DecodeConcatRequest(r *http.Request) (interface{}, error) {
30 func DecodeConcatRequest(_ context.Context, r *http.Request) (interface{}, error) {
2931 var request ConcatRequest
3032 err := json.NewDecoder(r.Body).Decode(&request)
3133 return &request, err
3436 // EncodeConcatResponse encodes the response to the provided HTTP response
3537 // writer, simply by JSON encoding to the writer. It's designed to be used in
3638 // transport/http.Server.
37 func EncodeConcatResponse(w http.ResponseWriter, response interface{}) error {
39 func EncodeConcatResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
3840 return json.NewEncoder(w).Encode(response)
3941 }
4042
4143 // EncodeSumRequest encodes the request to the provided HTTP request, simply
4244 // by JSON encoding to the request body. It's designed to be used in
4345 // transport/http.Client.
44 func EncodeSumRequest(r *http.Request, request interface{}) error {
46 func EncodeSumRequest(_ context.Context, r *http.Request, request interface{}) error {
4547 var buf bytes.Buffer
4648 if err := json.NewEncoder(&buf).Encode(request); err != nil {
4749 return err
5355 // DecodeSumResponse decodes the response from the provided HTTP response,
5456 // simply by JSON decoding from the response body. It's designed to be used in
5557 // transport/http.Client.
56 func DecodeSumResponse(resp *http.Response) (interface{}, error) {
58 func DecodeSumResponse(_ context.Context, resp *http.Response) (interface{}, error) {
5759 var response SumResponse
5860 err := json.NewDecoder(resp.Body).Decode(&response)
5961 return response, err
6264 // EncodeConcatRequest encodes the request to the provided HTTP request,
6365 // simply by JSON encoding to the request body. It's designed to be used in
6466 // transport/http.Client.
65 func EncodeConcatRequest(r *http.Request, request interface{}) error {
67 func EncodeConcatRequest(_ context.Context, r *http.Request, request interface{}) error {
6668 var buf bytes.Buffer
6769 if err := json.NewEncoder(&buf).Encode(request); err != nil {
6870 return err
7476 // DecodeConcatResponse decodes the response from the provided HTTP response,
7577 // simply by JSON decoding from the response body. It's designed to be used in
7678 // transport/http.Client.
77 func DecodeConcatResponse(resp *http.Response) (interface{}, error) {
79 func DecodeConcatResponse(_ context.Context, resp *http.Response) (interface{}, error) {
7880 var response ConcatResponse
7981 err := json.NewDecoder(resp.Body).Decode(&response)
8082 return response, err
172172 }
173173 }
174174
175 func passEncode(r *http.Request, request interface{}) error {
175 func passEncode(_ context.Context, r *http.Request, request interface{}) error {
176176 r.Body = request.(io.ReadCloser)
177177 return nil
178178 }
179179
180 func passDecode(r *http.Response) (interface{}, error) {
180 func passDecode(_ context.Context, r *http.Response) (interface{}, error) {
181181 return ioutil.ReadAll(r.Body)
182182 }
183183
100100 return r
101101 }
102102
103 func decodePostProfileRequest(r *stdhttp.Request) (request interface{}, err error) {
103 func decodePostProfileRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
104104 var req postProfileRequest
105105 if e := json.NewDecoder(r.Body).Decode(&req.Profile); e != nil {
106106 return nil, e
108108 return req, nil
109109 }
110110
111 func decodeGetProfileRequest(r *stdhttp.Request) (request interface{}, err error) {
111 func decodeGetProfileRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
112112 vars := mux.Vars(r)
113113 id, ok := vars["id"]
114114 if !ok {
117117 return getProfileRequest{ID: id}, nil
118118 }
119119
120 func decodePutProfileRequest(r *stdhttp.Request) (request interface{}, err error) {
120 func decodePutProfileRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
121121 vars := mux.Vars(r)
122122 id, ok := vars["id"]
123123 if !ok {
133133 }, nil
134134 }
135135
136 func decodePatchProfileRequest(r *stdhttp.Request) (request interface{}, err error) {
136 func decodePatchProfileRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
137137 vars := mux.Vars(r)
138138 id, ok := vars["id"]
139139 if !ok {
149149 }, nil
150150 }
151151
152 func decodeDeleteProfileRequest(r *stdhttp.Request) (request interface{}, err error) {
152 func decodeDeleteProfileRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
153153 vars := mux.Vars(r)
154154 id, ok := vars["id"]
155155 if !ok {
158158 return deleteProfileRequest{ID: id}, nil
159159 }
160160
161 func decodeGetAddressesRequest(r *stdhttp.Request) (request interface{}, err error) {
161 func decodeGetAddressesRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
162162 vars := mux.Vars(r)
163163 id, ok := vars["id"]
164164 if !ok {
167167 return getAddressesRequest{ProfileID: id}, nil
168168 }
169169
170 func decodeGetAddressRequest(r *stdhttp.Request) (request interface{}, err error) {
170 func decodeGetAddressRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
171171 vars := mux.Vars(r)
172172 id, ok := vars["id"]
173173 if !ok {
183183 }, nil
184184 }
185185
186 func decodePostAddressRequest(r *stdhttp.Request) (request interface{}, err error) {
186 func decodePostAddressRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
187187 vars := mux.Vars(r)
188188 id, ok := vars["id"]
189189 if !ok {
199199 }, nil
200200 }
201201
202 func decodeDeleteAddressRequest(r *stdhttp.Request) (request interface{}, err error) {
202 func decodeDeleteAddressRequest(_ context.Context, r *stdhttp.Request) (request interface{}, err error) {
203203 vars := mux.Vars(r)
204204 id, ok := vars["id"]
205205 if !ok {
227227 // client. I chose to do it this way because I didn't know if something more
228228 // specific was necessary. It's certainly possible to specialize on a
229229 // per-response (per-method) basis.
230 func encodeResponse(w stdhttp.ResponseWriter, response interface{}) error {
230 func encodeResponse(ctx context.Context, w stdhttp.ResponseWriter, response interface{}) error {
231231 if e, ok := response.(errorer); ok && e.error() != nil {
232232 // Not a Go kit transport error, but a business-logic error.
233233 // Provide those as HTTP errors.
234 encodeError(w, e.error())
234 encodeError(ctx, e.error(), w)
235235 return nil
236236 }
237237 return json.NewEncoder(w).Encode(response)
238238 }
239239
240 func encodeError(w stdhttp.ResponseWriter, err error) {
240 func encodeError(_ context.Context, err error, w stdhttp.ResponseWriter) {
241241 if err == nil {
242242 panic("encodeError with nil error")
243243 }
254254 case errAlreadyExists, errInconsistentIDs:
255255 return stdhttp.StatusBadRequest
256256 default:
257 if _, ok := err.(kithttp.BadRequestError); ok {
258 return stdhttp.StatusBadRequest
257 if e, ok := err.(kithttp.TransportError); ok {
258 switch e.Domain {
259 case kithttp.DomainDecode:
260 return stdhttp.StatusBadRequest
261 case kithttp.DomainDo:
262 return stdhttp.StatusServiceUnavailable
263 default:
264 return stdhttp.StatusInternalServerError
265 }
259266 }
260267 return stdhttp.StatusInternalServerError
261268 }
8787
8888 var errBadRoute = errors.New("bad route")
8989
90 func decodeBookCargoRequest(r *http.Request) (interface{}, error) {
90 func decodeBookCargoRequest(_ context.Context, r *http.Request) (interface{}, error) {
9191 var body struct {
9292 Origin string `json:"origin"`
9393 Destination string `json:"destination"`
105105 }, nil
106106 }
107107
108 func decodeLoadCargoRequest(r *http.Request) (interface{}, error) {
108 func decodeLoadCargoRequest(_ context.Context, r *http.Request) (interface{}, error) {
109109 vars := mux.Vars(r)
110110 id, ok := vars["id"]
111111 if !ok {
114114 return loadCargoRequest{ID: cargo.TrackingID(id)}, nil
115115 }
116116
117 func decodeRequestRoutesRequest(r *http.Request) (interface{}, error) {
117 func decodeRequestRoutesRequest(_ context.Context, r *http.Request) (interface{}, error) {
118118 vars := mux.Vars(r)
119119 id, ok := vars["id"]
120120 if !ok {
123123 return requestRoutesRequest{ID: cargo.TrackingID(id)}, nil
124124 }
125125
126 func decodeAssignToRouteRequest(r *http.Request) (interface{}, error) {
126 func decodeAssignToRouteRequest(_ context.Context, r *http.Request) (interface{}, error) {
127127 vars := mux.Vars(r)
128128 id, ok := vars["id"]
129129 if !ok {
141141 }, nil
142142 }
143143
144 func decodeChangeDestinationRequest(r *http.Request) (interface{}, error) {
144 func decodeChangeDestinationRequest(_ context.Context, r *http.Request) (interface{}, error) {
145145 vars := mux.Vars(r)
146146 id, ok := vars["id"]
147147 if !ok {
162162 }, nil
163163 }
164164
165 func decodeListCargosRequest(r *http.Request) (interface{}, error) {
165 func decodeListCargosRequest(_ context.Context, r *http.Request) (interface{}, error) {
166166 return listCargosRequest{}, nil
167167 }
168168
169 func decodeListLocationsRequest(r *http.Request) (interface{}, error) {
169 func decodeListLocationsRequest(_ context.Context, r *http.Request) (interface{}, error) {
170170 return listLocationsRequest{}, nil
171171 }
172172
173 func encodeResponse(w http.ResponseWriter, response interface{}) error {
173 func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
174174 if e, ok := response.(errorer); ok && e.error() != nil {
175 encodeError(w, e.error())
175 encodeError(ctx, e.error(), w)
176176 return nil
177177 }
178178 w.Header().Set("Content-Type", "application/json; charset=utf-8")
184184 }
185185
186186 // encode errors from business-logic
187 func encodeError(w http.ResponseWriter, err error) {
187 func encodeError(_ context.Context, err error, w http.ResponseWriter) {
188188 switch err {
189189 case cargo.ErrUnknown:
190190 w.WriteHeader(http.StatusNotFound)
3636 return r
3737 }
3838
39 func decodeRegisterIncidentRequest(r *http.Request) (interface{}, error) {
39 func decodeRegisterIncidentRequest(_ context.Context, r *http.Request) (interface{}, error) {
4040 var body struct {
4141 CompletionTime time.Time `json:"completion_time"`
4242 TrackingID string `json:"tracking_id"`
6969 return types[s]
7070 }
7171
72 func encodeResponse(w http.ResponseWriter, response interface{}) error {
72 func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
7373 if e, ok := response.(errorer); ok && e.error() != nil {
74 encodeError(w, e.error())
74 encodeError(ctx, e.error(), w)
7575 return nil
7676 }
7777 w.Header().Set("Content-Type", "application/json; charset=utf-8")
8383 }
8484
8585 // encode errors from business-logic
86 func encodeError(w http.ResponseWriter, err error) {
86 func encodeError(_ context.Context, err error, w http.ResponseWriter) {
8787 switch err {
8888 case cargo.ErrUnknown:
8989 w.WriteHeader(http.StatusNotFound)
9696 ).Endpoint()
9797 }
9898
99 func decodeFetchRoutesResponse(resp *http.Response) (interface{}, error) {
99 func decodeFetchRoutesResponse(_ context.Context, resp *http.Response) (interface{}, error) {
100100 var response fetchRoutesResponse
101101 if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
102102 return nil, err
104104 return response, nil
105105 }
106106
107 func encodeFetchRoutesRequest(r *http.Request, request interface{}) error {
107 func encodeFetchRoutesRequest(_ context.Context, r *http.Request, request interface{}) error {
108108 req := request.(fetchRoutesRequest)
109109
110110 vals := r.URL.Query()
3434 return r
3535 }
3636
37 func decodeTrackCargoRequest(r *http.Request) (interface{}, error) {
37 func decodeTrackCargoRequest(_ context.Context, r *http.Request) (interface{}, error) {
3838 vars := mux.Vars(r)
3939 id, ok := vars["id"]
4040 if !ok {
4343 return trackCargoRequest{ID: id}, nil
4444 }
4545
46 func encodeResponse(w http.ResponseWriter, response interface{}) error {
46 func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
4747 if e, ok := response.(errorer); ok && e.error() != nil {
48 encodeError(w, e.error())
48 encodeError(ctx, e.error(), w)
4949 return nil
5050 }
5151 w.Header().Set("Content-Type", "application/json; charset=utf-8")
5757 }
5858
5959 // encode errors from business-logic
60 func encodeError(w http.ResponseWriter, err error) {
60 func encodeError(_ context.Context, err error, w http.ResponseWriter) {
6161 switch err {
6262 case cargo.ErrUnknown:
6363 w.WriteHeader(http.StatusNotFound)
7373 }
7474 }
7575
76 func decodeUppercaseRequest(r *http.Request) (interface{}, error) {
76 func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) {
7777 var request uppercaseRequest
7878 if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
7979 return nil, err
8181 return request, nil
8282 }
8383
84 func decodeCountRequest(r *http.Request) (interface{}, error) {
84 func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) {
8585 var request countRequest
8686 if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
8787 return nil, err
8989 return request, nil
9090 }
9191
92 func encodeResponse(w http.ResponseWriter, response interface{}) error {
92 func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
9393 return json.NewEncoder(w).Encode(response)
9494 }
9595
2727 }
2828 }
2929
30 func decodeUppercaseRequest(r *http.Request) (interface{}, error) {
30 func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) {
3131 var request uppercaseRequest
3232 if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
3333 return nil, err
3535 return request, nil
3636 }
3737
38 func decodeCountRequest(r *http.Request) (interface{}, error) {
38 func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) {
3939 var request countRequest
4040 if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
4141 return nil, err
4343 return request, nil
4444 }
4545
46 func encodeResponse(w http.ResponseWriter, response interface{}) error {
46 func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
4747 return json.NewEncoder(w).Encode(response)
4848 }
4949
2929 }
3030 }
3131
32 func decodeUppercaseRequest(r *http.Request) (interface{}, error) {
32 func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) {
3333 var request uppercaseRequest
3434 if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
3535 return nil, err
3737 return request, nil
3838 }
3939
40 func decodeCountRequest(r *http.Request) (interface{}, error) {
40 func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) {
4141 var request countRequest
4242 if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
4343 return nil, err
4545 return request, nil
4646 }
4747
48 func decodeUppercaseResponse(r *http.Response) (interface{}, error) {
48 func decodeUppercaseResponse(_ context.Context, r *http.Response) (interface{}, error) {
4949 var response uppercaseResponse
5050 if err := json.NewDecoder(r.Body).Decode(&response); err != nil {
5151 return nil, err
5353 return response, nil
5454 }
5555
56 func encodeResponse(w http.ResponseWriter, response interface{}) error {
56 func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
5757 return json.NewEncoder(w).Encode(response)
5858 }
5959
60 func encodeRequest(r *http.Request, request interface{}) error {
60 func encodeRequest(_ context.Context, r *http.Request, request interface{}) error {
6161 var buf bytes.Buffer
6262 if err := json.NewEncoder(&buf).Encode(request); err != nil {
6363 return err
7373
7474 req, err := http.NewRequest(c.method, c.tgt.String(), nil)
7575 if err != nil {
76 return nil, TransportError{DomainNewRequest, err}
76 return nil, TransportError{Domain: DomainNewRequest, Err: err}
7777 }
7878
79 if err = c.enc(req, request); err != nil {
80 return nil, TransportError{DomainEncode, err}
79 if err = c.enc(ctx, req, request); err != nil {
80 return nil, TransportError{Domain: DomainEncode, Err: err}
8181 }
8282
8383 for _, f := range c.before {
8686
8787 resp, err := ctxhttp.Do(ctx, c.client, req)
8888 if err != nil {
89 return nil, TransportError{DomainDo, err}
89 return nil, TransportError{Domain: DomainDo, Err: err}
9090 }
9191 if !c.bufferedStream {
9292 defer resp.Body.Close()
9393 }
9494
95 response, err := c.dec(resp)
95 response, err := c.dec(ctx, resp)
9696 if err != nil {
97 return nil, TransportError{DomainDecode, err}
97 return nil, TransportError{Domain: DomainDecode, Err: err}
9898 }
9999
100100 return response, nil
2020 func TestHTTPClient(t *testing.T) {
2121 var (
2222 testbody = "testbody"
23 encode = func(*http.Request, interface{}) error { return nil }
24 decode = func(r *http.Response) (interface{}, error) {
23 encode = func(context.Context, *http.Request, interface{}) error { return nil }
24 decode = func(_ context.Context, r *http.Response) (interface{}, error) {
2525 buffer := make([]byte, len(testbody))
2626 r.Body.Read(buffer)
2727 return TestResponse{r.Body, string(buffer)}, nil
8484 func TestHTTPClientBufferedStream(t *testing.T) {
8585 var (
8686 testbody = "testbody"
87 encode = func(*http.Request, interface{}) error { return nil }
88 decode = func(r *http.Response) (interface{}, error) {
87 encode = func(context.Context, *http.Request, interface{}) error { return nil }
88 decode = func(_ context.Context, r *http.Response) (interface{}, error) {
8989 return TestResponse{r.Body, ""}, nil
9090 }
9191 )
00 package http
11
2 import "net/http"
2 import (
3 "net/http"
4
5 "golang.org/x/net/context"
6 )
37
48 // DecodeRequestFunc extracts a user-domain request object from an HTTP
59 // request object. It's designed to be used in HTTP servers, for server-side
610 // endpoints. One straightforward DecodeRequestFunc could be something that
711 // JSON decodes from the request body to the concrete response type.
8 type DecodeRequestFunc func(*http.Request) (request interface{}, err error)
12 type DecodeRequestFunc func(context.Context, *http.Request) (request interface{}, err error)
913
1014 // EncodeRequestFunc encodes the passed request object into the HTTP request
1115 // object. It's designed to be used in HTTP clients, for client-side
1216 // endpoints. One straightforward EncodeRequestFunc could something that JSON
1317 // encodes the object directly to the request body.
14 type EncodeRequestFunc func(*http.Request, interface{}) error
18 type EncodeRequestFunc func(context.Context, *http.Request, interface{}) error
1519
1620 // EncodeResponseFunc encodes the passed response object to the HTTP response
1721 // writer. It's designed to be used in HTTP servers, for server-side
1822 // endpoints. One straightforward EncodeResponseFunc could be something that
1923 // JSON encodes the object directly to the response body.
20 type EncodeResponseFunc func(http.ResponseWriter, interface{}) error
24 type EncodeResponseFunc func(context.Context, http.ResponseWriter, interface{}) error
2125
2226 // DecodeResponseFunc extracts a user-domain response object from an HTTP
2327 // response object. It's designed to be used in HTTP clients, for client-side
2428 // endpoints. One straightforward DecodeResponseFunc could be something that
2529 // JSON decodes from the response body to the concrete response type.
26 type DecodeResponseFunc func(*http.Response) (response interface{}, err error)
30 type DecodeResponseFunc func(context.Context, *http.Response) (response interface{}, err error)
1414 func TestClientEndpointEncodeError(t *testing.T) {
1515 var (
1616 sampleErr = errors.New("Oh no, an error")
17 enc = func(r *http.Request, request interface{}) error { return sampleErr }
18 dec = func(r *http.Response) (response interface{}, err error) { return nil, nil }
17 enc = func(context.Context, *http.Request, interface{}) error { return sampleErr }
18 dec = func(context.Context, *http.Response) (interface{}, error) { return nil, nil }
1919 )
2020
2121 u := &url.URL{
8282 ctx = f(ctx, r)
8383 }
8484
85 request, err := s.dec(r)
85 request, err := s.dec(ctx, r)
8686 if err != nil {
8787 s.logger.Log("err", err)
8888 s.errorEncoder(ctx, TransportError{Domain: DomainDecode, Err: err}, w)
100100 f(ctx, w)
101101 }
102102
103 if err := s.enc(w, response); err != nil {
103 if err := s.enc(ctx, w, response); err != nil {
104104 s.logger.Log("err", err)
105105 s.errorEncoder(ctx, TransportError{Domain: DomainEncode, Err: err}, w)
106106 return
1515 handler := httptransport.NewServer(
1616 context.Background(),
1717 func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil },
18 func(*http.Request) (interface{}, error) { return struct{}{}, errors.New("dang") },
19 func(http.ResponseWriter, interface{}) error { return nil },
18 func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, errors.New("dang") },
19 func(context.Context, http.ResponseWriter, interface{}) error { return nil },
2020 )
2121 server := httptest.NewServer(handler)
2222 defer server.Close()
3030 handler := httptransport.NewServer(
3131 context.Background(),
3232 func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errors.New("dang") },
33 func(*http.Request) (interface{}, error) { return struct{}{}, nil },
34 func(http.ResponseWriter, interface{}) error { return nil },
33 func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
34 func(context.Context, http.ResponseWriter, interface{}) error { return nil },
3535 )
3636 server := httptest.NewServer(handler)
3737 defer server.Close()
4545 handler := httptransport.NewServer(
4646 context.Background(),
4747 func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil },
48 func(*http.Request) (interface{}, error) { return struct{}{}, nil },
49 func(http.ResponseWriter, interface{}) error { return errors.New("dang") },
48 func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
49 func(context.Context, http.ResponseWriter, interface{}) error { return errors.New("dang") },
5050 )
5151 server := httptest.NewServer(handler)
5252 defer server.Close()
6767 handler := httptransport.NewServer(
6868 context.Background(),
6969 func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errTeapot },
70 func(*http.Request) (interface{}, error) { return struct{}{}, nil },
71 func(http.ResponseWriter, interface{}) error { return nil },
70 func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
71 func(context.Context, http.ResponseWriter, interface{}) error { return nil },
7272 httptransport.ServerErrorEncoder(func(_ context.Context, err error, w http.ResponseWriter) { w.WriteHeader(code(err)) }),
7373 )
7474 server := httptest.NewServer(handler)
9999 handler = httptransport.NewServer(
100100 ctx,
101101 endpoint,
102 func(*http.Request) (interface{}, error) { return struct{}{}, nil },
103 func(http.ResponseWriter, interface{}) error { return nil },
102 func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
103 func(context.Context, http.ResponseWriter, interface{}) error { return nil },
104104 httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { return ctx }),
105105 httptransport.ServerAfter(func(ctx context.Context, w http.ResponseWriter) { return }),
106106 )