fix(base): triggering beforeunload event may cause Uncaught null (#520)

* fix(base): triggering `beforeunload` event may cause `Uncaught null`

* chore: add an integration test

Author: nyannyacha

crates/base/src/deno_runtime.rs

@@ -1328,10 +1328,12 @@ where
                     if accumulated_cpu_time_ns >= threshold_ns {
                         beforeunload_cpu_threshold.store(None);
 
-                        if let Err(err) = MaybeDenoRuntime::DenoRuntime(&mut this)
-                            .dispatch_beforeunload_event(WillTerminateReason::CPU)
-                        {
-                            return Poll::Ready(Err(err));
+                        if !state.is_terminated() {
+                            if let Err(err) = MaybeDenoRuntime::DenoRuntime(&mut this)
+                                .dispatch_beforeunload_event(WillTerminateReason::CPU)
+                            {
+                                return Poll::Ready(Err(err));
+                            }
                         }
                     }
                 }
@@ -1351,7 +1353,7 @@ where
                     if total_malloced_bytes >= threshold_bytes {
                         beforeunload_mem_threshold.store(None);
 
-                        if !mem_state.is_exceeded() {
+                        if !state.is_terminated() && !mem_state.is_exceeded() {
                             if let Err(err) = MaybeDenoRuntime::DenoRuntime(&mut this)
                                 .dispatch_beforeunload_event(WillTerminateReason::Memory)
                             {

crates/base/src/worker/supervisor/strategy_per_worker.rs

@@ -210,13 +210,17 @@ pub async fn supervise(args: Arguments) -> (ShutdownReason, i64) {
     });
 
     let terminate_fn = {
+        let state = state.runtime.clone();
         let thread_safe_handle = thread_safe_handle.clone();
         move |should_terminate: bool| {
             let data_ptr_mut = Box::into_raw(Box::new(V8HandleTerminationData {
                 should_terminate,
                 isolate_memory_usage_tx: Some(isolate_memory_usage_tx),
             }));
 
+            if should_terminate {
+                state.terminated.raise();
+            }
             if !thread_safe_handle
                 .request_interrupt(v8_handle_termination, data_ptr_mut as *mut std::ffi::c_void)
             {

crates/base/test_cases/issue-func-205/index.ts

@@ -0,0 +1,24 @@
+import { FFmpeg } from 'npm:@ffmpeg.wasm/main';
+import { default as core, type FFmpegCoreConstructor } from 'npm:@ffmpeg.wasm/core-st';
+
+const ff = await FFmpeg.create({
+    core: core as FFmpegCoreConstructor,
+});
+
+Deno.serve(async (_req) => {
+    const resp = await fetch(
+        'https://raw.githubusercontent.com/ffmpegwasm/testdata/master/Big_Buck_Bunny_180_10s.webm',
+    );
+    const buf = new Uint8Array(await resp.arrayBuffer());
+
+    ff.fs.writeFile('meow.webm', buf);
+
+    await ff.run('-i', 'meow.webm', 'meow.mp4');
+    const data = ff.fs.readFile('meow.mp4');
+
+    return new Response(data, {
+        headers: {
+            'content-type': 'video/mp4',
+        },
+    });
+});

crates/base/test_cases/main/index.ts

@@ -18,31 +18,44 @@ Deno.serve((req: Request) => {
   console.log(req.url);
   const url = new URL(req.url);
   const { pathname } = url;
-  const path_parts = pathname.split("/");
+  const path_parts = pathname.split('/');
   const service_name = path_parts[1];
 
-  if (!service_name || service_name === "") {
-    const error = { msg: "missing function name in request" }
+  if (!service_name || service_name === '') {
+    const error = { msg: 'missing function name in request' };
     return new Response(
       JSON.stringify(error),
-      { status: 400, headers: { "Content-Type": "application/json" } },
-    )
+      { status: 400, headers: { 'Content-Type': 'application/json' } },
+    );
   }
 
   const servicePath = `./test_cases/${service_name}`;
   console.error(`serving the request with ${servicePath}`);
 
   const createWorker = async () => {
-    const memoryLimitMb = parseIntFromHeadersOrDefault(req, "x-memory-limit-mb", 150);
-    const workerTimeoutMs = parseIntFromHeadersOrDefault(req, "x-worker-timeout-ms", 10 * 60 * 1000);
-    const cpuTimeSoftLimitMs = parseIntFromHeadersOrDefault(req, "x-cpu-time-soft-limit-ms", 10 * 60 * 1000);
-    const cpuTimeHardLimitMs = parseIntFromHeadersOrDefault(req, "x-cpu-time-hard-limit-ms", 10 * 60 * 1000);
+    const memoryLimitMb = parseIntFromHeadersOrDefault(req, 'x-memory-limit-mb', 150);
+    const workerTimeoutMs = parseIntFromHeadersOrDefault(
+      req,
+      'x-worker-timeout-ms',
+      10 * 60 * 1000,
+    );
+    const cpuTimeSoftLimitMs = parseIntFromHeadersOrDefault(
+      req,
+      'x-cpu-time-soft-limit-ms',
+      10 * 60 * 1000,
+    );
+    const cpuTimeHardLimitMs = parseIntFromHeadersOrDefault(
+      req,
+      'x-cpu-time-hard-limit-ms',
+      10 * 60 * 1000,
+    );
     const noModuleCache = false;
     const importMapPath = null;
     const envVarsObj = Deno.env.toObject();
-    const envVars = Object.keys(envVarsObj).map(k => [k, envVarsObj[k]]);
+    const envVars = Object.keys(envVarsObj).map((k) => [k, envVarsObj[k]]);
     const context = {
-      sourceMap: req.headers.get("x-context-source-map") == "true"
+      sourceMap: req.headers.get('x-context-source-map') == 'true',
+      useReadSyncFileAPI: req.headers.get('x-use-read-sync-file-api') == 'true',
     };
 
     return await EdgeRuntime.userWorkers.create({
@@ -54,9 +67,9 @@ Deno.serve((req: Request) => {
       noModuleCache,
       importMapPath,
       envVars,
-      context
+      context,
     });
-  }
+  };
 
   const callWorker = async () => {
     try {
@@ -69,13 +82,13 @@ Deno.serve((req: Request) => {
       // 	return await callWorker();
       // }
 
-      const error = { msg: e.toString() }
+      const error = { msg: e.toString() };
       return new Response(
         JSON.stringify(error),
-        { status: 500, headers: { "Content-Type": "application/json" } },
+        { status: 500, headers: { 'Content-Type': 'application/json' } },
       );
     }
-  }
+  };
 
   return callWorker();
-})
+});

crates/base/tests/integration_tests.rs

@@ -6,7 +6,7 @@ use graph::{emitter::EmitterFactory, generate_binary_eszip, EszipPayloadKind};
 use http_v02::{self as http, HeaderValue};
 use hyper_v014 as hyper;
 use reqwest_v011 as reqwest;
-use sb_event_worker::events::{LogLevel, WorkerEvents};
+use sb_event_worker::events::{LogLevel, ShutdownReason, WorkerEvents};
 use url::Url;
 
 use std::{
@@ -2384,6 +2384,49 @@ async fn test_issue_456() {
     tb.exit(Duration::from_secs(TESTBED_DEADLINE_SEC)).await;
 }
 
+#[tokio::test]
+#[serial]
+async fn test_issue_func_205() {
+    let (tx, mut rx) = mpsc::unbounded_channel();
+    let tb = TestBedBuilder::new("./test_cases/main")
+        .with_per_worker_policy(None)
+        .with_worker_event_sender(Some(tx))
+        .with_server_flags(ServerFlags {
+            beforeunload_wall_clock_pct: Some(90),
+            beforeunload_cpu_pct: Some(90),
+            beforeunload_memory_pct: Some(90),
+            ..Default::default()
+        })
+        .build()
+        .await;
+
+    let resp = tb
+        .request(|b| {
+            b.uri("/issue-func-205")
+                .header("x-cpu-time-soft-limit-ms", HeaderValue::from_static("500"))
+                .header("x-cpu-time-hard-limit-ms", HeaderValue::from_static("1000"))
+                .header("x-use-read-sync-file-api", HeaderValue::from_static("true"))
+                .body(Body::empty())
+                .context("can't make request")
+        })
+        .await
+        .unwrap();
+
+    assert_eq!(resp.status().as_u16(), StatusCode::INTERNAL_SERVER_ERROR);
+
+    tb.exit(Duration::from_secs(TESTBED_DEADLINE_SEC)).await;
+
+    while let Some(ev) = rx.recv().await {
+        let WorkerEvents::Shutdown(ev) = ev.event else {
+            continue;
+        };
+        assert_eq!(ev.reason, ShutdownReason::CPUTime);
+        return;
+    }
+
+    unreachable!("test failed");
+}
+
 #[tokio::test]
 #[serial]
 async fn test_should_render_detailed_failed_to_create_graph_error() {

ext/event_worker/events.rs

@@ -20,7 +20,7 @@ pub struct WorkerMemoryUsed {
     pub mem_check_captured: MemCheckState,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub enum ShutdownReason {
     EventLoopCompleted,
     WallClockTime,