feat: begin wasip3 implementation

Signed-off-by: Roman Volosatovs <[email protected]>

Author: rvolosatovs

crates/test-programs/artifacts/build.rs

@@ -78,6 +78,7 @@ impl Artifacts {
                 s if s.starts_with("config_") => "config",
                 s if s.starts_with("keyvalue_") => "keyvalue",
                 s if s.starts_with("tls_") => "tls",
+                s if s.starts_with("p3_") => "p3",
                 // If you're reading this because you hit this panic, either add
                 // it to a test suite above or add a new "suite". The purpose of
                 // the categorization above is to have a static assertion that
@@ -100,6 +101,7 @@ impl Artifacts {
             }
             let adapter = match test.name.as_str() {
                 "reactor" => &reactor_adapter,
+                s if s.starts_with("p3_") => &reactor_adapter,
                 s if s.starts_with("api_proxy") => &proxy_adapter,
                 _ => &command_adapter,
             };

crates/test-programs/src/bin/p3_clocks_sleep.rs

@@ -0,0 +1,51 @@
+use core::future::Future as _;
+use core::pin::pin;
+use core::task::{Context, Poll, Waker};
+
+use test_programs::p3::wasi::clocks::monotonic_clock;
+
+struct Component;
+
+test_programs::p3::export!(Component);
+
+impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
+    async fn run() -> Result<(), ()> {
+        sleep_10ms().await;
+        sleep_0ms();
+        sleep_backwards_in_time();
+        Ok(())
+    }
+}
+
+async fn sleep_10ms() {
+    let dur = 10_000_000;
+    monotonic_clock::wait_until(monotonic_clock::now() + dur).await;
+    monotonic_clock::wait_for(dur).await;
+}
+
+fn sleep_0ms() {
+    let mut cx = Context::from_waker(Waker::noop());
+
+    assert_eq!(
+        pin!(monotonic_clock::wait_until(monotonic_clock::now())).poll(&mut cx),
+        Poll::Ready(()),
+        "waiting until now() is ready immediately",
+    );
+    assert_eq!(
+        pin!(monotonic_clock::wait_for(0)).poll(&mut cx),
+        Poll::Ready(()),
+        "waiting for 0 is ready immediately",
+    );
+}
+
+fn sleep_backwards_in_time() {
+    let mut cx = Context::from_waker(Waker::noop());
+
+    assert_eq!(
+        pin!(monotonic_clock::wait_until(monotonic_clock::now() - 1)).poll(&mut cx),
+        Poll::Ready(()),
+        "waiting until instant which has passed is ready immediately",
+    );
+}
+
+fn main() {}

crates/test-programs/src/bin/p3_random_imports.rs

@@ -0,0 +1,51 @@
+use test_programs::p3::wasi::random;
+
+struct Component;
+
+test_programs::p3::export!(Component);
+
+impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
+    async fn run() -> Result<(), ()> {
+        let mut bytes = [0_u8; 256];
+        unsafe {
+            wasip1::random_get(bytes.as_mut_ptr(), bytes.len()).unwrap();
+        }
+
+        assert!(bytes.iter().any(|x| *x != 0));
+
+        // Acquired random bytes should be of the expected length.
+        let array = random::random::get_random_bytes(100);
+        assert_eq!(array.len(), 100);
+
+        // It shouldn't take 100+ tries to get a nonzero random integer.
+        for i in 0.. {
+            if random::random::get_random_u64() == 0 {
+                continue;
+            }
+            assert!(i < 100);
+            break;
+        }
+
+        // The `insecure_seed` API should return the same result each time.
+        let (a1, b1) = random::insecure_seed::insecure_seed();
+        let (a2, b2) = random::insecure_seed::insecure_seed();
+        assert_eq!(a1, a2);
+        assert_eq!(b1, b2);
+
+        // Acquired random bytes should be of the expected length.
+        let array = random::insecure::get_insecure_random_bytes(100);
+        assert_eq!(array.len(), 100);
+
+        // It shouldn't take 100+ tries to get a nonzero random integer.
+        for i in 0.. {
+            if random::insecure::get_insecure_random_u64() == 0 {
+                continue;
+            }
+            assert!(i < 100);
+            break;
+        }
+        Ok(())
+    }
+}
+
+fn main() {}

crates/test-programs/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod http;
 pub mod nn;
+pub mod p3;
 pub mod preview1;
 pub mod sockets;
 pub mod tls;

crates/test-programs/src/p3/mod.rs

