src/net/http/roundtrip_js.go

   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         "os"
  15         "strconv"
  16         "strings"
  17         "syscall/js"
  18 )
  19
  20 // RoundTrip implements the RoundTripper interface using the WHATWG Fetch API.
  21 func (t *Transport) RoundTrip(req *Request) (*Response, error) {
  22         if useFakeNetwork() {
  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")
  33         if ac != js.Undefined() {
  34                 // Some browsers that support WASM don't necessarily support
  35                 // the AbortController. See
  36                 // https://developer.mozilla.org/en-US/docs/Web/API/AbortController#Browser_compatibility.
  37                 ac = ac.New()
  38         }
  39
  40         opt := js.Global().Get("Object").New()
  41         // See https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch
  42         // for options available.
  43         opt.Set("headers", headers)
  44         opt.Set("method", req.Method)
  45         opt.Set("credentials", "same-origin")
  46         if ac != js.Undefined() {
  47                 opt.Set("signal", ac.Get("signal"))
  48         }
  49
  50         if req.Body != nil {
  51                 // TODO(johanbrandhorst): Stream request body when possible.
  52                 // See https://bugs.chromium.org/p/chromium/issues/detail?id=688906 for Blink issue.
  53                 // See https://bugzilla.mozilla.org/show_bug.cgi?id=1387483 for Firefox issue.
  54                 // See https://github.com/web-platform-tests/wpt/issues/7693 for WHATWG tests issue.
  55                 // See https://developer.mozilla.org/en-US/docs/Web/API/Streams_API for more details on the Streams API
  56                 // and browser support.
  57                 body, err := ioutil.ReadAll(req.Body)
  58                 if err != nil {
  59                         req.Body.Close() // RoundTrip must always close the body, including on errors.
  60                         return nil, err
  61                 }
  62                 req.Body.Close()
  63                 opt.Set("body", body)
  64         }
  65         respPromise := js.Global().Call("fetch", req.URL.String(), opt)
  66         var (
  67                 respCh = make(chan *Response, 1)
  68                 errCh  = make(chan error, 1)
  69         )
  70         success := js.NewCallback(func(args []js.Value) {
  71                 result := args[0]
  72                 header := Header{}
  73                 // https://developer.mozilla.org/en-US/docs/Web/API/Headers/entries
  74                 headersIt := result.Get("headers").Call("entries")
  75                 for {
  76                         n := headersIt.Call("next")
  77                         if n.Get("done").Bool() {
  78                                 break
  79                         }
  80                         pair := n.Get("value")
  81                         key, value := pair.Index(0).String(), pair.Index(1).String()
  82                         ck := CanonicalHeaderKey(key)
  83                         header[ck] = append(header[ck], value)
  84                 }
  85
  86                 contentLength := int64(0)
  87                 if cl, err := strconv.ParseInt(header.Get("Content-Length"), 10, 64); err == nil {
  88                         contentLength = cl
  89                 }
  90
  91                 b := result.Get("body")
  92                 var body io.ReadCloser
  93                 if b != js.Undefined() {
  94                         body = &streamReader{stream: b.Call("getReader")}
  95                 } else {
  96                         // Fall back to using ArrayBuffer
  97                         // https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer
  98                         body = &arrayReader{arrayPromise: result.Call("arrayBuffer")}
  99                 }
 100
 101                 select {
 102                 case respCh <- &Response{
 103                         Status:        result.Get("status").String() + " " + StatusText(result.Get("status").Int()),
 104                         StatusCode:    result.Get("status").Int(),
 105                         Header:        header,
 106                         ContentLength: contentLength,
 107                         Body:          body,
 108                         Request:       req,
 109                 }:
 110                 case <-req.Context().Done():
 111                 }
 112         })
 113         defer success.Release()
 114         failure := js.NewCallback(func(args []js.Value) {
 115                 err := fmt.Errorf("net/http: fetch() failed: %s", args[0].String())
 116                 select {
 117                 case errCh <- err:
 118                 case <-req.Context().Done():
 119                 }
 120         })
 121         defer failure.Release()
 122         respPromise.Call("then", success, failure)
 123         select {
 124         case <-req.Context().Done():
 125                 if ac != js.Undefined() {
 126                         // Abort the Fetch request
 127                         ac.Call("abort")
 128                 }
 129                 return nil, req.Context().Err()
 130         case resp := <-respCh:
 131                 return resp, nil
 132         case err := <-errCh:
 133                 return nil, err
 134         }
 135 }
 136
 137 var errClosed = errors.New("net/http: reader is closed")
 138
 139 // useFakeNetwork is used to determine whether the request is made
 140 // by a test and should be made to use the fake in-memory network.
 141 func useFakeNetwork() bool {
 142         return len(os.Args) > 0 && strings.HasSuffix(os.Args[0], ".test")
 143 }
 144
 145 // streamReader implements an io.ReadCloser wrapper for ReadableStream.
 146 // See https://fetch.spec.whatwg.org/#readablestream for more information.
 147 type streamReader struct {
 148         pending []byte
 149         stream  js.Value
 150         err     error // sticky read error
 151 }
 152
 153 func (r *streamReader) Read(p []byte) (n int, err error) {
 154         if r.err != nil {
 155                 return 0, r.err
 156         }
 157         if len(r.pending) == 0 {
 158                 var (
 159                         bCh   = make(chan []byte, 1)
 160                         errCh = make(chan error, 1)
 161                 )
 162                 success := js.NewCallback(func(args []js.Value) {
 163                         result := args[0]
 164                         if result.Get("done").Bool() {
 165                                 errCh <- io.EOF
 166                                 return
 167                         }
 168                         value := make([]byte, result.Get("value").Get("byteLength").Int())
 169                         a := js.TypedArrayOf(value)
 170                         a.Call("set", result.Get("value"))
 171                         a.Release()
 172                         bCh <- value
 173                 })
 174                 defer success.Release()
 175                 failure := js.NewCallback(func(args []js.Value) {
 176                         // Assumes it's a TypeError. See
 177                         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError
 178                         // for more information on this type. See
 179                         // https://streams.spec.whatwg.org/#byob-reader-read for the spec on
 180                         // the read method.
 181                         errCh <- errors.New(args[0].Get("message").String())
 182                 })
 183                 defer failure.Release()
 184                 r.stream.Call("read").Call("then", success, failure)
 185                 select {
 186                 case b := <-bCh:
 187                         r.pending = b
 188                 case err := <-errCh:
 189                         r.err = err
 190                         return 0, err
 191                 }
 192         }
 193         n = copy(p, r.pending)
 194         r.pending = r.pending[n:]
 195         return n, nil
 196 }
 197
 198 func (r *streamReader) Close() error {
 199         // This ignores any error returned from cancel method. So far, I did not encounter any concrete
 200         // situation where reporting the error is meaningful. Most users ignore error from resp.Body.Close().
 201         // If there's a need to report error here, it can be implemented and tested when that need comes up.
 202         r.stream.Call("cancel")
 203         if r.err == nil {
 204                 r.err = errClosed
 205         }
 206         return nil
 207 }
 208
 209 // arrayReader implements an io.ReadCloser wrapper for ArrayBuffer.
 210 // https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer.
 211 type arrayReader struct {
 212         arrayPromise js.Value
 213         pending      []byte
 214         read         bool
 215         err          error // sticky read error
 216 }
 217
 218 func (r *arrayReader) Read(p []byte) (n int, err error) {
 219         if r.err != nil {
 220                 return 0, r.err
 221         }
 222         if !r.read {
 223                 r.read = true
 224                 var (
 225                         bCh   = make(chan []byte, 1)
 226                         errCh = make(chan error, 1)
 227                 )
 228                 success := js.NewCallback(func(args []js.Value) {
 229                         // Wrap the input ArrayBuffer with a Uint8Array
 230                         uint8arrayWrapper := js.Global().Get("Uint8Array").New(args[0])
 231                         value := make([]byte, uint8arrayWrapper.Get("byteLength").Int())
 232                         a := js.TypedArrayOf(value)
 233                         a.Call("set", uint8arrayWrapper)
 234                         a.Release()
 235                         bCh <- value
 236                 })
 237                 defer success.Release()
 238                 failure := js.NewCallback(func(args []js.Value) {
 239                         // Assumes it's a TypeError. See
 240                         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError
 241                         // for more information on this type.
 242                         // See https://fetch.spec.whatwg.org/#concept-body-consume-body for reasons this might error.
 243                         errCh <- errors.New(args[0].Get("message").String())
 244                 })
 245                 defer failure.Release()
 246                 r.arrayPromise.Call("then", success, failure)
 247                 select {
 248                 case b := <-bCh:
 249                         r.pending = b
 250                 case err := <-errCh:
 251                         return 0, err
 252                 }
 253         }
 254         if len(r.pending) == 0 {
 255                 return 0, io.EOF
 256         }
 257         n = copy(p, r.pending)
 258         r.pending = r.pending[n:]
 259         return n, nil
 260 }
 261
 262 func (r *arrayReader) Close() error {
 263         if r.err == nil {
 264                 r.err = errClosed
 265         }
 266         return nil
 267 }