Update to wasmtime v36 (#500)

* Update to wasmtime v36

Includes a couple of non-functional changes to the WASI layer, which
reflect the code motion that happened in the upstream crate.

* Dummy support for `AsyncWrite`

* Lint

Author: saulecabrera

Cargo.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    wasmtime (34.0.0)
+    wasmtime (36.0.0)
       rb_sys (~> 0.9.116)
 
 GEM

Gemfile.lock

@@ -1,6 +1,6 @@
 [package]
 name = "wasmtime-rb"
-version = "33.0.0"
+version = "36.0.0"
 edition = "2021"
 authors = ["The Wasmtime Project Developers"]
 license = "Apache-2.0"
@@ -24,8 +24,8 @@ magnus = { version = "0.7", features = ["rb-sys"] }
 rb-sys = { version = "*", default-features = false, features = [
   "stable-api-compiled-fallback",
 ] }
-wasmtime = { version = "=34.0.0", features = ["memory-protection-keys"] }
-wasmtime-wasi = "=34.0.0"
+wasmtime = { version = "=36.0.0", features = ["memory-protection-keys"] }
+wasmtime-wasi = "=36.0.0"
 cap-std = "3.4.0"
 wat = "1.236.0"
 tokio = { version = "1.47.1", features = [
@@ -38,8 +38,8 @@ async-timer = { version = "1.0.0-beta.15", features = [
   "tokio1",
 ], optional = true }
 static_assertions = "1.1.0"
-wasmtime-environ = "=34.0.0"
-deterministic-wasi-ctx = { version = "=3.0.0" }
+wasmtime-environ = "=36.0.0"
+deterministic-wasi-ctx = { version = "=3.0.1" }
 
 [build-dependencies]
 rb-sys-env = "0.2.2"

ext/Cargo.toml

@@ -5,7 +5,9 @@ use magnus::{
 };
 use std::io::Write;
 use std::sync::{Arc, Mutex};
-use wasmtime_wasi::p2::{OutputStream, Pollable, StdoutStream, StreamError, StreamResult};
+use tokio::io::AsyncWrite;
+use wasmtime_wasi::cli::{IsTerminal, StdoutStream};
+use wasmtime_wasi::p2::{OutputStream, Pollable, StreamError, StreamResult};
 
 /// A buffer that limits the number of bytes that can be written to it.
 /// If the buffer is full, it will truncate the data.
@@ -14,6 +16,31 @@ pub struct OutputLimitedBuffer {
     inner: Arc<Mutex<OutputLimitedBufferInner>>,
 }
 
+// No support for WASI P3, yet.
+impl AsyncWrite for OutputLimitedBuffer {
+    fn poll_write(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+        _buf: &[u8],
+    ) -> std::task::Poll<Result<usize, std::io::Error>> {
+        std::task::Poll::Ready(Ok(0))
+    }
+
+    fn poll_flush(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), std::io::Error>> {
+        std::task::Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), std::io::Error>> {
+        std::task::Poll::Ready(Ok(()))
+    }
+}
+
 impl OutputLimitedBuffer {
     /// Creates a new [OutputLimitedBuffer] with the given underlying buffer
     /// and capacity.
@@ -33,12 +60,19 @@ impl Clone for OutputLimitedBuffer {
 }
 
 impl StdoutStream for OutputLimitedBuffer {
-    fn stream(&self) -> Box<dyn OutputStream> {
+    fn p2_stream(&self) -> Box<dyn OutputStream> {
+        let cloned = self.clone();
+        Box::new(cloned)
+    }
+
+    fn async_stream(&self) -> Box<dyn AsyncWrite + Send + Sync> {
         let cloned = self.clone();
         Box::new(cloned)
     }
+}
 
-    fn isatty(&self) -> bool {
+impl IsTerminal for OutputLimitedBuffer {
+    fn is_terminal(&self) -> bool {
         false
     }
 }

ext/src/helpers/output_limited_buffer.rs

@@ -93,6 +93,9 @@ pub(crate) fn component_val_to_rb(val: Val, _store: &StoreContextValue) -> Resul
         }
         Val::Flags(vec) => Ok(vec.into_value()),
         Val::Resource(_resource_any) => not_implemented!("Resource not implemented"),
+        Val::Future(_) => not_implemented!("Future not implemented"),
+        Val::ErrorContext(_) => not_implemented!("ErrorContext not implemented"),
+        Val::Stream(_) => not_implemented!("Stream not implemented"),
     }
 }
 
@@ -280,6 +283,9 @@ pub(crate) fn rb_to_component_val(
         Type::Flags(_) => Vec::<String>::try_convert(value).map(Val::Flags),
         Type::Own(_resource_type) => not_implemented!("Resource not implemented"),
         Type::Borrow(_resource_type) => not_implemented!("Resource not implemented"),
+        Type::Future(_) => not_implemented!("Future not implemented"),
+        Type::Stream(_) => not_implemented!("Stream not implemented"),
+        Type::ErrorContext => not_implemented!("ErrorContext not implemented"),
     }
 }
 

ext/src/ruby_api/component/convert.rs

@@ -18,10 +18,7 @@ use magnus::{
     DataTypeFunctions, Error, Module as _, Object, RModule, Ruby, TryConvert, TypedData, Value,
 };
 use wasmtime::component::{Linker as LinkerImpl, LinkerInstance as LinkerInstanceImpl};
-use wasmtime_wasi::{
-    p2::{IoView, WasiCtx, WasiView},
-    ResourceTable,
-};
+use wasmtime_wasi::{ResourceTable, WasiCtx};
 
 /// @yard
 /// @rename Wasmtime::Component::Linker

ext/src/ruby_api/component/linker.rs

@@ -19,9 +19,9 @@ use wasmtime::{
     AsContext, AsContextMut, ResourceLimiter, Store as StoreImpl, StoreContext, StoreContextMut,
     StoreLimits, StoreLimitsBuilder,
 };
-use wasmtime_wasi::p2::{IoView, WasiCtx, WasiView};
 use wasmtime_wasi::preview1::WasiP1Ctx;
 use wasmtime_wasi::{I32Exit, ResourceTable};
+use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView};
 
 define_rb_intern!(
     WASI_CONFIG => "wasi_config",
@@ -513,15 +513,13 @@ impl ResourceLimiter for TrackingResourceLimiter {
 }
 
 impl WasiView for StoreData {
-    fn ctx(&mut self) -> &mut WasiCtx {
-        self.wasi
+    fn ctx(&mut self) -> WasiCtxView<'_> {
+        let ctx = self
+            .wasi
             .as_mut()
-            .expect("Should have WASI context defined if using WASI p2")
-    }
-}
+            .expect("Should have WASI context defined if using WASI p2");
+        let table = &mut self.resource_table;
 
-impl IoView for StoreData {
-    fn table(&mut self) -> &mut ResourceTable {
-        &mut self.resource_table
+        WasiCtxView { ctx, table }
     }
 }

ext/src/ruby_api/store.rs

@@ -14,10 +14,10 @@ use std::convert::TryFrom;
 use std::fs;
 use std::path::Path;
 use std::{fs::File, path::PathBuf};
+use wasmtime_wasi::cli::OutputFile;
 use wasmtime_wasi::p2::pipe::MemoryInputPipe;
-use wasmtime_wasi::p2::{OutputFile, WasiCtx, WasiCtxBuilder};
 use wasmtime_wasi::preview1::WasiP1Ctx;
-use wasmtime_wasi::{DirPerms, FilePerms};
+use wasmtime_wasi::{DirPerms, FilePerms, WasiCtx, WasiCtxBuilder};
 
 define_rb_intern!(
     READ => "read",

ext/src/ruby_api/wasi_config.rs

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wasmtime
-  VERSION = "34.0.0"
+  VERSION = "36.0.0"
 end