feat: updating wasmtime to 36.0.0

ruslanti · ruslanti · commit 69688913058b · 2025-09-11T10:17:00.000+03:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -13,14 +13,15 @@ tokio = { version = "1", features = ["full"] }
 tokio-util = { version = "0.7", features = ["codec"] }
 tracing = "0.1"
 hyper = { version = "1", features = ["full"] }
-http = "1.3.1"
+http = "1.3"
 async-trait = "0.1"
-wasmtime = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-31.0.0"}
-wasmtime-wasi = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-31.0.0"}
-wasi-common = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-31.0.0"}
-wasmtime-wasi-nn = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-31.0.0", features = ["openvino", "candle"] }
-wasmtime-wasi-http = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-31.0.0"}
-wasmtime-environ = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-31.0.0"}
+wasmtime = { git = "https://github.com/G-Core/wasmtime.git", features = ["component-model"], branch = "release-36.0.0"}
+wasmtime-wasi = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-36.0.0"}
+wasmtime-wasi-io = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-36.0.0"}
+wasi-common = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-36.0.0"}
+wasmtime-wasi-nn = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-36.0.0", features = ["openvino", "candle"] }
+wasmtime-wasi-http = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-36.0.0"}
+wasmtime-environ = { git = "https://github.com/G-Core/wasmtime.git", branch = "release-36.0.0"}
 bytesize = "2.0.1"
 
 clap = { version = "4", features = ["derive"] }
@@ -46,7 +47,7 @@ authors.workspace = true
 
 
 [dev-dependencies]
-tempfile = "3.20.0"
+tempfile = "3.22"
 
 [dependencies]
 anyhow = { workspace = true }
diff --git a/crates/http-backend/Cargo.toml b/crates/http-backend/Cargo.toml
@@ -13,11 +13,10 @@ anyhow = {workspace = true}
 tracing = {workspace = true}
 hyper = { workspace = true }
 tokio = { workspace = true }
-hyper-util = { version = "0.1.10", features = ["client", "client-legacy", "http1", "tokio"] }
-http-body-util = "0.1.3"
-pin-project = "1.1.10"
-tower-service = "0.3.3"
-smol_str = {workspace = true}
+hyper-util = { version = "0.1", features = ["client", "client-legacy", "http1", "tokio"] }
+http-body-util = "0.1"
+pin-project = "1.1"
+tower-service = "0.3"
 
 [dev-dependencies]
 claims = "0.8"
diff --git a/crates/http-service/src/executor/http.rs b/crates/http-service/src/executor/http.rs
@@ -11,12 +11,11 @@ use hyper::body::Body;
 use reactor::gcore::fastedge;
 use runtime::{store::StoreBuilder, InstancePre};
 use std::time::{Duration, Instant};
-use wasmtime_wasi::StdoutStream;
 use wasmtime_wasi_http::body::HyperOutgoingBody;
 
 /// Execute context used by ['HttpService']
 #[derive(Clone)]
