Struct JsWorker 

pub struct JsWorker { /* private fields */ }

Available on crate features js and std only.

A JsRuntime owned by a dedicated OS thread: the compile-once, call-many execution model.

State (globals, function definitions, …) persists for the lifetime of the worker: execute a script once, then call into its functions per request. This is the model browsers and proxies use for long-lived configuration scripts; spawn a fresh worker instead when a script must not observe earlier executions.

The handle is cheap to clone; all handles share the same runtime and jobs run strictly in order. The thread exits once the last handle is dropped.

A job that exceeds the worker’s timeout releases its caller with a JsErrorKind::Timeout. A job still waiting in the queue is cancelled and never runs. A job already running cannot be interrupted when it is inside an arbitrary Rust host callback; until that exact job finishes the worker is abandoned, and later jobs fail fast with JsErrorKind::Setup instead of queueing behind work that may never end. If it never returns, the worker is retired and its thread remains occupied, so spawn a replacement. Without a timeout configured, such a job blocks its caller and the queue indefinitely.

A panicking host function kills the worker: the pending and all later jobs fail fast with a JsErrorKind::Setup error (fail-loud, rather than continuing on a runtime in unknown state).

Implementations

impl JsWorker

pub const DEFAULT_QUEUE_CAPACITY: usize = 128

Default capacity of the worker’s job queue.

pub fn builder() -> JsWorkerBuilder

Create a JsWorkerBuilder to configure a new worker.

pub fn spawn(builder: JsRuntimeBuilder) -> Result<JsWorker, JsError>

Spawn a worker thread owning a fresh JsRuntime built from the given builder, with the default worker configuration.

pub fn is_abandoned(&self) -> bool

Whether the worker is stuck on a job that overran its timeout.

Abandoned workers refuse further jobs. The state clears by itself if the overrunning job does eventually finish; a job that never returns retires the worker for good, so spawn a replacement.

pub async fn run<T, F>(&self, f: F) -> Result<T, JsError>

where F: FnOnce(&mut JsRuntime) -> Result<T, JsError> + Send + 'static, T: Send + 'static,

Execute the given closure with exclusive access to the worker’s runtime.

Dropping this future cancels the job while it is still queued. Once the job is running it is allowed to finish, since arbitrary Rust host code cannot be interrupted safely.

pub async fn eval<S>(&self, src: S) -> Result<JsValue, JsError>

where S: AsRef<str> + Send + 'static,

Evaluate a script on the worker’s runtime, returning the value of its final expression.

pub async fn exec<S>(&self, src: S) -> Result<(), JsError>

where S: AsRef<str> + Send + 'static,

Execute a script on the worker’s runtime, discarding its final expression value.

pub async fn call<N, I, V>(&self, name: N, args: I) -> Result<JsValue, JsError>

where N: AsRef<str> + Send + 'static, I: IntoIterator<Item = V>, V: Into<JsValue>,

Call a global function (defined by a previously executed script, or registered as a host function) with the given arguments.

Trait Implementations

impl Clone for JsWorker

fn clone(&self) -> JsWorker

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JsWorker

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.