fix: allow calling synchronous deno functions in the top-level context

Author: nyannyacha

crates/base/src/runtime/mod.rs

@@ -23,6 +23,7 @@ use base_rt::get_current_cpu_time_ns;
 use base_rt::BlockingScopeCPUUsage;
 use base_rt::DenoRuntimeDropToken;
 use base_rt::DropToken;
+use base_rt::RuntimeState;
 use cooked_waker::IntoWaker;
 use cooked_waker::WakeRef;
 use cpu_timer::CPUTimer;
@@ -51,7 +52,6 @@ use deno_cache::SqliteBackedCache;
 use deno_core::error::AnyError;
 use deno_core::error::JsError;
 use deno_core::serde_json;
-use deno_core::unsync::sync::AtomicFlag;
 use deno_core::url::Url;
 use deno_core::v8;
 use deno_core::v8::GCCallbackFlags;
@@ -298,33 +298,6 @@ pub enum WillTerminateReason {
   Termination,
 }
 
-#[derive(Debug, Clone, Default)]
-pub struct RuntimeState {
-  pub evaluating_mod: Arc<AtomicFlag>,
-  pub event_loop_completed: Arc<AtomicFlag>,
-  pub terminated: Arc<AtomicFlag>,
-  pub found_inspector_session: Arc<AtomicFlag>,
-  pub mem_reached_half: Arc<AtomicFlag>,
-}
-
-impl RuntimeState {
-  pub fn is_evaluating_mod(&self) -> bool {
-    self.evaluating_mod.is_raised()
-  }
-
-  pub fn is_event_loop_completed(&self) -> bool {
-    self.event_loop_completed.is_raised()
-  }
-
-  pub fn is_terminated(&self) -> bool {
-    self.terminated.is_raised()
-  }
-
-  pub fn is_found_inspector_session(&self) -> bool {
-    self.found_inspector_session.is_raised()
-  }
-}
-
 #[derive(Debug)]
 pub struct RunOptions {
   wait_termination_request_token: bool,
@@ -1312,7 +1285,11 @@ where
 
       spawn_blocking_non_send(|| {
         let _wall = deno_core::unsync::set_wall().drop_guard();
+        let init = scopeguard::guard(self.runtime_state.init.clone(), |v| {
+          v.lower();
+        });
 
+        init.raise();
         handle.block_on(
           #[allow(clippy::async_yields_async)]
           async {
@@ -3323,7 +3300,6 @@ mod test {
     impl GetRuntimeContext for Ctx {
       fn get_extra_context() -> impl Serialize {
         serde_json::json!({
-          "useReadSyncFileAPI": true,
           "shouldBootstrapMockFnThrowError": true,
         })
       }
@@ -3333,7 +3309,10 @@ mod test {
       "./test_cases/user-worker-san-check",
       None,
       None,
-      &["./test_cases/user-worker-san-check/.blocklisted"],
+      &[
+        "./test_cases/user-worker-san-check/.blocklisted",
+        "./test_cases/user-worker-san-check/.whitelisted",
+      ],
     )
     .set_context::<Ctx>()
     .build()

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

@@ -4,6 +4,7 @@ use std::time::Duration;
 
 use anyhow::anyhow;
 use base_mem_check::MemCheckState;
+use base_rt::RuntimeState;
 use cpu_timer::CPUTimer;
 use deno_core::v8;
 use deno_core::InspectorSessionKind;
@@ -31,7 +32,6 @@ use super::pool::SupervisorPolicy;
 use super::termination_token::TerminationToken;
 
 use crate::runtime::DenoRuntime;
-use crate::runtime::RuntimeState;
 use crate::server::ServerFlags;
 use crate::utils::units::percentage_value;
 

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

@@ -4,6 +4,7 @@ use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
 
+use base_rt::RuntimeState;
 use deno_core::unsync::sync::AtomicFlag;
 use ext_event_worker::events::ShutdownReason;
 use ext_runtime::PromiseMetrics;
@@ -17,7 +18,6 @@ use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
 use tracing::Instrument;
 
-use crate::runtime::RuntimeState;
 use crate::runtime::WillTerminateReason;
 use crate::worker::supervisor::create_wall_clock_beforeunload_alert;
 use crate::worker::supervisor::v8_handle_beforeunload;

crates/base/test_cases/user-worker-san-check/.blocklisted

@@ -23,18 +23,12 @@ link
 linkSync
 lstat
 lstatSync
-makeTempDirSync
 makeTempFile
 makeTempFileSync
-mkdirSync
-openSync
-readDirSync
 readLink
 readLinkSync
-removeSync
 rename
 renameSync
-statSync
 symlink
 symlinkSync
 truncate
@@ -43,13 +37,11 @@ umask
 utime
 utimeSync
 watchFs
-writeFileSync
-writeTextFileSync
 chdir
 dlopen
 cron
 run
 kill
 exit
 addSignalListener
-removeSignalListener
+removeSignalListener

crates/base/test_cases/user-worker-san-check/.whitelisted

@@ -0,0 +1,9 @@
+mkdirSync
+readDirSync
+removeSync
+statSync
+writeFileSync
+writeTextFileSync
+readTextFileSync
+readFileSync
+makeTempDirSync

crates/base/test_cases/user-worker-san-check/index.ts

@@ -1,29 +1,74 @@
-let blocklist: string[] = Deno.readTextFileSync(".blocklisted")
-  .trim()
-  .split("\n");
+function checkBlocklisted(list: string[]) {
+  for (const api of list) {
+    console.log(api);
+    if (Deno[api] === void 0) {
+      continue;
+    }
 
-for (const api of blocklist) {
-  console.log(api);
-  if (Deno[api] === void 0) {
-    continue;
-  }
+    if (typeof Deno[api] !== "function") {
+      throw new Error(`invalid api: ${api}`);
+    }
+
+    try {
+      Deno[api]();
+      throw new Error(`unreachable: ${api}`);
+    } catch (ex) {
+      if (ex instanceof Deno.errors.PermissionDenied) {
+        continue;
+      } else if (ex instanceof TypeError) {
+        if (ex.message === "called MOCK_FN") {
+          continue;
+        }
+      }
+    }
 
-  if (typeof Deno[api] !== "function") {
     throw new Error(`invalid api: ${api}`);
   }
+}
 
-  try {
-    Deno[api]();
-    throw new Error(`unreachable: ${api}`);
-  } catch (ex) {
-    if (ex instanceof Deno.errors.PermissionDenied) {
+function checkWhitelisted(list: string[]) {
+  for (const api of list) {
+    console.log(api);
+    if (Deno[api] === void 0) {
       continue;
-    } else if (ex instanceof TypeError) {
-      if (ex.message === "called MOCK_FN") {
-        continue;
+    }
+
+    if (typeof Deno[api] !== "function") {
+      throw new Error(`invalid api: ${api}`);
+    }
+
+    try {
+      Deno[api]();
+      throw new Error(`unreachable: ${api}`);
+    } catch (ex) {
+      if (ex instanceof Deno.errors.PermissionDenied) {
+        throw ex;
       }
     }
   }
-
-  throw new Error(`invalid api: ${api}`);
 }
+
+const blocklist: string[] = Deno.readTextFileSync(".blocklisted")
+  .trim()
+  .split("\n");
+const whitelisted: string[] = Deno.readTextFileSync(".whitelisted")
+  .trim()
+  .split("\n");
+
+checkBlocklisted(blocklist);
+checkWhitelisted(whitelisted);
+
+const { promise: fence, resolve, reject } = Promise.withResolvers<void>();
+
+setTimeout(() => {
+  try {
+    checkBlocklisted(whitelisted);
+    resolve();
+  } catch (ex) {
+    reject(ex);
+  }
+});
+
+await fence;
+
+export {};

crates/base_rt/src/lib.rs

@@ -18,8 +18,12 @@ use tracing::debug;
 use tracing::debug_span;
 use tracing::Instrument;
 
+mod runtime_state;
+
 pub mod error;
 
+pub use runtime_state::RuntimeState;
+
 pub const DEFAULT_PRIMARY_WORKER_POOL_SIZE: usize = 2;
 pub const DEFAULT_USER_WORKER_POOL_SIZE: usize = 1;
 

crates/base_rt/src/runtime_state.rs

@@ -0,0 +1,35 @@
+use std::sync::Arc;
+
+use deno_core::unsync::sync::AtomicFlag;
+
+#[derive(Debug, Clone, Default)]
+pub struct RuntimeState {
+  pub init: Arc<AtomicFlag>,
+  pub evaluating_mod: Arc<AtomicFlag>,
+  pub event_loop_completed: Arc<AtomicFlag>,
+  pub terminated: Arc<AtomicFlag>,
+  pub found_inspector_session: Arc<AtomicFlag>,
+  pub mem_reached_half: Arc<AtomicFlag>,
+}
+
+impl RuntimeState {
+  pub fn is_init(&self) -> bool {
+    self.init.is_raised()
+  }
+
+  pub fn is_evaluating_mod(&self) -> bool {
+    self.evaluating_mod.is_raised()
+  }
+
+  pub fn is_event_loop_completed(&self) -> bool {
+    self.event_loop_completed.is_raised()
+  }
+
+  pub fn is_terminated(&self) -> bool {
+    self.terminated.is_raised()
+  }
+
+  pub fn is_found_inspector_session(&self) -> bool {
+    self.found_inspector_session.is_raised()
+  }
+}

ext/runtime/js/bootstrap.js

@@ -399,13 +399,6 @@ const globalProperties = {
 };
 ObjectDefineProperties(globalThis, globalProperties);
 
-let bootstrapMockFnThrowError = false;
-const MOCK_FN = () => {
-  if (bootstrapMockFnThrowError) {
-    throw new TypeError("called MOCK_FN");
-  }
-};
-
 const MAKE_HARD_ERR_FN = (msg) => {
   return () => {
     throw new globalThis_.Deno.errors.PermissionDenied(msg);
@@ -491,6 +484,8 @@ function processRejectionHandled(promise, reason) {
 }
 
 globalThis.bootstrapSBEdge = (opts, ctx) => {
+  let bootstrapMockFnThrowError = false;
+
   globalThis_ = globalThis;
 
   // We should delete this after initialization,
@@ -590,8 +585,8 @@ globalThis.bootstrapSBEdge = (opts, ctx) => {
   );
   setLanguage("en");
 
-  // Find declarative fetch handler
   core.addMainModuleHandler((main) => {
+    // Find declarative fetch handler
     if (ObjectHasOwn(main, "default")) {
       registerDeclarativeServer(main.default);
     }
@@ -669,10 +664,20 @@ globalThis.bootstrapSBEdge = (opts, ctx) => {
       "makeTempDir": true,
       "readDir": true,
 
-      "kill": MOCK_FN,
-      "exit": MOCK_FN,
-      "addSignalListener": MOCK_FN,
-      "removeSignalListener": MOCK_FN,
+      "kill": "mock",
+      "exit": "mock",
+      "addSignalListener": "mock",
+      "removeSignalListener": "mock",
+
+      "statSync": "allowIfRuntimeIsInInit",
+      "removeSync": "allowIfRuntimeIsInInit",
+      "writeFileSync": "allowIfRuntimeIsInInit",
+      "writeTextFileSync": "allowIfRuntimeIsInInit",
+      "readFileSync": "allowIfRuntimeIsInInit",
+      "readTextFileSync": "allowIfRuntimeIsInInit",
+      "mkdirSync": "allowIfRuntimeIsInInit",
+      "makeTempDirSync": "allowIfRuntimeIsInInit",
+      "readDirSync": "allowIfRuntimeIsInInit",
 
       // TODO: use a non-hardcoded path
       "execPath": () => "/bin/edge-runtime",
@@ -682,6 +687,7 @@ globalThis.bootstrapSBEdge = (opts, ctx) => {
     if (ctx?.useReadSyncFileAPI) {
       apisToBeOverridden["readFileSync"] = true;
       apisToBeOverridden["readTextFileSync"] = true;
+      apisToBeOverridden["openSync"] = true;
     }
 
     const apiNames = ObjectKeys(apisToBeOverridden);
@@ -693,6 +699,31 @@ globalThis.bootstrapSBEdge = (opts, ctx) => {
         delete Deno[name];
       } else if (typeof value === "function") {
         Deno[name] = value;
+      } else if (typeof value === "string") {
+        switch (value) {
+          case "mock": {
+            Deno[name] = () => {
+              if (bootstrapMockFnThrowError) {
+                throw new TypeError("called MOCK_FN");
+              }
+            };
+            break;
+          }
+          case "allowIfRuntimeIsInInit": {
+            const originalFn = Deno[name];
+            const blocklistedFn = MAKE_HARD_ERR_FN(
+              `Deno.${name} is blocklisted on the current context`,
+            );
+            Deno[name] = (...args) => {
+              if (ops.op_is_runtime_init()) {
+                return originalFn(...args);
+              } else {
+                return blocklistedFn();
+              }
+            };
+            break;
+          }
+        }
       }
     }
   }