Merge pull request #162 from bytecodealliance/abk/io-p3

Implement `io` module for WASIp3

Author: adamrk

examples/stdio.rs

@@ -0,0 +1,84 @@
+#![cfg_attr(not(target_os = "wasi"), no_main)]
+#![cfg(target_os = "wasi")]
+
+//! Demonstrates async line-oriented stdin, stdout, stderr, and flushing.
+
+use anyhow::Result;
+use wstd::io::{AsyncRead, AsyncWrite};
+
+struct LineReader<R> {
+    reader: R,
+    buffer: Vec<u8>,
+}
+
+impl<R: AsyncRead> LineReader<R> {
+    fn new(reader: R) -> Self {
+        Self {
+            reader,
+            buffer: Vec::new(),
+        }
+    }
+
+    async fn read_line(&mut self) -> std::io::Result<Option<Vec<u8>>> {
+        loop {
+            if let Some(newline) = self.buffer.iter().position(|byte| *byte == b'\n') {
+                return Ok(Some(self.buffer.drain(..=newline).collect()));
+            }
+
+            let mut chunk = [0; 1024];
+            match self.reader.read(&mut chunk).await? {
+                0 if self.buffer.is_empty() => return Ok(None),
+                0 => return Ok(Some(std::mem::take(&mut self.buffer))),
+                len => {
+                    self.buffer.extend_from_slice(&chunk[..len]);
+                }
+            }
+        }
+    }
+}
+
+#[wstd::main]
+async fn main() -> Result<()> {
+    let mut stdin = LineReader::new(wstd::io::stdin());
+    let mut stdout = wstd::io::stdout();
+    let mut stderr = wstd::io::stderr();
+
+    let mut stdin_error = None;
+    while let Some(line) = match stdin.read_line().await {
+        Ok(Some(line)) => Some(line),
+        Ok(None) => {
+            stdin_error = Some(std::io::ErrorKind::UnexpectedEof.into());
+            None
+        }
+        Err(error) => {
+            stdin_error = Some(error);
+            None
+        }
+    } {
+        stdout.write_all(b"stdout: ").await.unwrap();
+        stdout.write_all(&line).await.unwrap();
+        stdout.flush().await.unwrap();
+
+        stderr.write_all(b"stderr: ").await.unwrap();
+        stderr.write_all(&line).await.unwrap();
+        stderr.flush().await.unwrap();
+    }
+    let stdin_error = stdin_error.expect("the loop only exits after a stdin error");
+
+    let stdout_result = match stdout.write_all(b"stdin closed\n").await {
+        Ok(()) => stdout.flush().await,
+        Err(error) => Err(error),
+    };
+
+    stderr
+        .write_all(format!("stdin error: {:?}\n", stdin_error.kind()).as_bytes())
+        .await?;
+    if let Err(error) = stdout_result {
+        stderr
+            .write_all(format!("stdout error: {:?}\n", error.kind()).as_bytes())
+            .await?;
+    }
+    stderr.flush().await?;
+
+    Ok(())
+}

src/io/mod.rs

@@ -5,10 +5,36 @@ mod cursor;
 mod empty;
 mod read;
 mod seek;
-mod stdio;
-mod streams;
+
+mod streams {
+    mod sys {
+        #[cfg(target_env = "p2")]
+        pub(super) mod p2;
+        #[cfg(target_env = "p3")]
+        pub(super) mod p3;
+    }
+    #[cfg(target_env = "p2")]
+    pub use sys::p2::*;
+    #[cfg(target_env = "p3")]
+    pub use sys::p3::*;
+}
+
+mod stdio {
+    mod sys {
+        #[cfg(target_env = "p2")]
+        pub(super) mod p2;
+        #[cfg(target_env = "p3")]
+        pub(super) mod p3;
+    }
+    #[cfg(target_env = "p2")]
+    pub use sys::p2::*;
+    #[cfg(target_env = "p3")]
+    pub use sys::p3::*;
+}
+
 mod write;
 
+#[cfg(target_env = "p2")]
 pub use crate::runtime::AsyncPollable;
 pub use copy::*;
 pub use cursor::*;
@@ -26,3 +52,37 @@ pub use std::io::Error;
 /// A specialized Result type for I/O operations.
 ///
 pub use std::io::Result;
+
+#[cfg(test)]
+mod test {
+    use super::{AsyncWrite, stderr, stdout};
+    use crate::runtime::block_on;
+
+    #[test]
+    // No internal predicate. Run test with --nocapture and inspect output manually.
+    fn stdout_println_hello_world() {
+        block_on(async {
+            let mut stdout = stdout();
+            let term = if stdout.is_terminal() { "is" } else { "is not" };
+            stdout
+                .write_all(format!("hello, world! stdout {term} a terminal\n",).as_bytes())
+                .await
+                .unwrap();
+            stdout.flush().await.unwrap();
+        })
+    }
+
+    #[test]
+    // No internal predicate. Run test with --nocapture and inspect output manually.
+    fn stderr_println_hello_world() {
+        block_on(async {
+            let mut stderr = stderr();
+            let term = if stderr.is_terminal() { "is" } else { "is not" };
+            stderr
+                .write_all(format!("hello, world! stderr {term} a terminal\n",).as_bytes())
+                .await
+                .unwrap();
+            stderr.flush().await.unwrap();
+        })
+    }
+}

src/io/stdio.rs src/io/stdio/sys/p2.rssrc/io/stdio.rs renamed to src/io/stdio/sys/p2.rs

@@ -1,7 +1,7 @@
-use super::{AsyncInputStream, AsyncOutputStream, AsyncRead, AsyncWrite, Result};
+use crate::io::{AsyncInputStream, AsyncOutputStream, AsyncRead, AsyncWrite, Result};
 use std::cell::LazyCell;
-use wasip2::cli::terminal_input::TerminalInput;
-use wasip2::cli::terminal_output::TerminalOutput;
+
+use wasip2::cli::{terminal_input::TerminalInput, terminal_output::TerminalOutput};
 
 /// Use the program's stdin as an `AsyncInputStream`.
 #[derive(Debug)]
@@ -34,10 +34,10 @@ impl Stdin {
 impl AsyncRead for Stdin {
     #[inline]
     async fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        self.stream.read(buf).await
+        let read = self.stream.read(buf).await?;
+        Ok(read)
     }
 
-    #[inline]
     async fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {
         self.stream.read_to_end(buf).await
     }
@@ -147,33 +147,3 @@ impl AsyncWrite for Stderr {
         self.stream.as_async_output_stream()
     }
 }
-
-#[cfg(test)]
-mod test {
-    use crate::io::AsyncWrite;
-    use crate::runtime::block_on;
-    #[test]
-    // No internal predicate. Run test with --nocapture and inspect output manually.
-    fn stdout_println_hello_world() {
-        block_on(async {
-            let mut stdout = super::stdout();
-            let term = if stdout.is_terminal() { "is" } else { "is not" };
-            stdout
-                .write_all(format!("hello, world! stdout {term} a terminal\n",).as_bytes())
-                .await
-                .unwrap();
-        })
-    }
-    #[test]
-    // No internal predicate. Run test with --nocapture and inspect output manually.
-    fn stderr_println_hello_world() {
-        block_on(async {
-            let mut stdout = super::stdout();
-            let term = if stdout.is_terminal() { "is" } else { "is not" };
-            stdout
-                .write_all(format!("hello, world! stderr {term} a terminal\n",).as_bytes())
-                .await
-                .unwrap();
-        })
-    }
-}