@@ -0,0 +1,19 @@
+wit_bindgen::generate!({
+    inline: "
+        package wasmtime:test;
+
+        world testp3 {
+            include wasi:cli/[email protected];
+
+            export wasi:cli/[email protected];
+        }
+    ",
+    path: "../wasi/src/p3/wit",
+    world: "wasmtime:test/testp3",
+    default_bindings_module: "test_programs::p3",
+    pub_export_macro: true,
+    async: [
+        "wasi:cli/[email protected]#run",
+    ],
+    generate_all
+});

crates/wasi/Cargo.toml

@@ -55,10 +55,13 @@ windows-sys = { workspace = true }
 rustix = { workspace = true, features = ["event", "net"] }
 
 [features]
-default = [ "preview1"]
+default = ["preview1"]
 preview1 = [
     "dep:wiggle",
 ]
+p3 = [
+    "wasmtime/component-model-async",
+]
 
 [[test]]
 name = "process_stdin"

crates/wasi/src/clocks.rs

@@ -1,5 +1,45 @@
-pub mod host;
-use cap_std::time::Duration;
+use cap_std::time::{Duration, Instant, SystemClock};
+use cap_std::{AmbientAuthority, ambient_authority};
+use cap_time_ext::{MonotonicClockExt as _, SystemClockExt as _};
+
+#[repr(transparent)]
+pub struct WasiClocksImpl<T>(pub T);
+
+impl<T: WasiClocksView> WasiClocksView for &mut T {
+    fn clocks(&mut self) -> &WasiClocksCtx {
+        (**self).clocks()
+    }
+}
+
+impl<T: WasiClocksView> WasiClocksView for WasiClocksImpl<T> {
+    fn clocks(&mut self) -> &WasiClocksCtx {
+        self.0.clocks()
+    }
+}
+
+impl WasiClocksView for WasiClocksCtx {
+    fn clocks(&mut self) -> &WasiClocksCtx {
+        self
+    }
+}
+
+pub trait WasiClocksView: Send {
+    fn clocks(&mut self) -> &WasiClocksCtx;
+}
+
+pub struct WasiClocksCtx {
+    pub wall_clock: Box<dyn HostWallClock + Send>,
+    pub monotonic_clock: Box<dyn HostMonotonicClock + Send>,
+}
+
+impl Default for WasiClocksCtx {
+    fn default() -> Self {
+        Self {
+            wall_clock: wall_clock(),
+            monotonic_clock: monotonic_clock(),
+        }
+    }
+}
 
 pub trait HostWallClock: Send {
     fn resolution(&self) -> Duration;
@@ -10,3 +50,84 @@ pub trait HostMonotonicClock: Send {
     fn resolution(&self) -> u64;
     fn now(&self) -> u64;
 }
+
+pub struct WallClock {
+    /// The underlying system clock.
+    clock: cap_std::time::SystemClock,
+}
+
+impl Default for WallClock {
+    fn default() -> Self {
+        Self::new(ambient_authority())
+    }
+}
+
+impl WallClock {
+    pub fn new(ambient_authority: AmbientAuthority) -> Self {
+        Self {
+            clock: cap_std::time::SystemClock::new(ambient_authority),
+        }
+    }
+}
+
+impl HostWallClock for WallClock {
+    fn resolution(&self) -> Duration {
+        self.clock.resolution()
+    }
+
+    fn now(&self) -> Duration {
+        // WASI defines wall clocks to return "Unix time".
+        self.clock
+            .now()
+            .duration_since(SystemClock::UNIX_EPOCH)
+            .unwrap()
+    }
+}
+
+pub struct MonotonicClock {
+    /// The underlying system clock.
+    clock: cap_std::time::MonotonicClock,
+
+    /// The `Instant` this clock was created. All returned times are
+    /// durations since that time.
+    initial: Instant,
+}
+
+impl Default for MonotonicClock {
+    fn default() -> Self {
+        Self::new(ambient_authority())
+    }
+}
+
+impl MonotonicClock {
+    pub fn new(ambient_authority: AmbientAuthority) -> Self {
+        let clock = cap_std::time::MonotonicClock::new(ambient_authority);
+        let initial = clock.now();
+        Self { clock, initial }
+    }
+}
+
+impl HostMonotonicClock for MonotonicClock {
+    fn resolution(&self) -> u64 {
+        self.clock.resolution().as_nanos().try_into().unwrap()
+    }
+
+    fn now(&self) -> u64 {
+        // Unwrap here and in `resolution` above; a `u64` is wide enough to
+        // hold over 584 years of nanoseconds.
+        self.clock
+            .now()
+            .duration_since(self.initial)
+            .as_nanos()
+            .try_into()
+            .unwrap()
+    }
+}
+
+pub fn monotonic_clock() -> Box<dyn HostMonotonicClock + Send> {
+    Box::new(MonotonicClock::default())
+}
+
+pub fn wall_clock() -> Box<dyn HostWallClock + Send> {
+    Box::new(WallClock::default())
+}