Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

test(renderer): scope short script watchdog timeout

ldm0e45aad07a683
diff --git a/moli-renderer-v8/src/host/timers.rs b/moli-renderer-v8/src/host/timers.rs
index e0cbc8c41..2ea5e9c3b 100644
--- a/moli-renderer-v8/src/host/timers.rs
+++ b/moli-renderer-v8/src/host/timers.rs
@@ -209,10 +209,7 @@ impl ScheduledTimerTask {
}
const MIN_DELAY_TIMER_READY_EARLY_ALLOWANCE: Duration = Duration::from_millis(1);
-#[cfg(not(test))]
const TIMER_CALLBACK_WATCHDOG_TIMEOUT: Duration = Duration::from_secs(8);
-#[cfg(test)]
-const TIMER_CALLBACK_WATCHDOG_TIMEOUT: Duration = Duration::from_millis(500);
#[derive(Default)]
pub(crate) struct HostTimeoutScheduler {
@@ -1110,6 +1107,7 @@ fn run_window_timer_callback(
scope.thread_safe_handle(),
TIMER_CALLBACK_WATCHDOG_TIMEOUT,
);
+ let watchdog_timeout = watchdog.timeout();
let result = CallbackInvoker::invoke(
scope,
"callback",
@@ -1122,7 +1120,7 @@ fn run_window_timer_callback(
if watchdog_timed_out {
return Err(HostTimeoutRunResult::CallbackError(format!(
"timer callback exceeded {:?} and was terminated",
- TIMER_CALLBACK_WATCHDOG_TIMEOUT
+ watchdog_timeout
)));
}
match result {
@@ -1152,12 +1150,13 @@ fn run_window_timer_callback(
scope.thread_safe_handle(),
TIMER_CALLBACK_WATCHDOG_TIMEOUT,
);
+ let watchdog_timeout = watchdog.timeout();
let result = callback.invoke(scope, host_ptr, extra_args);
let watchdog_timed_out = watchdog.disarm() == V8ExecutionWatchdogOutcome::TimedOut;
if watchdog_timed_out {
return Err(HostTimeoutRunResult::CallbackError(format!(
"Window Web IDL callback exceeded {:?} and was terminated",
- TIMER_CALLBACK_WATCHDOG_TIMEOUT
+ watchdog_timeout
)));
}
match result {
@@ -1185,12 +1184,13 @@ fn run_window_timer_callback(
scope.thread_safe_handle(),
TIMER_CALLBACK_WATCHDOG_TIMEOUT,
);
+ let watchdog_timeout = watchdog.timeout();
let result = run_window_timer_source(scope, source);
let watchdog_timed_out = watchdog.disarm() == V8ExecutionWatchdogOutcome::TimedOut;
if watchdog_timed_out {
return Err(HostTimeoutRunResult::CallbackError(format!(
"timer source exceeded {:?} and was terminated",
- TIMER_CALLBACK_WATCHDOG_TIMEOUT
+ watchdog_timeout
)));
}
result
diff --git a/moli-renderer-v8/src/script_vm/eval_exec.rs b/moli-renderer-v8/src/script_vm/eval_exec.rs
index 7a25fe945..17cfc9c0e 100644
--- a/moli-renderer-v8/src/script_vm/eval_exec.rs
+++ b/moli-renderer-v8/src/script_vm/eval_exec.rs
@@ -236,6 +236,7 @@ fn execute_source_text_on_current_stack_with_completion(
scope.thread_safe_handle(),
SCRIPT_TURN_WATCHDOG_TIMEOUT,
);
+ let watchdog_timeout = watchdog.timeout();
let run_result = script.run(&scope);
let watchdog_timed_out = watchdog.disarm() == V8ExecutionWatchdogOutcome::TimedOut;
scope.set_continuation_preserved_embedder_data(previous_continuation_data);
@@ -243,7 +244,7 @@ fn execute_source_text_on_current_stack_with_completion(
if watchdog_timed_out {
return RawScriptExecutionError::Internal(anyhow!(
"script execution exceeded {:?} and was terminated",
- SCRIPT_TURN_WATCHDOG_TIMEOUT
+ watchdog_timeout
));
}
let exception = scope.exception();
@@ -573,12 +574,13 @@ impl ScriptVm {
scope.thread_safe_handle(),
SCRIPT_TURN_WATCHDOG_TIMEOUT,
);
+ let watchdog_timeout = watchdog.timeout();
perform_microtask_checkpoint_and_report_pending_promise_rejections(scope);
let watchdog_timed_out = watchdog.disarm() == V8ExecutionWatchdogOutcome::TimedOut;
if watchdog_timed_out {
return Err(anyhow!(
"microtask checkpoint exceeded {:?} and was terminated",
- SCRIPT_TURN_WATCHDOG_TIMEOUT
+ watchdog_timeout
));
}
if let Some(script_url) = script_url {
diff --git a/moli-renderer-v8/src/script_vm/page_task_enqueue.rs b/moli-renderer-v8/src/script_vm/page_task_enqueue.rs
index 5e243ce85..878ee8f7a 100644
--- a/moli-renderer-v8/src/script_vm/page_task_enqueue.rs
+++ b/moli-renderer-v8/src/script_vm/page_task_enqueue.rs
@@ -23,10 +23,7 @@ use crate::v8_execution_watchdog::{
V8ExecutionWatchdog, V8ExecutionWatchdogKind, V8ExecutionWatchdogOutcome,
};
-#[cfg(not(test))]
const LIFECYCLE_EVENT_WATCHDOG_TIMEOUT: Duration = Duration::from_secs(8);
-#[cfg(test)]
-const LIFECYCLE_EVENT_WATCHDOG_TIMEOUT: Duration = Duration::from_millis(500);
impl ScriptVm {
fn dispatch_document_event_body(&mut self, event_type: &str) -> Result<()> {
@@ -130,6 +127,7 @@ impl ScriptVm {
LIFECYCLE_EVENT_WATCHDOG_TIMEOUT,
)
});
+ let watchdog_timeout = watchdog.timeout();
let result = {
let context_ptr: *const v8::Global<v8::Context> = &self.page_default_context;
self.renderer_document_isolate
@@ -150,7 +148,7 @@ impl ScriptVm {
if timed_out {
anyhow::bail!(
"document lifecycle event `{event_type}` exceeded {:?} and was terminated",
- LIFECYCLE_EVENT_WATCHDOG_TIMEOUT
+ watchdog_timeout
);
}
Ok(())
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs
index 557e82466..dd85399cd 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs
@@ -3224,6 +3224,11 @@ fn host_dispatched_events_ignore_user_replaced_event_constructor() {
}
#[test]
fn domcontentloaded_listener_watchdog_terminates_runaway_listener_and_recovers_isolate() {
+ let _watchdog_timeout =
+ crate::v8_execution_watchdog::V8ExecutionWatchdog::override_timeout_for_test(
+ crate::v8_execution_watchdog::V8ExecutionWatchdogKind::LifecycleEvent,
+ std::time::Duration::from_millis(500),
+ );
let mut vm = new_storage_test_vm("https://example.com/");
vm.exec(
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index d7928064e..c72770d14 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -14929,6 +14929,11 @@ fn eval_probe_fixture_output(url: &str, markup: &str) -> serde_json::Value {
#[test]
fn script_turn_watchdog_terminates_runaway_script_and_recovers_isolate() {
+ let _watchdog_timeout =
+ crate::v8_execution_watchdog::V8ExecutionWatchdog::override_timeout_for_test(
+ crate::v8_execution_watchdog::V8ExecutionWatchdogKind::ScriptTurn,
+ std::time::Duration::from_millis(500),
+ );
let mut vm = new_parsed_test_vm("https://example.test/", "<!doctype html><body></body>");
let started = Instant::now();
let error = vm
@@ -14952,6 +14957,11 @@ fn script_turn_watchdog_terminates_runaway_script_and_recovers_isolate() {
#[test]
fn microtask_checkpoint_watchdog_terminates_runaway_queue_and_recovers_isolate() {
+ let _watchdog_timeout =
+ crate::v8_execution_watchdog::V8ExecutionWatchdog::override_timeout_for_test(
+ crate::v8_execution_watchdog::V8ExecutionWatchdogKind::ScriptTurn,
+ std::time::Duration::from_millis(500),
+ );
let mut vm = new_parsed_test_vm("https://example.test/", "<!doctype html><body></body>");
let started = Instant::now();
let error = vm
@@ -15119,6 +15129,11 @@ fn runtime_await_promise_sync_result_survives_queued_allocation_gc() {
#[tokio::test]
async fn timer_callback_watchdog_terminates_runaway_timer_and_recovers_isolate() {
+ let _watchdog_timeout =
+ crate::v8_execution_watchdog::V8ExecutionWatchdog::override_timeout_for_test(
+ crate::v8_execution_watchdog::V8ExecutionWatchdogKind::TimerCallback,
+ std::time::Duration::from_millis(500),
+ );
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm = new_parsed_test_vm("https://example.test/", "<!doctype html><body></body>");
vm.exec(
diff --git a/moli-renderer-v8/src/v8_execution_watchdog.rs b/moli-renderer-v8/src/v8_execution_watchdog.rs
index 3e639ed52..a98e1e8cc 100644
--- a/moli-renderer-v8/src/v8_execution_watchdog.rs
+++ b/moli-renderer-v8/src/v8_execution_watchdog.rs
@@ -32,6 +32,30 @@ pub(crate) enum V8ExecutionWatchdogKind {
LifecycleEvent,
}
+#[cfg(test)]
+impl V8ExecutionWatchdogKind {
+ const fn override_index(self) -> usize {
+ match self {
+ Self::ScriptTurn => 0,
+ Self::TimerCallback => 1,
+ Self::LifecycleEvent => 2,
+ }
+ }
+}
+
+#[cfg(test)]
+std::thread_local! {
+ static V8_EXECUTION_WATCHDOG_TIMEOUT_OVERRIDES:
+ std::cell::Cell<[Option<Duration>; 3]> =
+ const { std::cell::Cell::new([None, None, None]) };
+}
+
+#[cfg(test)]
+fn v8_execution_watchdog_timeout(kind: V8ExecutionWatchdogKind, fallback: Duration) -> Duration {
+ V8_EXECUTION_WATCHDOG_TIMEOUT_OVERRIDES
+ .with(|overrides| overrides.get()[kind.override_index()].unwrap_or(fallback))
+}
+
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum V8ExecutionWatchdogOutcome {
Completed,
@@ -209,6 +233,7 @@ fn run_v8_execution_watchdog_service(shared: Arc<V8ExecutionWatchdogServiceShare
pub(crate) struct V8ExecutionWatchdog {
key: V8ExecutionWatchdogRegistrationKey,
registration: Option<Arc<V8ExecutionWatchdogRegistration>>,
+ timeout: Duration,
}
impl V8ExecutionWatchdog {
@@ -217,14 +242,36 @@ impl V8ExecutionWatchdog {
isolate: v8::IsolateHandle,
timeout: Duration,
) -> Self {
+ #[cfg(test)]
+ let timeout = v8_execution_watchdog_timeout(kind, timeout);
let (key, registration) =
V8ExecutionWatchdogService::global().register(kind, isolate, timeout);
Self {
key,
registration: Some(registration),
+ timeout,
}
}
+ #[cfg(test)]
+ pub(crate) fn override_timeout_for_test(
+ kind: V8ExecutionWatchdogKind,
+ timeout: Duration,
+ ) -> V8ExecutionWatchdogTimeoutOverride {
+ assert!(!timeout.is_zero(), "watchdog timeout must be non-zero");
+ let previous = V8_EXECUTION_WATCHDOG_TIMEOUT_OVERRIDES.with(|overrides| {
+ let mut values = overrides.get();
+ let previous = values[kind.override_index()].replace(timeout);
+ overrides.set(values);
+ previous
+ });
+ V8ExecutionWatchdogTimeoutOverride { kind, previous }
+ }
+
+ pub(crate) fn timeout(&self) -> Duration {
+ self.timeout
+ }
+
pub(crate) fn disarm(mut self) -> V8ExecutionWatchdogOutcome {
self.disarm_inner()
}
@@ -244,6 +291,23 @@ impl Drop for V8ExecutionWatchdog {
}
}
+#[cfg(test)]
+pub(crate) struct V8ExecutionWatchdogTimeoutOverride {
+ kind: V8ExecutionWatchdogKind,
+ previous: Option<Duration>,
+}
+
+#[cfg(test)]
+impl Drop for V8ExecutionWatchdogTimeoutOverride {
+ fn drop(&mut self) {
+ V8_EXECUTION_WATCHDOG_TIMEOUT_OVERRIDES.with(|overrides| {
+ let mut values = overrides.get();
+ values[self.kind.override_index()] = self.previous;
+ overrides.set(values);
+ });
+ }
+}
+
#[cfg(test)]
static V8_EXECUTION_WATCHDOG_SERVICE_THREAD_STARTS: std::sync::atomic::AtomicUsize =
std::sync::atomic::AtomicUsize::new(0);
@@ -252,6 +316,49 @@ static V8_EXECUTION_WATCHDOG_SERVICE_THREAD_STARTS: std::sync::atomic::AtomicUsi
mod tests {
use super::*;
+ #[test]
+ fn timeout_override_is_kind_scoped_and_restored() {
+ let fallback = Duration::from_secs(8);
+ assert_eq!(
+ v8_execution_watchdog_timeout(V8ExecutionWatchdogKind::ScriptTurn, fallback),
+ fallback
+ );
+
+ {
+ let _outer = V8ExecutionWatchdog::override_timeout_for_test(
+ V8ExecutionWatchdogKind::ScriptTurn,
+ Duration::from_millis(500),
+ );
+ assert_eq!(
+ v8_execution_watchdog_timeout(V8ExecutionWatchdogKind::ScriptTurn, fallback),
+ Duration::from_millis(500)
+ );
+ assert_eq!(
+ v8_execution_watchdog_timeout(V8ExecutionWatchdogKind::TimerCallback, fallback),
+ fallback
+ );
+ {
+ let _inner = V8ExecutionWatchdog::override_timeout_for_test(
+ V8ExecutionWatchdogKind::ScriptTurn,
+ Duration::from_millis(250),
+ );
+ assert_eq!(
+ v8_execution_watchdog_timeout(V8ExecutionWatchdogKind::ScriptTurn, fallback),
+ Duration::from_millis(250)
+ );
+ }
+ assert_eq!(
+ v8_execution_watchdog_timeout(V8ExecutionWatchdogKind::ScriptTurn, fallback),
+ Duration::from_millis(500)
+ );
+ }
+
+ assert_eq!(
+ v8_execution_watchdog_timeout(V8ExecutionWatchdogKind::ScriptTurn, fallback),
+ fallback
+ );
+ }
+
fn evaluate_script(isolate: &mut v8::OwnedIsolate, source: &str) -> Option<String> {
let scope = std::pin::pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();