refine task assertions, add test for task timeout (#894)

Author: Guy Bedford

integration-tests/js-compute/fixtures/app/src/timers.js

@@ -342,6 +342,30 @@ import { routes } from "./routes.js";
             }
         }))
     });
+    routes.set('/setTimeout/fetch-timeout', async () => {
+        let timedOut = false
+        const first = fetch('https://httpbin.org/delay/1', {
+            backend: 'httpbin'
+        })
+        const second = Promise.race([
+            fetch('https://httpbin.org/delay/1', {
+                backend: 'httpbin'
+            }),
+            new Promise(resolve => setTimeout(resolve, 5)).then(() => {
+                timedOut = true
+                return { status: 504, errors: 'timeout' }
+            })
+        ])
+        const firstValue = await first
+        let error = assert(timedOut, true, 'should have timed out')
+        if (error) { return error }
+        error = assert(firstValue.status, 200, 'should get first value')
+        if (error) { return error }
+        const secondValue = await second
+        error = assert(secondValue.status, 504, 'should get second value timeout')
+        if (error) { return error }
+        return pass()
+    });
 }
 
 // clearInterval

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

@@ -4866,6 +4866,16 @@
       "body": ["START\nEND\n"]
     }
   },
+  "GET /setTimeout/fetch-timeout": {
+    "environments": ["viceroy", "compute"],
+    "downstream_request": {
+      "method": "GET",
+      "pathname": "/setTimeout/fetch-timeout"
+    },
+    "downstream_response": {
+      "status": 200
+    }
+  },
   "GET /clearInterval/exposed-as-global": {
     "environments": ["viceroy", "compute"],
     "downstream_request": {

runtime/fastly/host-api/host_api.cpp

@@ -118,7 +118,7 @@ size_t api::AsyncTask::select(std::vector<api::AsyncTask *> &tasks) {
 
   // When there are no async tasks, sleep until the deadline
   if (handles.size() == 0) {
-    MOZ_ASSERT(soonest_deadline > 0);
+    MOZ_ASSERT(soonest_deadline > now);
     sleep_until(soonest_deadline, now);
     return soonest_deadline_idx;
   }
@@ -127,13 +127,17 @@ size_t api::AsyncTask::select(std::vector<api::AsyncTask *> &tasks) {
   fastly::fastly_host_error err = 0;
 
   while (true) {
-    if (!convert_result(fastly::async_select(handles.data(), handles.size(),
-                                             (soonest_deadline - now) / MILLISECS_IN_NANOSECS,
-                                             &ret),
+    MOZ_ASSERT(soonest_deadline == 0 || soonest_deadline > now);
+    // timeout value of 0 means no timeout for async_select
+    uint32_t timeout = soonest_deadline > 0 ? (soonest_deadline - now) / MILLISECS_IN_NANOSECS : 0;
+    if (!convert_result(fastly::async_select(handles.data(), handles.size(), timeout, &ret),
                         &err)) {
-      if (host_api::error_is_optional_none(err)) {
-        abort();
+      if (host_api::error_is_bad_handle(err)) {
+        fprintf(stderr, "Critical Error: An invalid handle was provided to async_select.\n");
+      } else {
+        fprintf(stderr, "Critical Error: An unknown error occurred in async_select.\n");
       }
+      abort();
     }
 
     // The result is only valid if the timeout didn't expire.
@@ -151,17 +155,19 @@ size_t api::AsyncTask::select(std::vector<api::AsyncTask *> &tasks) {
         }
       }
       abort();
-    } else {
-      // No value case means a timeout, which means soonest_deadline_idx is set.
-      MOZ_ASSERT(soonest_deadline > 0);
+    } else if (soonest_deadline > 0) {
+      MOZ_ASSERT(soonest_deadline > now);
       MOZ_ASSERT(soonest_deadline_idx != -1);
       // Verify that the task definitely is ready from a time perspective, and if not loop the host
       // call again.
       now = MonotonicClock::now();
       if (soonest_deadline > now) {
+        err = 0;
         continue;
       }
       return soonest_deadline_idx;
+    } else {
+      abort();
     }
   }
 }