Use wasmtime-wasi APIs instead of wasi-common

Author: jeffcharles

Cargo.lock

@@ -19,6 +19,8 @@ ruby-api = []
 winch = ["wasmtime/winch"]
 
 [dependencies]
+async-trait = "*"
+bytes = "*"
 lazy_static = "1.5.0"
 magnus = { version = "0.7", features = ["rb-sys"] }
 rb-sys = { version = "*", default-features = false, features = [
@@ -40,7 +42,7 @@ async-timer = { version = "1.0.0-beta.15", features = [
 ], optional = true }
 static_assertions = "1.1.0"
 wasmtime-environ = "=31.0.0"
-deterministic-wasi-ctx = "=0.1.34"
+deterministic-wasi-ctx = "=1.0.0"
 
 [build-dependencies]
 rb-sys-env = "0.2.2"

ext/Cargo.toml

@@ -0,0 +1,25 @@
+use std::sync::Arc;
+
+use wasmtime_wasi::{FileInputStream, StdinStream};
+
+pub struct FileStdinStream {
+    file: Arc<File>,
+}
+
+impl FileStdinStream {
+    pub fn new(file: File) -> Self {
+        Self {
+            file: Arc::new(file),
+        }
+    }
+}
+
+impl StdinStream for FileStdinStream {
+    fn stream(&self) -> Box<dyn wasmtime_wasi::InputStream> {
+        Box::new(FileInputStream::new(Arc::clone(&self.file), 0))
+    }
+
+    fn isatty(&self) -> bool {
+        false
+    }
+}

ext/src/helpers/file_stdin_stream.rs

@@ -1,12 +1,14 @@
+mod file_stdin_stream;
 mod macros;
 mod nogvl;
 mod output_limited_buffer;
 mod static_id;
 mod symbol_enum;
 mod tmplock;
 
+pub use file_stdin_stream::FileStdinStream;
 pub use nogvl::nogvl;
-pub use output_limited_buffer::OutputLimitedBuffer;
+pub use output_limited_buffer::{OutputLimitedBuffer, WritePipe};
 pub use static_id::StaticId;
 pub use symbol_enum::SymbolEnum;
 pub use tmplock::Tmplock;

ext/src/helpers/mod.rs

@@ -1,9 +1,63 @@
+use bytes::Bytes;
 use magnus::{
     value::{InnerValue, Opaque, ReprValue},
     RString, Ruby,
 };
-use std::io;
-use std::io::ErrorKind;
+use std::io::Write;
+use std::sync::{Arc, Mutex};
+use wasmtime_wasi::{OutputStream, Pollable, StdoutStream, StreamError, StreamResult};
+
+pub struct WritePipe {
+    inner: Arc<Mutex<OutputLimitedBuffer>>,
+}
+
+impl WritePipe {
+    pub fn new(inner: OutputLimitedBuffer) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(inner)),
+        }
+    }
+}
+
+impl Clone for WritePipe {
+    fn clone(&self) -> Self {
+        Self {
+            inner: Arc::clone(&self.inner),
+        }
+    }
+}
+
+impl StdoutStream for WritePipe {
+    fn stream(&self) -> Box<dyn wasmtime_wasi::OutputStream> {
+        let cloned = self.clone();
+        Box::new(cloned)
+    }
+
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+#[async_trait::async_trait]
+impl Pollable for WritePipe {
+    async fn ready(&mut self) {}
+}
+
+impl OutputStream for WritePipe {
+    fn write(&mut self, bytes: Bytes) -> StreamResult<()> {
+        let mut stream = self.inner.lock().expect("Should be only writer");
+        stream.write(&bytes)
+    }
+
+    fn flush(&mut self) -> StreamResult<()> {
+        Ok(())
+    }
+
+    fn check_write(&mut self) -> StreamResult<usize> {
+        let mut stream = self.inner.lock().expect("Should be only writer");
+        stream.check_write()
+    }
+}
 
 /// A buffer that limits the number of bytes that can be written to it.
 /// If the buffer is full, it will truncate the data.
@@ -21,8 +75,12 @@ impl OutputLimitedBuffer {
     }
 }
 
