Skip to content

Commit 4532afa

Browse files
net/http: add js/wasm compatible DefaultTransport
Adds a new Transport type for the js/wasm target that uses the JavaScript Fetch API for sending HTTP requests. Support for streaming response bodies is used when available, falling back to reading the entire response into memory at once.
1 parent 65c365b commit 4532afa

File tree

3 files changed

+254
-5
lines changed

3 files changed

+254
-5
lines changed

src/net/http/roundtrip.go

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
// Copyright 2018 The Go Authors. All rights reserved.
2+
// Use of this source code is governed by a BSD-style
3+
// license that can be found in the LICENSE file.
4+
5+
// +build !js,wasm
6+
7+
package http
8+
9+
// RoundTrip implements the RoundTripper interface.
10+
//
11+
// For higher-level HTTP client support (such as handling of cookies
12+
// and redirects), see Get, Post, and the Client type.
13+
func (t *Transport) RoundTrip(req *Request) (*Response, error) {
14+
return t.roundTrip(req)
15+
}

src/net/http/roundtrip_js.go

Lines changed: 237 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,237 @@
1+
// Copyright 2018 The Go Authors. All rights reserved.
2+
// Use of this source code is governed by a BSD-style
3+
// license that can be found in the LICENSE file.
4+
5+
// +build js,wasm
6+
7+
package http
8+
9+
import (
10+
"errors"
11+
"fmt"
12+
"io"
13+
"io/ioutil"
14+
"strconv"
15+
"syscall/js"
16+
)
17+
18+
// RoundTrip implements the RoundTripper interface using the WHATWG Fetch API.
19+
// It supports streaming response bodies.
20+
// See https://fetch.spec.whatwg.org/ for more information on this standard.
21+
func (*Transport) RoundTrip(req *Request) (*Response, error) {
22+
if isLocal(req) {
23+
return t.roundTrip(req)
24+
}
25+
headers := js.Global.Get("Headers").New()
26+
for key, values := range req.Header {
27+
for _, value := range values {
28+
headers.Call("append", key, value)
29+
}
30+
}
31+
32+
ac := js.Global.Get("AbortController").New()
33+
34+
opt := js.Global.Get("Object").New()
35+
opt.Set("headers", headers)
36+
opt.Set("method", req.Method)
37+
opt.Set("credentials", "same-origin")
38+
opt.Set("signal", ac.Get("signal"))
39+
40+
if req.Body != nil {
41+
// TODO(johanbrandhorst): Stream request body when possible.
42+
body, err := ioutil.ReadAll(req.Body)
43+
if err != nil {
44+
req.Body.Close() // RoundTrip must always close the body, including on errors.
45+
return nil, err
46+
}
47+
req.Body.Close()
48+
opt.Set("body", body)
49+
}
50+
respPromise := js.Global.Call("fetch", req.URL.String(), opt)
51+
var (
52+
respCh = make(chan *Response, 1)
53+
errCh = make(chan error, 1)
54+
)
55+
success := js.NewCallback(func(args []js.Value) {
56+
result := args[0]
57+
header := Header{}
58+
writeHeaders := js.NewCallback(func(args []js.Value) {
59+
key, value := args[0].String(), args[1].String()
60+
ck := CanonicalHeaderKey(key)
61+
header[ck] = append(header[ck], value)
62+
})
63+
defer writeHeaders.Close()
64+
result.Get("headers").Call("forEach", writeHeaders)
65+
66+
contentLength := int64(-1)
67+
if cl, err := strconv.ParseInt(header.Get("Content-Length"), 10, 64); err == nil {
68+
contentLength = cl
69+
}
70+
71+
b := result.Get("body")
72+
var body io.ReadCloser
73+
if b != js.Undefined {
74+
body = &streamReader{stream: b.Call("getReader")}
75+
} else {
76+
// Fall back to using ArrayBuffer
77+
// https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer
78+
body = &arrayReader{arrayPromise: result.Call("arrayBuffer")}
79+
}
80+
81+
select {
82+
case respCh <- &Response{
83+
Status: result.Get("status").String() + " " + StatusText(result.Get("status").Int()),
84+
StatusCode: result.Get("status").Int(),
85+
Header: header,
86+
ContentLength: contentLength,
87+
Body: body,
88+
Request: req,
89+
}:
90+
case <-req.Context().Done():
91+
}
92+
})
93+
defer success.Close()
94+
failure := js.NewCallback(func(args []js.Value) {
95+
err := fmt.Errorf("net/http: fetch() failed: %s", args[0].String())
96+
select {
97+
case errCh <- err:
98+
case <-req.Context().Done():
99+
}
100+
})
101+
defer failure.Close()
102+
respPromise.Call("then", success, failure)
103+
select {
104+
case <-req.Context().Done():
105+
// Abort the Fetch request
106+
ac.Call("abort")
107+
return nil, req.Context().Err()
108+
case resp := <-respCh:
109+
return resp, nil
110+
case err := <-errCh:
111+
return nil, err
112+
}
113+
}
114+
115+
func isLocal(req *Request) bool {
116+
switch req.Host {
117+
case "127.0.0.1": // TODO(johanbrandhorst): Add more local hosts?
118+
return true
119+
}
120+
121+
return false
122+
}
123+
124+
// streamReader implements an io.ReadCloser wrapper for ReadableStream.
125+
// See https://fetch.spec.whatwg.org/#readablestream for more information.
126+
type streamReader struct {
127+
pending []byte
128+
stream js.Value
129+
err error // sticky read error
130+
}
131+
132+
func (r *streamReader) Read(p []byte) (n int, err error) {
133+
if r.err != nil {
134+
return 0, r.err
135+
}
136+
if len(r.pending) == 0 {
137+
var (
138+
bCh = make(chan []byte, 1)
139+
errCh = make(chan error, 1)
140+
)
141+
success := js.NewCallback(func(args []js.Value) {
142+
result := args[0]
143+
if result.Get("done").Bool() {
144+
errCh <- io.EOF
145+
return
146+
}
147+
value := make([]byte, result.Get("value").Get("byteLength").Int())
148+
js.ValueOf(value).Call("set", result.Get("value"))
149+
bCh <- value
150+
})
151+
defer success.Close()
152+
failure := js.NewCallback(func(args []js.Value) {
153+
// Assumes it's a TypeError. See
154+
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError
155+
// for more information on this type. See
156+
// https://streams.spec.whatwg.org/#byob-reader-read for the spec on
157+
// the read method.
158+
errCh <- errors.New(args[0].Get("message").String())
159+
})
160+
defer failure.Close()
161+
r.stream.Call("read").Call("then", success, failure)
162+
select {
163+
case b := <-bCh:
164+
r.pending = b
165+
case err := <-errCh:
166+
r.err = err
167+
return 0, err
168+
}
169+
}
170+
n = copy(p, r.pending)
171+
r.pending = r.pending[n:]
172+
return n, nil
173+
}
174+
175+
func (r *streamReader) Close() error {
176+
// This ignores any error returned from cancel method. So far, I did not encounter any concrete
177+
// situation where reporting the error is meaningful. Most users ignore error from resp.Body.Close().
178+
// If there's a need to report error here, it can be implemented and tested when that need comes up.
179+
r.stream.Call("cancel")
180+
return nil
181+
}
182+
183+
// arrayReader implements an io.ReadCloser wrapper for ArrayBuffer.
184+
// https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer.
185+
type arrayReader struct {
186+
arrayPromise js.Value
187+
pending []byte
188+
read bool
189+
err error // sticky read error
190+
}
191+
192+
func (r *arrayReader) Read(p []byte) (n int, err error) {
193+
if r.err != nil {
194+
return 0, r.err
195+
}
196+
if !r.read {
197+
r.read = true
198+
var (
199+
bCh = make(chan []byte, 1)
200+
errCh = make(chan error, 1)
201+
)
202+
success := js.NewCallback(func(args []js.Value) {
203+
// Wrap the input ArrayBuffer with a Uint8Array
204+
uint8arrayWrapper := js.Global.Get("Uint8Array").New(args[0])
205+
value := make([]byte, uint8arrayWrapper.Get("byteLength").Int())
206+
js.ValueOf(value).Call("set", uint8arrayWrapper)
207+
bCh <- value
208+
})
209+
defer success.Close()
210+
failure := js.NewCallback(func(args []js.Value) {
211+
// Assumes it's a TypeError. See
212+
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError
213+
// for more information on this type.
214+
// See https://fetch.spec.whatwg.org/#concept-body-consume-body for reasons this might error.
215+
errCh <- errors.New(args[0].Get("message").String())
216+
})
217+
defer failure.Close()
218+
r.arrayPromise.Call("then", success, failure)
219+
select {
220+
case b := <-bCh:
221+
r.pending = b
222+
case err := <-errCh:
223+
return 0, err
224+
}
225+
}
226+
if len(r.pending) == 0 {
227+
return 0, io.EOF
228+
}
229+
n = copy(p, r.pending)
230+
r.pending = r.pending[n:]
231+
return n, nil
232+
}
233+
234+
func (r *arrayReader) Close() error {
235+
// This is a noop
236+
return nil
237+
}

src/net/http/transport.go

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -342,11 +342,8 @@ func (tr *transportRequest) setError(err error) {
342342
tr.mu.Unlock()
343343
}
344344

345-
// RoundTrip implements the RoundTripper interface.
346-
//
347-
// For higher-level HTTP client support (such as handling of cookies
348-
// and redirects), see Get, Post, and the Client type.
349-
func (t *Transport) RoundTrip(req *Request) (*Response, error) {
345+
// roundTrip implements a RoundTripper over HTTP.
346+
func (t *Transport) roundTrip(req *Request) (*Response, error) {
350347
t.nextProtoOnce.Do(t.onceSetNextProtoDefaults)
351348
ctx := req.Context()
352349
trace := httptrace.ContextClientTrace(ctx)

0 commit comments

Comments
 (0)