Reject promises for requests that fail

Author: elliottt

c-dependencies/js-compute-runtime/js-compute-builtins.cpp

@@ -65,6 +65,10 @@ bool isWizening() { return execution_mode == Mode::PreWizening; }
 
 void markWizeningAsFinished() { execution_mode = Mode::PostWizening; }
 
+namespace Request {
+JSObject *response_promise(JSObject *obj);
+}
+
 typedef bool InternalMethod(JSContext *cx, HandleObject receiver, HandleValue extra, CallArgs args);
 template <InternalMethod fun> bool internal_method(JSContext *cx, unsigned argc, Value *vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
@@ -1377,6 +1381,22 @@ bool body_reader_then_handler(JSContext *cx, HandleObject body_owner, HandleValu
     fprintf(stderr, "Error: read operation on body ReadableStream didn't respond with a "
                     "Uint8Array. Received value: ");
     dump_value(cx, val, stderr);
+
+    // reject the request promise
+    if (Request::is_instance(body_owner)) {
+      RootedObject response_promise(cx, Request::response_promise(body_owner));
+      RootedValue exn(cx);
+
+      // TODO: this should be a TypeError, but I'm not sure how to make that work
+      JS_ReportErrorUTF8(cx, "TypeError");
+      if (!JS_GetPendingException(cx, &exn)) {
+        return false;
+      }
+      JS_ClearPendingException(cx);
+
+      return JS::RejectPromise(cx, response_promise, exn);
+    }
+
     return false;
   }
 

integration-tests/js-compute/fixtures/tee/tee.ts

@@ -1,20 +1,46 @@
 addEventListener("fetch", event => event.respondWith(handleRequest(event.request)));
 
 async function handleRequest(req: Request) {
-  let [body1, _body2] = req.body.tee();
 
-  // Regression test for making requests whose bodies are streams that result
-  // from a `tee`. The bug this is guarding against is where we were eagerly
-  // placing the request into the pending queue, even though its body stream had
-  // not been closed yet. This resulted in deadlock when we called
-  // `pending_req_select`, as we were waiting on an http request whose body had
-  // not been closed.
-  let res = fetch(new Request(req.url, {
-    body: body1,
-    headers: req.headers,
-    method: req.method,
-    backend: "TheOrigin"
-  }));
+  if (req.url.endsWith("/tee")) {
+    let [body1, _body2] = req.body.tee();
 
-  return res;
+    // Regression test for making requests whose bodies are streams that result
+    // from a `tee`. The bug this is guarding against is where we were eagerly
+    // placing the request into the pending queue, even though its body stream had
+    // not been closed yet. This resulted in deadlock when we called
+    // `pending_req_select`, as we were waiting on an http request whose body had
+    // not been closed.
+    let res = fetch(new Request(req.url, {
+      body: body1,
+      headers: req.headers,
+      method: req.method,
+      backend: "TheOrigin"
+    }));
+
+    return res;
+  }
+
+  if (req.url.endsWith("/error")) {
+    console.log(req.method);
+    let res = fetch(req.url, {
+      method: "POST",
+      body: new ReadableStream({
+        start: controller => {
+          controller.enqueue("Test");
+          controller.close();
+        }
+      }),
+      backend: "TheOrigin",
+    });
+
+    return res
+      .then(_ => new Response("Error wasn't raised"))
+      .catch(err => {
+        console.log(err.toString());
+        return new Response(err.toString());
+      });
+  }
+
+  return new Response("");
 }

integration-tests/js-compute/fixtures/tee/tests.json

@@ -13,5 +13,20 @@
       "status": 200,
       "body": "hello world!"
     }
+  },
+
+  "GET /error": {
+    "environments": ["viceroy", "c@e"],
+    "downstream_request": {
+      "method": "GET",
+      "pathname": "/error",
+      "headers": {
+          "Content-Type": "application/json"
+      }
+    },
+    "downstream_response": {
+      "status": 200,
+      "body": "Error: TypeError"
+    }
   }
 }