Add pseudo-streams.

Cargo.toml

@@ -15,8 +15,9 @@ edition = "2021"
 anyhow = "1.0.22"
 thiserror = "1.0.15"
 tracing = "0.1.26"
-cap-std = "1.0.0"
-cap-rand = "1.0.0"
+cap-std = "1.0.2"
+cap-rand = "1.0.2"
+cap-fs-ext = "1.0.2"
 bitflags = "1.2"
 windows-sys = "0.42.0"
 rustix = "0.36.0"

host/Cargo.toml

@@ -14,6 +14,8 @@ tracing = { workspace = true }
 wasmtime = { git = "https://github.com/bytecodealliance/wasmtime", features = ["component-model"] }
 wasi-common = { path = "../wasi-common" }
 wasi-cap-std-sync = { path = "../wasi-common/cap-std-sync" }
+is-terminal = "0.4.1"
+terminal_size = "0.2.3"
 
 [dev-dependencies]
 test-programs-macros = { path = "../test-programs/macros" }

host/src/clocks.rs

@@ -1,7 +1,6 @@
 use crate::{wasi_clocks, wasi_default_clocks, WasiCtx};
-use anyhow::Context;
 use cap_std::time::SystemTime;
-use wasi_common::clocks::{MonotonicClock, MonotonicTimer, WallClock};
+use wasi_common::clocks::{TableMonotonicClockExt, TableWallClockExt};
 
 impl TryFrom<SystemTime> for wasi_clocks::Datetime {
     type Error = anyhow::Error;
@@ -19,102 +18,56 @@ impl TryFrom<SystemTime> for wasi_clocks::Datetime {
 
 #[async_trait::async_trait]
 impl wasi_default_clocks::WasiDefaultClocks for WasiCtx {
-    async fn default_monotonic_clock(&mut self) -> anyhow::Result<wasi_clocks::MonotonicClock> {
-        Ok(self.clocks.default_monotonic)
+    async fn default_wall_clock(&mut self) -> anyhow::Result<wasi_clocks::WallClock> {
+        // Create a new handle to the default wall clock.
+        let new = self.clocks.default_wall_clock.dup();
+        Ok(self.table_mut().push(Box::new(new))?)
     }
 
-    async fn default_wall_clock(&mut self) -> anyhow::Result<wasi_clocks::WallClock> {
-        Ok(self.clocks.default_wall)
+    async fn default_monotonic_clock(&mut self) -> anyhow::Result<wasi_clocks::MonotonicClock> {
+        // Create a new handle to the default monotonic clock.
+        let new = self.clocks.default_monotonic_clock.dup();
+        Ok(self.table_mut().push(Box::new(new))?)
     }
 }
 
 #[async_trait::async_trait]
 impl wasi_clocks::WasiClocks for WasiCtx {
-    async fn subscribe_wall_clock(
-        &mut self,
-        when: wasi_clocks::Datetime,
-        absolute: bool,
-    ) -> anyhow::Result<wasi_clocks::WasiFuture> {
-        drop((when, absolute));
-        todo!()
-    }
-
-    async fn subscribe_monotonic_clock(
-        &mut self,
-        when: wasi_clocks::Instant,
-        absolute: bool,
-    ) -> anyhow::Result<wasi_clocks::WasiFuture> {
-        drop((when, absolute));
-        todo!()
-    }
-
     async fn monotonic_clock_now(
         &mut self,
         fd: wasi_clocks::MonotonicClock,
     ) -> anyhow::Result<wasi_clocks::Instant> {
-        let clock = self.table.get::<MonotonicClock>(fd)?;
-        let now = clock.now(self.clocks.monotonic.as_ref());
-        Ok(now
-            .as_nanos()
-            .try_into()
-            .context("converting monotonic time to nanos u64")?)
+        Ok(self.table().get_monotonic_clock(fd)?.now())
     }
 
     async fn monotonic_clock_resolution(
         &mut self,
         fd: wasi_clocks::MonotonicClock,
     ) -> anyhow::Result<wasi_clocks::Instant> {
-        self.table.get::<MonotonicClock>(fd)?;
-        let res = self.clocks.monotonic.resolution();
-        Ok(res
-            .as_nanos()
-            .try_into()
-            .context("converting monotonic resolution to nanos u64")?)
-    }
-
-    async fn monotonic_clock_new_timer(
-        &mut self,
-        fd: wasi_clocks::MonotonicClock,
-        initial: wasi_clocks::Instant,
-    ) -> anyhow::Result<wasi_clocks::MonotonicTimer> {
-        let clock = self.table.get::<MonotonicClock>(fd)?;
-        let timer = clock.new_timer(std::time::Duration::from_micros(initial));
-        drop(clock);
-        let timer_fd = self.table.push(Box::new(timer))?;
-        Ok(timer_fd)
+        Ok(self.table().get_monotonic_clock(fd)?.now())
     }
 
     async fn wall_clock_now(
         &mut self,
         fd: wasi_clocks::WallClock,
     ) -> anyhow::Result<wasi_clocks::Datetime> {
-        let clock = self.table.get::<WallClock>(fd)?;
-        Ok(clock.now(self.clocks.system.as_ref()).try_into()?)
+        let clock = self.table().get_wall_clock(fd)?;
+        let now = clock.now();
+        Ok(wasi_clocks::Datetime {
+            seconds: now.as_secs(),
+            nanoseconds: now.subsec_nanos(),
+        })
     }
 
     async fn wall_clock_resolution(
         &mut self,
         fd: wasi_clocks::WallClock,
     ) -> anyhow::Result<wasi_clocks::Datetime> {
-        self.table.get::<WallClock>(fd)?;
-        let nanos = self.clocks.system.resolution().as_nanos();
+        let clock = self.table().get_wall_clock(fd)?;
+        let res = clock.resolution();
         Ok(wasi_clocks::Datetime {
-            seconds: (nanos / 1_000_000_000_u128)
-                .try_into()
-                .context("converting wall clock resolution to seconds u64")?,
-            nanoseconds: (nanos % 1_000_000_000_u128).try_into().unwrap(),
+            seconds: res.as_secs(),
+            nanoseconds: res.subsec_nanos(),
         })
     }
-
-    async fn monotonic_timer_current(
-        &mut self,
-        fd: wasi_clocks::MonotonicTimer,
-    ) -> anyhow::Result<wasi_clocks::Instant> {
-        let timer = self.table.get::<MonotonicTimer>(fd)?;
-        Ok(timer
-            .current(self.clocks.monotonic.as_ref())
-            .as_nanos()
-            .try_into()
-            .context("converting monotonic timer to nanos u64")?)
-    }
 }