-impl io::Write for OutputLimitedBuffer {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+impl OutputLimitedBuffer {
+    fn check_write(&mut self) -> StreamResult<usize> {
+        Ok(usize::MAX)
+    }
+
+    fn write(&mut self, buf: &[u8]) -> StreamResult<()> {
         // Append a buffer to the string and truncate when hitting the capacity.
         // We return the input buffer size regardless of whether we truncated or not to avoid a panic.
         let ruby = Ruby::get().unwrap();
@@ -32,39 +90,34 @@ impl io::Write for OutputLimitedBuffer {
         // Handling frozen case here is necessary because magnus does not check if a string is frozen before writing to it.
         let is_frozen = inner_buffer.as_value().is_frozen();
         if is_frozen {
-            return Err(io::Error::new(
-                ErrorKind::WriteZero,
-                "Cannot write to a frozen buffer.",
-            ));
+            return Err(StreamError::trap("Cannot write to a frozen buffer."));
         }
 
         if buf.is_empty() {
-            return Ok(0);
+            return Ok(());
         }
 
         if inner_buffer
             .len()
             .checked_add(buf.len())
             .is_some_and(|val| val < self.capacity)
         {
-            let amount_written = inner_buffer.write(buf)?;
+            let amount_written = inner_buffer
+                .write(buf)
+                .map_err(|e| StreamError::trap(&e.to_string()))?;
             if amount_written < buf.len() {
-                return Ok(amount_written);
+                return Ok(());
             }
         } else {
             let portion = self.capacity - inner_buffer.len();
-            let amount_written = inner_buffer.write(&buf[0..portion])?;
+            let amount_written = inner_buffer
+                .write(&buf[0..portion])
+                .map_err(|e| StreamError::trap(&e.to_string()))?;
             if amount_written < portion {
-                return Ok(amount_written);
+                return Ok(());
             }
         };
 
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        let ruby = Ruby::get().unwrap();
-
-        self.buffer.get_inner_with(&ruby).flush()
+        Ok(())
     }
 }

ext/src/helpers/output_limited_buffer.rs

@@ -54,8 +54,10 @@ impl Linker {
 
         let mut inner: LinkerImpl<StoreData> = LinkerImpl::new(engine.get());
         if wasi {
-            wasi_common::sync::add_to_linker(&mut inner, |s| s.wasi_ctx_mut())
-                .map_err(|e| error!("{}", e))?
+            wasmtime_wasi::preview0::add_to_linker_sync(&mut inner, |s| s.wasi_ctx_mut())
+                .map_err(|e| error!("{}", e))?;
+            wasmtime_wasi::preview1::add_to_linker_sync(&mut inner, |s| s.wasi_ctx_mut())
+                .map_err(|e| error!("{}", e))?;
         }
         Ok(Self {
             inner: RefCell::new(inner),

ext/src/ruby_api/linker.rs

@@ -15,11 +15,12 @@ use rb_sys::tracking_allocator::{ManuallyTracked, TrackingAllocator};
 use std::borrow::Borrow;
 use std::cell::UnsafeCell;
 use std::convert::TryFrom;
-use wasi_common::{I32Exit, WasiCtx as WasiCtxImpl};
 use wasmtime::{
     AsContext, AsContextMut, ResourceLimiter, Store as StoreImpl, StoreContext, StoreContextMut,
     StoreLimits, StoreLimitsBuilder,
 };
+use wasmtime_wasi::preview1::WasiP1Ctx as WasiCtxImpl;
+use wasmtime_wasi::I32Exit;
 
 define_rb_intern!(
     WASI_CTX => "wasi_ctx",

ext/src/ruby_api/store.rs

@@ -5,20 +5,16 @@ use super::{
 };
 use crate::error;
 use crate::helpers::OutputLimitedBuffer;
-use deterministic_wasi_ctx::build_wasi_ctx as wasi_deterministic_ctx;
 use magnus::{
     class, function, gc::Marker, method, prelude::*, typed_data::Obj, Error, Object, RString,
     RTypedData, Ruby, TypedData, Value,
 };
 use std::{borrow::Borrow, cell::RefCell, fs::File, path::PathBuf};
-use wasi_common::pipe::{ReadPipe, WritePipe};
-use wasi_common::WasiCtx as WasiCtxImpl;
+use wasmtime_wasi::preview1::WasiP1Ctx as WasiCtxImpl;
 
 /// @yard
 /// WASI context to be sent as {Store#new}’s +wasi_ctx+ keyword argument.
 ///
-/// Instance methods mutate the current object and return +self+.
-///
 /// @see https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/struct.WasiCtx.html
 ///   Wasmtime's Rust doc
 #[magnus::wrap(class = "Wasmtime::WasiCtx", size, free_immediately)]
@@ -29,96 +25,6 @@ pub struct WasiCtx {
 type RbSelf = Obj<WasiCtx>;
 
 impl WasiCtx {
-    /// @yard
-    /// Create a new deterministic {WasiCtx}. See https://github.com/Shopify/deterministic-wasi-ctx for more details
-    /// @return [WasiCtx]
-    pub fn deterministic() -> Self {
-        Self {
-            inner: RefCell::new(wasi_deterministic_ctx()),
-        }
-    }
-
-    /// @yard
-    /// Set stdin to read from the specified file.
-    /// @def set_stdin_file(path)
-    /// @param path [String] The path of the file to read from.
-    /// @return [WasiCtxBuilder] +self+
-    fn set_stdin_file(rb_self: RbSelf, path: RString) -> RbSelf {
-        let inner = rb_self.inner.borrow_mut();
-        let cs = file_r(path).map(wasi_file).unwrap();
-        inner.set_stdin(cs);
-        rb_self
-    }
-
-    /// @yard
-    /// Set stdin to the specified String.
-    /// @def set_stdin_string(content)
-    /// @param content [String]
-    /// @return [WasiCtx] +self+
-    fn set_stdin_string(rb_self: RbSelf, content: RString) -> RbSelf {
-        let inner = rb_self.inner.borrow_mut();
-        let str = unsafe { content.as_slice() };
-        let pipe = ReadPipe::from(str);
-        inner.set_stdin(Box::new(pipe));
-        rb_self
-    }
-
-    /// @yard
-    /// Set stdout to write to a file. Will truncate the file if it exists,
-    /// otherwise try to create it.
-    /// @def set_stdout_file(path)
-    /// @param path [String] The path of the file to write to.
-    /// @return [WasiCtx] +self+
-    fn set_stdout_file(rb_self: RbSelf, path: RString) -> RbSelf {
-        let inner = rb_self.inner.borrow_mut();
-        let cs = file_w(path).map(wasi_file).unwrap();
-        inner.set_stdout(cs);
-        rb_self
-    }
-
-    /// @yard
-    /// Set stdout to write to a string buffer.
-    /// If the string buffer is frozen, Wasm execution will raise a Wasmtime::Error error.
-    /// No encoding checks are done on the resulting string, it is the caller's responsibility to ensure the string contains a valid encoding
-    /// @def set_stdout_buffer(buffer, capacity)
-    /// @param buffer [String] The string buffer to write to.
-    /// @param capacity [Integer] The maximum number of bytes that can be written to the output buffer.
-    /// @return [WasiCtx] +self+
-    fn set_stdout_buffer(rb_self: RbSelf, buffer: RString, capacity: usize) -> RbSelf {
-        let inner = rb_self.inner.borrow_mut();
-        let pipe = WritePipe::new(OutputLimitedBuffer::new(buffer.into(), capacity));
-        inner.set_stdout(Box::new(pipe));
-        rb_self
-    }
-
-    /// @yard
-    /// Set stderr to write to a file. Will truncate the file if it exists,
-    /// otherwise try to create it.
-    /// @def set_stderr_file(path)
-    /// @param path [String] The path of the file to write to.
-    /// @return [WasiCtx] +self+
-    fn set_stderr_file(rb_self: RbSelf, path: RString) -> RbSelf {
-        let inner = rb_self.inner.borrow_mut();
-        let cs = file_w(path).map(wasi_file).unwrap();
-        inner.set_stderr(cs);
-        rb_self
-    }
-
-    /// @yard
-    /// Set stderr to write to a string buffer.
-    /// If the string buffer is frozen, Wasm execution will raise a Wasmtime::Error error.
-    /// No encoding checks are done on the resulting string, it is the caller's responsibility to ensure the string contains a valid encoding
-    /// @def set_stderr_buffer(buffer, capacity)
-    /// @param buffer [String] The string buffer to write to.
-    /// @param capacity [Integer] The maximum number of bytes that can be written to the output buffer.
-    /// @return [WasiCtx] +self+
-    fn set_stderr_buffer(rb_self: RbSelf, buffer: RString, capacity: usize) -> RbSelf {
-        let inner = rb_self.inner.borrow_mut();
-        let pipe = WritePipe::new(OutputLimitedBuffer::new(buffer.into(), capacity));
-        inner.set_stderr(Box::new(pipe));
-        rb_self
-    }
-
     pub fn from_inner(inner: WasiCtxImpl) -> Self {
         Self {
             inner: RefCell::new(inner),
@@ -131,13 +37,6 @@ impl WasiCtx {
 }
 
 pub fn init() -> Result<(), Error> {
-    let class = root().define_class("WasiCtx", class::object())?;
-    class.define_singleton_method("deterministic", function!(WasiCtx::deterministic, 0))?;
-    class.define_method("set_stdin_file", method!(WasiCtx::set_stdin_file, 1))?;
-    class.define_method("set_stdin_string", method!(WasiCtx::set_stdin_string, 1))?;
-    class.define_method("set_stdout_file", method!(WasiCtx::set_stdout_file, 1))?;
-    class.define_method("set_stdout_buffer", method!(WasiCtx::set_stdout_buffer, 2))?;
-    class.define_method("set_stderr_file", method!(WasiCtx::set_stderr_file, 1))?;
-    class.define_method("set_stderr_buffer", method!(WasiCtx::set_stderr_buffer, 2))?;
+    root().define_class("WasiCtx", class::object())?;
     Ok(())
 }