Add WASI support by tokio_wasi

Cargo.toml

@@ -12,22 +12,29 @@ repository = "https://github.com/futursolo/prokio"
 rust-version = "1.60.0"
 
 [dependencies]
-futures = { version = "0.3", default-features = false, features = ["std", "async-await"] }
+futures = { version = "0.3", default-features = false, features = [
+  "std",
+  "async-await",
+] }
 pin-project = "1.0.11"
 pinned = "0.1.0"
+once_cell = "1"
+
+[target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies]
+wasm-bindgen-futures = { version = "0.4" }
+gloo = { version = "0.10" }
 
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-wasm-bindgen-futures = "0.4"
-gloo = "0.8"
+[target.'cfg(target_os = "wasi")'.dependencies]
+tokio_wasi = { version = "1", features = ["rt", "time"] }
+tokio-stream_wasi = { version = "0.1", features = ["time"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 num_cpus = "1.13"
-once_cell = "1"
-tokio = { version = "1.21.1", features = ["rt", "time"] }
+tokio = { version = "1", features = ["rt", "time"] }
 tokio-stream = { version = "0.1", features = ["time"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
-tokio = { version = "1.19", features = ["full"] }
+tokio = { version = "1", features = ["full"] }
 
 [features]
 default = []

src/lib.rs

@@ -56,9 +56,12 @@ pub mod fmt;
 pub mod pinned;
 pub mod time;
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
 #[path = "rt_wasm_bindgen/mod.rs"]
 mod imp;
+#[cfg(all(target_arch = "wasm32", target_os = "wasi"))]
+#[path = "rt_tokio_wasi/mod.rs"]
+mod imp;
 #[cfg(not(target_arch = "wasm32"))]
 #[path = "rt_tokio/mod.rs"]
 mod imp;

src/rt_tokio/mod.rs

@@ -14,7 +14,15 @@ use local_worker::LocalWorker;
 pub(crate) fn get_default_runtime_size() -> usize {
     // We use num_cpus as std::thread::available_parallelism() does not take
     // system resource constraint (e.g.: cgroups) into consideration.
-    num_cpus::get()
+    #[cfg(not(target_os = "wasi"))]
+    {
+        num_cpus::get()
+    }
+    // WASI does not support multi-threading at this moment.
+    #[cfg(target_os = "wasi")]
+    {
+        1
+    }
 }
 
 #[inline(always)]

src/rt_tokio_wasi/mod.rs

@@ -0,0 +1,71 @@
+use std::future::Future;
+use std::io;
+use std::marker::PhantomData;
+
+use once_cell::sync::Lazy;
+
+static RUNTIME: Lazy<tokio::runtime::Runtime> = Lazy::new(|| {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+});
+
+pub(crate) mod time;
+
+pub(crate) fn get_default_runtime_size() -> usize {
+    0
+}
+
+#[inline(always)]
+pub(super) fn spawn_local<F>(f: F)
+where
+    F: Future<Output = ()> + 'static,
+{
+    RUNTIME.block_on(async { f.await })
+}
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct Runtime {}
+
+impl Runtime {
+    pub fn new(_size: usize) -> io::Result<Self> {
+        Ok(Self {})
+    }
+
+    pub fn spawn_pinned<F, Fut>(&self, create_task: F)
+    where
+        F: FnOnce() -> Fut,
+        F: Send + 'static,
+        Fut: Future<Output = ()> + 'static,
+    {
+        RUNTIME.block_on(async { create_task().await })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct LocalHandle {
+    // This type is not send or sync.
+    _marker: PhantomData<*const ()>,
+}
+
+impl LocalHandle {
+    pub fn try_current() -> Option<Self> {
+        Some(Self {
+            _marker: PhantomData,
+        })
+    }
+
+    pub fn current() -> Self {
+        Self {
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn spawn_local<F>(&self, f: F)
+    where
+        F: Future<Output = ()> + 'static,
+    {
+        RUNTIME.block_on(async { f.await })
+    }
+}

src/rt_tokio_wasi/time.rs

@@ -0,0 +1,14 @@
+use std::future::Future;
+use std::time::Duration;
+
+use futures::stream::{Stream, StreamExt};
+use tokio_stream::wrappers::IntervalStream;
+
+#[inline(always)]
+pub(crate) fn sleep(dur: Duration) -> impl Future<Output = ()> {
+    tokio::time::sleep(dur)
+}
+
+pub(crate) fn interval(dur: Duration) -> impl Stream<Item = ()> {
+    IntervalStream::new(tokio::time::interval(dur)).then(|_| async {})
+}