@wasm-oj/server 0.2.3 → 0.2.5

package/crates/runtime-core/src/run/mod.rs

@@ -15,6 +15,8 @@ mod native;
 #[cfg(target_arch = "wasm32")]
 mod web;
 #[cfg(target_arch = "wasm32")]
+pub(crate) mod web_interactive;
+#[cfg(target_arch = "wasm32")]
 pub(crate) mod web_runtime;
 
 pub fn run(request: RunRequest) -> Result<RunResult, RunError> {

package/crates/runtime-core/src/run/native.rs

@@ -2,7 +2,9 @@ use crate::capabilities::attach_capability_denials;
 use crate::deterministic::{VirtualClock, attach_deterministic_imports};
 use crate::filesystem::{read_files_bounded, runtime_project_files};
 use crate::memory::LimitingTunables;
-use crate::meter::{CostPoints, METER_MODEL, instrument_wasm, meter_state, remaining_points};
+use crate::meter::{
+    CostPoints, METER_MODEL, attach_safepoint, instrument_wasm, meter_state, remaining_points,
+};
 use crate::module_imports::attach_imported_memory;
 use crate::module_policy::{DEFERRED_START_EXPORT, defer_start_section, enforce_memory_limit};
 use crate::output::{OutputBudget, OutputCapture};
@@ -105,13 +107,14 @@ fn run_in_runtime(request: RunRequest) -> Result<RunResult, RunError> {
         clock.clone(),
         request.startup_entropy_bytes,
     );
+    attach_safepoint(&mut store, &mut imports);
     attach_capability_denials(&mut store, &module, &mut imports).map_err(RunError::Compile)?;
     let imported_memory =
         attach_imported_memory(&mut store, &module, &mut imports).map_err(RunError::Compile)?;
 
     let instance = Instance::new(&mut store, &module, &imports)
         .map_err(|error| RunError::Compile(format!("failed to instantiate module: {error}")))?;
-    let meter = meter_state(&mut store, &instance).map_err(RunError::Runtime)?;
+    let meter = meter_state(&instance).map_err(RunError::Runtime)?;
     let guest_memory = instance
         .exports
         .get_memory("memory")

package/crates/runtime-core/src/run/web.rs

@@ -2,13 +2,16 @@ use super::web_runtime::runtime_with_engine;
 use crate::capabilities::attach_capability_denials;
 use crate::deterministic::{VirtualClock, attach_deterministic_imports};
 use crate::filesystem::{read_files_bounded, runtime_project_files};
-use crate::meter::{CostPoints, METER_MODEL, instrument_wasm, meter_state, remaining_points};
+use crate::meter::{
+    CostPoints, METER_MODEL, attach_safepoint, instrument_wasm, meter_state, remaining_points,
+};
 use crate::module_imports::attach_imported_memory;
 use crate::module_policy::{DEFERRED_START_EXPORT, defer_start_section, enforce_memory_limit};
-use crate::output::{OutputBudget, OutputCapture};
+use crate::output::{CappedOutput, OutputBudget, OutputCapture};
 use crate::{ExecutionMetrics, ExecutionTermination, RunError, RunRequest, RunResult};
 use std::io::Write;
 use std::sync::{Arc, Mutex};
+use virtual_fs::VirtualFile;
 use wasmer::{Instance, Memory, Module, Store};
 use wasmer_wasix::{
     Pipe, WasiEnv, WasiError, WasiModuleInstanceHandles, WasiModuleTreeHandles, wasmer_wasix_types,
@@ -16,8 +19,29 @@ use wasmer_wasix::{
 
 pub fn run(
     request: RunRequest,
-    mut on_execution: impl FnMut(bool) -> Result<(), RunError>,
+    on_execution: impl FnMut(bool) -> Result<(), RunError>,
 ) -> Result<RunResult, RunError> {
+    let (mut stdin_writer, stdin_reader) = Pipe::channel();
+    stdin_writer
+        .write_all(&request.stdin)
+        .map_err(|error| RunError::Io(error.to_string()))?;
+    drop(stdin_writer);
+    execute(request, Box::new(stdin_reader), None, on_execution).map(|execution| execution.result)
+}
+
+pub(super) type StdoutPeer = Box<dyn FnOnce(CappedOutput) -> Box<dyn VirtualFile + Send + Sync>>;
+
+pub(super) struct Execution {
+    pub result: RunResult,
+    pub exit_code: Option<i32>,
+}
+
+pub(super) fn execute(
+    request: RunRequest,
+    stdin: Box<dyn VirtualFile + Send + Sync>,
+    stdout_peer: Option<StdoutPeer>,
+    mut on_execution: impl FnMut(bool) -> Result<(), RunError>,
+) -> Result<Execution, RunError> {
     let limited = enforce_memory_limit(&request.wasm, request.resources.memory_limit_bytes)
         .map_err(RunError::Compile)?;
     let metered = instrument_wasm(&limited, request.resources.instruction_budget)
@@ -29,11 +53,6 @@ pub fn run(
     })?;
     let runtime = runtime_with_engine(store.engine().clone());
 
-    let (mut stdin_writer, stdin_reader) = Pipe::channel();
-    stdin_writer
-        .write_all(&request.stdin)
-        .map_err(|error| RunError::Io(error.to_string()))?;
-    drop(stdin_writer);
     let output_limit = usize::try_from(request.resources.output_limit_bytes)
         .map_err(|_| RunError::InvalidRequest("output limit exceeds host range".to_string()))?;
     let output_budget = OutputBudget::new(output_limit);
@@ -51,8 +70,11 @@ pub fn run(
         .runtime(runtime)
         .args(request.args.clone())
         .envs(request.env.clone())
-        .stdin(Box::new(stdin_reader))
-        .stdout(Box::new(stdout_file))
+        .stdin(stdin)
+        .stdout(match stdout_peer {
+            Some(peer) => peer(stdout_file),
+            None => Box::new(stdout_file),
+        })
         .stderr(Box::new(stderr_file))
         .fs(filesystem.clone());
     builder
@@ -82,12 +104,13 @@ pub fn run(
         clock.clone(),
         request.startup_entropy_bytes,
     );
+    attach_safepoint(&mut store, &mut imports);
     attach_capability_denials(&mut store, &module, &mut imports).map_err(RunError::Compile)?;
     let imported_memory =
         attach_imported_memory(&mut store, &module, &mut imports).map_err(RunError::Compile)?;
     let instance = Instance::new(&mut store, &module, &imports)
         .map_err(|error| RunError::Compile(format!("failed to instantiate module: {error}")))?;
-    let meter = meter_state(&mut store, &instance).map_err(RunError::Runtime)?;
+    let meter = meter_state(&instance).map_err(RunError::Runtime)?;
     let guest_memory = instance
         .exports
         .get_memory("memory")
@@ -138,12 +161,14 @@ pub fn run(
     let logical_time_exceeded = clock.limit_exceeded()?;
 
     let mut code = 0;
+    let mut exit_code = None;
     let mut termination = ExecutionTermination::Exited;
     let mut trap_message = None;
     if let Err(error) = execution {
         if let Some(wasi_error) = crate::wasi_error(&error) {
             match wasi_error {
                 WasiError::Exit(exit) => {
+                    exit_code = Some(exit.raw());
                     let errno: wasmer_wasix_types::wasi::Errno = (*exit).into();
                     if errno != wasmer_wasix_types::wasi::Errno::Success {
                         code = errno as i32;
@@ -211,7 +236,7 @@ pub fn run(
         CostPoints::Exhausted => request.resources.instruction_budget,
     };
     let filesystem_metrics = project_filesystem.metrics();
-    Ok(RunResult {
+    let result = RunResult {
         code,
         metrics: ExecutionMetrics {
             cost,
@@ -231,5 +256,6 @@ pub fn run(
         trap_message,
         determinism: request.determinism,
         resources: request.resources,
-    })
+    };
+    Ok(Execution { result, exit_code })
 }

package/crates/runtime-core/src/run/web_interactive.rs

@@ -0,0 +1,375 @@
+use super::web::{Execution, execute};
+use crate::output::CappedOutput;
+use crate::{
+    DeterminismConfig, ExecutionTermination, InteractiveMetrics, InteractiveProcessResult,
+    InteractiveProgram, RunError, RunRequest,
+};
+use serde::{Deserialize, Serialize};
+use std::io;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
+use virtual_fs::{FsError, VirtualFile};
+use wasm_bindgen::JsValue;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct InteractiveSideRequest {
+    pub program: InteractiveProgram,
+    pub determinism: DeterminismConfig,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InteractiveSideResult {
+    pub process: InteractiveProcessResult,
+    #[serde(with = "serde_bytes")]
+    pub protocol: Vec<u8>,
+}
+
+/// Stream callbacks supplied by the side Worker. Reads and writes wait with
+/// `Atomics.wait`, so they never return `Pending` to WASIX.
+pub struct HostStreams {
+    read: js_sys::Function,
+    poll: js_sys::Function,
+    wait: js_sys::Function,
+    write: js_sys::Function,
+    close: js_sys::Function,
+}
+
+// SAFETY: the web build of runtime-core has no threads; these JS handles never
+// leave the Worker thread that created them.
+unsafe impl Send for HostStreams {}
+// SAFETY: see `Send`.
+unsafe impl Sync for HostStreams {}
+
+impl HostStreams {
+    pub fn new(
+        read: js_sys::Function,
+        poll: js_sys::Function,
+        wait: js_sys::Function,
+        write: js_sys::Function,
+        close: js_sys::Function,
+    ) -> Self {
+        Self {
+            read,
+            poll,
+            wait,
+            write,
+            close,
+        }
+    }
+
+    fn read(&self, maximum: usize) -> io::Result<Vec<u8>> {
+        let chunk = self
+            .read
+            .call1(&JsValue::UNDEFINED, &JsValue::from(maximum as u32))
+            .map_err(host_error)?;
+        Ok(js_sys::Uint8Array::new(&chunk).to_vec())
+    }
+
+    fn poll(&self) -> io::Result<Option<usize>> {
+        let available = self
+            .poll
+            .call0(&JsValue::UNDEFINED)
+            .map_err(host_error)?
+            .as_f64()
+            .ok_or_else(|| io::Error::other("interactive input poll returned no size"))?;
+        Ok((available >= 0.0).then_some(available as usize))
+    }
+
+    fn wait(&self) -> io::Result<usize> {
+        let available = self
+            .wait
+            .call0(&JsValue::UNDEFINED)
+            .map_err(host_error)?
+            .as_f64()
+            .ok_or_else(|| io::Error::other("interactive input wait returned no size"))?;
+        Ok(available as usize)
+    }
+
+    fn write(&self, bytes: &[u8]) -> io::Result<usize> {
+        let written = self
+            .write
+            .call1(&JsValue::UNDEFINED, &js_sys::Uint8Array::from(bytes))
+            .map_err(host_error)?
+            .as_f64()
+            .ok_or_else(|| io::Error::other("interactive output write returned no size"))?;
+        if written < 0.0 {
+            return Err(io::ErrorKind::BrokenPipe.into());
+        }
+        Ok(written as usize)
+    }
+
+    /// Closes the input (fd 0) or output (fd 1) pipe end, so the peer sees
+    /// EOF or a broken pipe at once, as when native drops its pipe end.
+    fn close(&self, fd: u32) {
+        let _ = self.close.call1(&JsValue::UNDEFINED, &JsValue::from(fd));
+    }
+}
+
+fn host_error(error: JsValue) -> io::Error {
+    io::Error::other(format!("interactive stream failed: {error:?}"))
+}
+
+pub fn run_side(
+    request: InteractiveSideRequest,
+    streams: HostStreams,
+    on_execution: impl FnMut(bool) -> Result<(), RunError>,
+) -> Result<InteractiveSideResult, RunError> {
+    let program = request.program;
+    if program.wasm.is_empty() {
+        return Err(RunError::InvalidRequest(
+            "interactive Wasm must not be empty".to_string(),
+        ));
+    }
+    let run = RunRequest {
+        wasm: program.wasm,
+        args: program.args,
+        env: program.env,
+        stdin: Vec::new(),
+        files: program.files,
+        output_paths: Vec::new(),
+        cwd: program.cwd,
+        startup_entropy_bytes: program.startup_entropy_bytes,
+        determinism: request.determinism,
+        resources: program.resources,
+    };
+    super::validate(&run)?;
+    let streams = Arc::new(streams);
+    let input = StreamInput {
+        streams: streams.clone(),
+    };
+    let Execution { result, exit_code } = execute(
+        run,
+        Box::new(input),
+        Some(Box::new(move |capture| {
+            Box::new(StreamOutput { streams, capture })
+        })),
+        on_execution,
+    )?;
+    let code = match exit_code {
+        Some(code) if result.termination == ExecutionTermination::Exited => code,
+        _ => result.code,
+    };
+    Ok(InteractiveSideResult {
+        process: InteractiveProcessResult {
+            code,
+            stderr: result.stderr,
+            termination: result.termination,
+            metrics: InteractiveMetrics {
+                cost: result.metrics.cost,
+                operations: result.metrics.operations,
+                logical_time_ns: result.metrics.logical_time_ns,
+                filesystem_bytes: result.metrics.filesystem_bytes,
+                filesystem_entries: result.metrics.filesystem_entries,
+                protocol_bytes: result.metrics.stdout_bytes,
+                stderr_bytes: result.metrics.stderr_bytes,
+            },
+        },
+        protocol: result.stdout,
+    })
+}
+
+struct StreamInput {
+    streams: Arc<HostStreams>,
+}
+
+// WASIX drops the stdio handle when the last descriptor that refers to it is
+// closed, which is when native drops its `PipeRx` or `PipeTx`.
+impl Drop for StreamInput {
+    fn drop(&mut self) {
+        self.streams.close(0);
+    }
+}
+
+impl std::fmt::Debug for StreamInput {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("StreamInput")
+    }
+}
+
+impl AsyncRead for StreamInput {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _context: &mut Context<'_>,
+        buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Ready(self.streams.read(buffer.remaining()).map(|chunk| {
+            buffer.put_slice(&chunk);
+        }))
+    }
+}
+
+impl AsyncWrite for StreamInput {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _context: &mut Context<'_>,
+        _buffer: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Err(io::ErrorKind::Unsupported.into()))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncSeek for StreamInput {
+    fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn poll_complete(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl VirtualFile for StreamInput {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn get_special_fd(&self) -> Option<u32> {
+        Some(0)
+    }
+
+    fn poll_read_ready(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        match self.streams.poll() {
+            Ok(Some(available)) => Poll::Ready(Ok(available)),
+            Ok(None) if crate::deterministic::defer_stdin_readiness() => {
+                context.waker().wake_by_ref();
+                Poll::Pending
+            }
+            Ok(None) => Poll::Ready(self.streams.wait()),
+            Err(error) => Poll::Ready(Err(error)),
+        }
+    }
+
+    fn poll_write_ready(
+        self: Pin<&mut Self>,
+        _context: &mut Context<'_>,
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Err(io::ErrorKind::Unsupported.into()))
+    }
+}
+
+struct StreamOutput {
+    streams: Arc<HostStreams>,
+    capture: CappedOutput,
+}
+
+impl Drop for StreamOutput {
+    fn drop(&mut self) {
+        self.streams.close(1);
+    }
+}
+
+impl std::fmt::Debug for StreamOutput {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("StreamOutput")
+    }
+}
+
+impl AsyncWrite for StreamOutput {
+    /// Drops bytes written after the peer closed its stdin, as native does; they are already in
+    /// the transcript.
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+        buffer: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        match Pin::new(&mut self.capture).poll_write(context, buffer) {
+            Poll::Ready(Ok(written)) => Poll::Ready(match self.streams.write(&buffer[..written]) {
+                Err(error) if error.kind() == io::ErrorKind::BrokenPipe => Ok(written),
+                result => result,
+            }),
+            result => result,
+        }
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncRead for StreamOutput {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _context: &mut Context<'_>,
+        _buffer: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncSeek for StreamOutput {
+    fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn poll_complete(self: Pin<&mut Self>, _context: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl VirtualFile for StreamOutput {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn get_special_fd(&self) -> Option<u32> {
+        Some(1)
+    }
+
+    fn poll_read_ready(
+        self: Pin<&mut Self>,
+        _context: &mut Context<'_>,
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+
+    fn poll_write_ready(
+        mut self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.capture).poll_write_ready(context)
+    }
+}

package/crates/runtime-core/src/web.rs

@@ -1,6 +1,7 @@
+use crate::run::web_interactive::{HostStreams, InteractiveSideRequest, run_side};
 use crate::{
     GoCompilerSession as CoreGoCompilerSession, GoCompilerSessionConfig, GoCompilerSessionRequest,
-    InteractiveRequest, RunError, RunRequest, interactive_response, run_response_from_result,
+    RunError, RunFailure, RunRequest, run_response_from_result,
 };
 use serde::Serialize;
 use wasm_bindgen::prelude::*;
@@ -72,17 +73,62 @@ impl WebGoCompilerSession {
     }
 }
 
+/// Runs one side of an interactive session in the calling Worker. `read`,
+/// `wait` and `write` block on the session's shared ring buffers; `poll`
+/// checks the input without blocking; `close(fd)` closes the input (0) or
+/// output (1) end when the guest drops it.
 #[wasm_bindgen]
-pub async fn interact_wasm_oj(request: JsValue) -> Result<JsValue, JsValue> {
+pub fn run_interactive_side(
+    request: JsValue,
+    read: js_sys::Function,
+    poll: js_sys::Function,
+    wait: js_sys::Function,
+    write: js_sys::Function,
+    close: js_sys::Function,
+    on_execution: js_sys::Function,
+) -> Result<JsValue, JsValue> {
     console_error_panic_hook::set_once();
-    let request: InteractiveRequest = serde_wasm_bindgen::from_value(request)
-        .map_err(|error| JsValue::from_str(&format!("invalid interactive request: {error}")))?;
-    let response = interactive_response(request).await;
+    let request: InteractiveSideRequest =
+        serde_wasm_bindgen::from_value(request).map_err(|error| {
+            JsValue::from_str(&format!("invalid interactive side request: {error}"))
+        })?;
+    let response = match run_side(
+        request,
+        HostStreams::new(read, poll, wait, write, close),
+        |running| {
+            on_execution
+                .call1(&JsValue::UNDEFINED, &JsValue::from_bool(running))
+                .map(|_| ())
+                .map_err(|error| RunError::Runtime(format!("execution observer failed: {error:?}")))
+        },
+    ) {
+        Ok(result) => InteractiveSideResponse {
+            ok: true,
+            result: Some(result),
+            error: None,
+        },
+        Err(error) => InteractiveSideResponse {
+            ok: false,
+            result: None,
+            error: Some(RunFailure {
+                code: error.code(),
+                message: error.to_string(),
+            }),
+        },
+    };
     response
         .serialize(&serde_wasm_bindgen::Serializer::new().serialize_maps_as_objects(true))
         .map_err(|error| {
             JsValue::from_str(&format!(
-                "failed to serialize interactive response: {error}"
+                "failed to serialize interactive side response: {error}"
             ))
         })
 }
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct InteractiveSideResponse {
+    ok: bool,
+    result: Option<crate::run::web_interactive::InteractiveSideResult>,
+    error: Option<RunFailure>,
+}