-pub struct HttpExecutorImpl<C> {
+pub struct HttpExecutorImpl<C: 'static> {
     instance_pre: InstancePre<HttpState<C>>,
     store_builder: StoreBuilder,
     backend: Backend<C>,
@@ -95,9 +94,9 @@ where
         let mut store = store_builder.build(state)?;
 
         let instance = self.instance_pre.instantiate_async(&mut store).await?;
-        let http_handler = instance.get_export(&mut store, None, "gcore:fastedge/http-handler");
+        let http_handler = instance.get_export_index(&mut store, None, "gcore:fastedge/http-handler");
         let process = instance
-            .get_export(&mut store, http_handler.as_ref(), "process")
+            .get_export_index(&mut store, http_handler.as_ref(), "process")
             .ok_or_else(|| anyhow!("gcore:fastedge/http-handler instance not found"))?;
         let func = instance
             .get_typed_func::<(fastedge::http::Request,), (fastedge::http::Response,)>(
@@ -111,9 +110,7 @@ where
             Err(error) => {
                 // log to application logger  error
                 if let Some(ref logger) = store.data().logger {
-                    if let Err(e) = logger.stream().write(error.to_string().into()) {
-                        tracing::debug!(cause=?e, "write error: {}", error)
-                    }
+                    logger.write_msg(format!("Execution error: {}", error)).await;
                 }
                 return Err(error);
             }
diff --git a/crates/http-service/src/executor/wasi_http.rs b/crates/http-service/src/executor/wasi_http.rs
@@ -17,7 +17,7 @@ use wasmtime_wasi_http::{body::HyperOutgoingBody, WasiHttpView};
 
 /// Execute context used by ['HttpService']
 #[derive(Clone)]
-pub struct WasiHttpExecutorImpl<C> {
+pub struct WasiHttpExecutorImpl<C: 'static> {
     instance_pre: InstancePre<HttpState<C>>,
     store_builder: StoreBuilder,
     backend: Backend<C>,
diff --git a/crates/http-service/src/lib.rs b/crates/http-service/src/lib.rs
@@ -1,3 +1,4 @@
+use wasmtime::component::HasSelf;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
@@ -181,25 +182,26 @@ where
     fn configure_engine(builder: &mut WasmEngineBuilder<Self::State>) -> Result<()> {
         let linker = builder.component_linker_ref();
         // Allow re-importing of `wasi:clocks/wall-clock@0.2.0`
-        wasmtime_wasi::add_to_linker_async(linker)?;
+        wasmtime_wasi::p2::add_to_linker_async(linker)?;
         linker.allow_shadowing(true);
         wasmtime_wasi_http::add_to_linker_async(linker)?;
 
         wasmtime_wasi_nn::wit::add_to_linker(linker, |data: &mut runtime::Data<Self::State>| {
             WasiNnView::new(&mut data.table, &mut data.wasi_nn)
         })?;
 
-        reactor::gcore::fastedge::http_client::add_to_linker(linker, |data| {
-            &mut data.as_mut().http_backend
-        })?;
+        reactor::gcore::fastedge::http_client::add_to_linker::<_, HasSelf<_>>(
+            linker,
+            |data| &mut data.as_mut().http_backend,
+        )?;
 
-        reactor::gcore::fastedge::dictionary::add_to_linker(linker, |data| {
+        reactor::gcore::fastedge::dictionary::add_to_linker::<_, HasSelf<_>>(linker, |data| {
             &mut data.as_mut().dictionary
         })?;
 
-        reactor::gcore::fastedge::secret::add_to_linker(linker, |data| &mut data.secret_store)?;
+        reactor::gcore::fastedge::secret::add_to_linker::<_, HasSelf<_>>(linker, |data| &mut data.secret_store)?;
 
-        reactor::gcore::fastedge::key_value::add_to_linker(linker, |data| {
+        reactor::gcore::fastedge::key_value::add_to_linker::<_, HasSelf<_>>(linker, |data| {
             &mut data.key_value_store
         })?;
 
diff --git a/crates/key-value-store/Cargo.toml b/crates/key-value-store/Cargo.toml
@@ -10,7 +10,7 @@ description = "key-value store host function"
 reactor = { path = "../reactor" }
 wasmtime = {workspace = true}
 slab = "0.4"
-async-trait = "0.1.88"
+async-trait = "0.1"
 smol_str = {workspace = true}
 
 [lints]
diff --git a/crates/reactor/src/lib.rs b/crates/reactor/src/lib.rs
@@ -3,6 +3,5 @@
 wasmtime::component::bindgen!({
     path: "../../sdk/wit",
     world: "reactor",
-    async: true,
-    tracing: false,
+    imports: { default: async },
 });
diff --git a/crates/runtime/Cargo.toml b/crates/runtime/Cargo.toml
@@ -13,13 +13,15 @@ stats = ["clickhouse"]
 
 [dependencies]
 anyhow = { workspace = true }
+tokio = { workspace = true }
 tokio-util = { workspace = true }
 wasmtime = { workspace = true }
 wasmtime-wasi = { workspace = true }
 wasi-common = { workspace = true }
 wasmtime-wasi-nn = { workspace = true }
 wasmtime-wasi-http = { workspace = true }
 wasmtime-environ = { workspace = true }
+wasmtime-wasi-io = { workspace = true }
 smol_str = { workspace = true }
 moka = { workspace = true }
 http = {workspace = true}
diff --git a/crates/runtime/src/lib.rs b/crates/runtime/src/lib.rs
@@ -1,9 +1,10 @@
 use crate::app::KvStoreOption;
 use key_value_store::KeyValueStore;
 use std::{fmt::Debug, ops::Deref};
-use wasmtime::component::ResourceTable;
-use wasmtime_wasi::IoView;
+use wasmtime_wasi::ResourceTable;
+use wasmtime_wasi::WasiCtxView;
 use wasmtime_wasi_http::{HttpResult, WasiHttpCtx, WasiHttpView};
+use wasmtime_wasi_io::IoView;
 
 use crate::store::StoreBuilder;
 use http_backend::Backend;
@@ -78,7 +79,7 @@ pub enum Wasi {
 }
 
 /// Host state data associated with individual [Store]s and [Instance]s.
-pub struct Data<T> {
+pub struct Data<T: 'static> {
     inner: T,
     wasi: Wasi,
     pub wasi_nn: WasiNnCtx,
@@ -141,6 +142,10 @@ impl<T: Send + BackendRequest> WasiHttpView for Data<T> {
             },
         ))
     }
+
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
 }
 
 impl<T> Data<T> {
@@ -191,12 +196,15 @@ impl AsRef<wasmtime::Config> for WasmConfig {
 }
 
 impl<T: Send> wasmtime_wasi::WasiView for Data<T> {
-    fn ctx(&mut self) -> &mut wasmtime_wasi::WasiCtx {
+    fn ctx(&mut self) -> WasiCtxView<'_> {
         match &mut self.wasi {
             Wasi::Preview1(_) => {
                 unreachable!("using WASI Preview 1 functions with Preview 2 store")
             }
-            Wasi::Preview2(ctx) => ctx,
+            Wasi::Preview2(ctx) => WasiCtxView {
+                ctx,
+                table: &mut self.table,
+            },
         }
     }
 }
@@ -302,7 +310,7 @@ pub type ComponentLinker<T> = wasmtime::component::Linker<Data<T>>;
 pub type ModuleLinker<T> = wasmtime::Linker<Data<T>>;
 
 /// An `WasmEngine` is a global context for the initialization and execution of WASM application.
-pub struct WasmEngine<T> {
+pub struct WasmEngine<T: 'static> {
     inner: Engine,
     component_linker: ComponentLinker<T>,
     module_linker: ModuleLinker<T>,
@@ -311,7 +319,7 @@ pub struct WasmEngine<T> {
 /// A builder interface for configuring a new [`WasmEngine`].
 ///
 /// A new [`WasmEngineBuilder`] can be obtained with [`WasmEngine::builder`].
-pub struct WasmEngineBuilder<T> {
+pub struct WasmEngineBuilder<T: 'static> {
     engine: Engine,
     component_linker: ComponentLinker<T>,
     module_linker: ModuleLinker<T>,
@@ -385,7 +393,7 @@ pub trait PreCompiledLoader<K> {
 }
 
 pub trait ContextT {
-    type BackendConnector;
+    type BackendConnector:  'static;
 
     fn make_logger(&self, app_name: SmolStr, wrk: &App) -> Logger;
 
diff --git a/crates/runtime/src/logger.rs b/crates/runtime/src/logger.rs
@@ -1,13 +1,18 @@
+use wasmtime_wasi_io::streams::StreamResult;
 use std::any::Any;
 use std::collections::HashMap;
 use std::io::IoSlice;
+use std::pin::Pin;
 use std::sync::Arc;
-
+use std::task::{Context, Poll};
 use async_trait::async_trait;
 use bytes::Bytes;
+use tokio::io::{AsyncWrite, AsyncWriteExt};
 use wasi_common::file::{FdFlags, FileType};
 use wasi_common::{Error, WasiFile};
-use wasmtime_wasi::{OutputStream, Pollable, StdoutStream, StreamResult};
+use wasmtime_wasi::cli::{IsTerminal, StdoutStream};
+use wasmtime_wasi_io::poll::Pollable;
+use wasmtime_wasi_io::streams::OutputStream;
 
 #[derive(Clone)]
 pub struct Logger {
@@ -16,18 +21,20 @@ pub struct Logger {
 }
 
 pub trait AppenderBuilder {
-    fn build(&self, properties: HashMap<String, String>) -> Box<dyn OutputStream>;
+    fn build(&self, properties: HashMap<String, String>) -> Box<dyn AsyncWrite + Send + Sync>;
+}
+
+impl IsTerminal for Logger {
+    fn is_terminal(&self) -> bool {
+        false
+    }
 }
 
 #[async_trait]
 impl StdoutStream for Logger {
-    fn stream(&self) -> Box<dyn OutputStream> {
+    fn async_stream(&self) -> Box<dyn AsyncWrite + Send + Sync> {
         self.appender.build(self.properties.clone())
     }
-
-    fn isatty(&self) -> bool {
-        false
-    }
 }
 
 impl Logger {
@@ -37,6 +44,12 @@ impl Logger {
             appender: Arc::new(sink),
         }
     }
+
+    pub async fn write_msg(&self, msg: String) {
+        if let Err(error) = Box::into_pin(self.async_stream()).write_all(msg.as_bytes()).await {
+            tracing::warn!(cause=?error, "write_msg");
+        }
+    }
 }
 
 impl Extend<(String, String)> for Logger {
@@ -48,7 +61,7 @@ impl Extend<(String, String)> for Logger {
 pub struct NullAppender;
 
 impl AppenderBuilder for NullAppender {
-    fn build(&self, _fields: HashMap<String, String>) -> Box<dyn OutputStream> {
+    fn build(&self, _fields: HashMap<String, String>) -> Box<dyn AsyncWrite + Send + Sync> {
         Box::new(NullAppender)
     }
 }
@@ -58,6 +71,25 @@ impl Pollable for NullAppender {
     async fn ready(&mut self) {}
 }
 
+impl AsyncWrite for NullAppender {
+    fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize, std::io::Error>> {
+        if cfg!(debug_assertions) {
+            Pin::new(&mut tokio::io::stdout()).poll_write(cx, buf)
+        } else {
+            // null write
+            Poll::Ready(Ok(buf.len()))
+        }
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), std::io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), std::io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
 impl OutputStream for NullAppender {
     fn write(&mut self, bytes: Bytes) -> StreamResult<()> {
         if cfg!(debug_assertions) {
@@ -106,17 +138,18 @@ impl WasiFile for NullAppender {
 }
 
 pub struct Console {
+    stdout: tokio::io::Stdout,
     limit: usize,
 }
 
 impl Default for Console {
     fn default() -> Self {
-        Self { limit: 10000 }
+        Self { stdout: tokio::io::stdout(), limit: 10000 }
     }
 }
 
 impl AppenderBuilder for Console {
-    fn build(&self, _fields: HashMap<String, String>) -> Box<dyn OutputStream> {
+    fn build(&self, _fields: HashMap<String, String>) -> Box<dyn AsyncWrite + Send + Sync> {
         Box::new(Console::default())
     }
 }
@@ -126,6 +159,20 @@ impl Pollable for Console {
     async fn ready(&mut self) {}
 }
 
+impl AsyncWrite for Console {
+    fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize, std::io::Error>> {
+        Pin::new(&mut self.stdout).poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), std::io::Error>> {
+        Pin::new(&mut self.stdout).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), std::io::Error>> {
+        Pin::new(&mut self.stdout).poll_shutdown(cx)
+    }
+}
+
 impl OutputStream for Console {
     fn write(&mut self, bytes: Bytes) -> StreamResult<()> {
         if self.limit > 0 {
diff --git a/crates/runtime/src/service.rs b/crates/runtime/src/service.rs
@@ -30,7 +30,7 @@ impl<C, S: Service<Context = C>> ServiceBuilder<C, S>
 where
     C: ContextT,
     S: Service<Context = C>,
-    <S as Service>::State: Send + Sync,
+    <S as Service>::State: Send + Sync + 'static,
 {
     /// Create a new ServiceBuilder.
     pub fn new(context: C) -> Self {
diff --git a/crates/runtime/src/store.rs b/crates/runtime/src/store.rs
