From c664bd90227acf7aaddf5f3811f97102334f8067 Mon Sep 17 00:00:00 2001 From: Pat Hickey Date: Thu, 11 Sep 2025 11:05:32 -0700 Subject: [PATCH] switch from using `wasi` crate to `wasip2` --- Cargo.toml | 4 ++-- macro/src/lib.rs | 8 ++++---- src/http/body.rs | 8 ++++---- src/http/client.rs | 8 ++++---- src/http/error.rs | 2 +- src/http/fields.rs | 2 +- src/http/method.rs | 2 +- src/http/request.rs | 6 +++--- src/http/response.rs | 2 +- src/http/scheme.rs | 2 +- src/http/server.rs | 6 +++--- src/io/copy.rs | 2 +- src/io/stdio.rs | 16 ++++++++-------- src/io/streams.rs | 2 +- src/lib.rs | 2 +- src/net/tcp_listener.rs | 42 ++++++++++++++++++++++------------------- src/net/tcp_stream.rs | 10 ++++++---- src/rand/mod.rs | 2 +- src/runtime/mod.rs | 2 +- src/runtime/reactor.rs | 36 +++++++++++++++++------------------ src/time/duration.rs | 2 +- src/time/instant.rs | 4 ++-- src/time/mod.rs | 2 +- 23 files changed, 89 insertions(+), 83 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 4157166..bf41f63 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,7 +22,7 @@ http.workspace = true itoa.workspace = true pin-project-lite.workspace = true slab.workspace = true -wasi.workspace = true +wasip2.workspace = true wstd-macro.workspace = true # optional @@ -83,7 +83,7 @@ test-log = { version = "0.2", features = ["trace"] } test-programs = { path = "test-programs" } test-programs-artifacts = { path = "test-programs/artifacts" } ureq = { version = "2.12.1", default-features = false } -wasi = "0.14.0" +wasip2 = "1.0" wstd = { path = "." } wstd-macro = { path = "macro", version = "=0.5.5" } diff --git a/macro/src/lib.rs b/macro/src/lib.rs index f118ab2..2c6c6e5 100644 --- a/macro/src/lib.rs +++ b/macro/src/lib.rs @@ -126,10 +126,10 @@ pub fn attr_macro_http_server(_attr: TokenStream, item: TokenStream) -> TokenStr quote! { struct TheServer; - impl ::wstd::wasi::exports::http::incoming_handler::Guest for TheServer { + impl ::wstd::wasip2::exports::http::incoming_handler::Guest for TheServer { fn handle( - request: ::wstd::wasi::http::types::IncomingRequest, - response_out: ::wstd::wasi::http::types::ResponseOutparam + request: ::wstd::wasip2::http::types::IncomingRequest, + response_out: ::wstd::wasip2::http::types::ResponseOutparam ) { #(#attrs)* #vis async fn __run(#inputs) #output { @@ -146,7 +146,7 @@ pub fn attr_macro_http_server(_attr: TokenStream, item: TokenStream) -> TokenStr } } - ::wstd::wasi::http::proxy::export!(TheServer with_types_in ::wstd::wasi); + ::wstd::wasip2::http::proxy::export!(TheServer with_types_in ::wstd::wasip2); // Provide an actual function named `main`. // diff --git a/src/http/body.rs b/src/http/body.rs index 074b4fe..9eecfae 100644 --- a/src/http/body.rs +++ b/src/http/body.rs @@ -5,7 +5,7 @@ use crate::io::{AsyncInputStream, AsyncOutputStream, AsyncRead, AsyncWrite, Curs use crate::runtime::AsyncPollable; use core::fmt; use http::header::CONTENT_LENGTH; -use wasi::http::types::IncomingBody as WasiIncomingBody; +use wasip2::http::types::IncomingBody as WasiIncomingBody; #[cfg(feature = "json")] use serde::de::DeserializeOwned; @@ -274,12 +274,12 @@ pub struct OutgoingBody { // IMPORTANT: the order of these fields here matters. `stream` must // be dropped before `body`. stream: AsyncOutputStream, - body: wasi::http::types::OutgoingBody, + body: wasip2::http::types::OutgoingBody, dontdrop: DontDropOutgoingBody, } impl OutgoingBody { - pub(crate) fn new(stream: AsyncOutputStream, body: wasi::http::types::OutgoingBody) -> Self { + pub(crate) fn new(stream: AsyncOutputStream, body: wasip2::http::types::OutgoingBody) -> Self { Self { stream, body, @@ -287,7 +287,7 @@ impl OutgoingBody { } } - pub(crate) fn consume(self) -> (AsyncOutputStream, wasi::http::types::OutgoingBody) { + pub(crate) fn consume(self) -> (AsyncOutputStream, wasip2::http::types::OutgoingBody) { let Self { stream, body, diff --git a/src/http/client.rs b/src/http/client.rs index ad7f10c..fd251d6 100644 --- a/src/http/client.rs +++ b/src/http/client.rs @@ -12,7 +12,7 @@ use pin_project_lite::pin_project; use std::future::Future; use std::pin::Pin; use std::task::{Context, Poll}; -use wasi::http::types::{ +use wasip2::http::types::{ FutureIncomingResponse as WasiFutureIncomingResponse, OutgoingBody as WasiOutgoingBody, RequestOptions as WasiRequestOptions, }; @@ -50,7 +50,7 @@ impl Client { let wasi_stream = wasi_body.write().unwrap(); // 1. Start sending the request head - let res = wasi::http::outgoing_handler::handle(wasi_req, self.wasi_options()?).unwrap(); + let res = wasip2::http::outgoing_handler::handle(wasi_req, self.wasi_options()?).unwrap(); // 2. Start sending the request body io::copy(body, AsyncOutputStream::new(wasi_stream)).await?; @@ -86,7 +86,7 @@ impl Client { let wasi_stream = wasi_body.write().unwrap(); // Start sending the request head. - let res = wasi::http::outgoing_handler::handle(wasi_req, self.wasi_options()?).unwrap(); + let res = wasip2::http::outgoing_handler::handle(wasi_req, self.wasi_options()?).unwrap(); let outgoing_body = OutgoingBody::new(AsyncOutputStream::new(wasi_stream), wasi_body); @@ -141,7 +141,7 @@ impl Client { None => None, }; - wasi::http::types::OutgoingBody::finish(body, wasi_trailers) + wasip2::http::types::OutgoingBody::finish(body, wasi_trailers) .expect("body length did not match Content-Length header value"); Ok(()) } diff --git a/src/http/error.rs b/src/http/error.rs index 34a70ae..c3c540b 100644 --- a/src/http/error.rs +++ b/src/http/error.rs @@ -12,7 +12,7 @@ pub struct Error { pub use http::header::{InvalidHeaderName, InvalidHeaderValue}; pub use http::method::InvalidMethod; -pub use wasi::http::types::{ErrorCode as WasiHttpErrorCode, HeaderError as WasiHttpHeaderError}; +pub use wasip2::http::types::{ErrorCode as WasiHttpErrorCode, HeaderError as WasiHttpHeaderError}; impl fmt::Debug for Error { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { diff --git a/src/http/fields.rs b/src/http/fields.rs index cd41684..34452f5 100644 --- a/src/http/fields.rs +++ b/src/http/fields.rs @@ -1,7 +1,7 @@ pub use http::header::{HeaderMap, HeaderName, HeaderValue}; use super::Error; -use wasi::http::types::{Fields, HeaderError as WasiHttpHeaderError}; +use wasip2::http::types::{Fields, HeaderError as WasiHttpHeaderError}; pub(crate) fn header_map_from_wasi(wasi_fields: Fields) -> Result { let mut output = HeaderMap::new(); diff --git a/src/http/method.rs b/src/http/method.rs index 1f06eff..cee31e6 100644 --- a/src/http/method.rs +++ b/src/http/method.rs @@ -1,4 +1,4 @@ -use wasi::http::types::Method as WasiMethod; +use wasip2::http::types::Method as WasiMethod; use http::method::InvalidMethod; pub use http::Method; diff --git a/src/http/request.rs b/src/http/request.rs index 92a1129..d150367 100644 --- a/src/http/request.rs +++ b/src/http/request.rs @@ -7,8 +7,8 @@ use super::{ Authority, Error, HeaderMap, PathAndQuery, Uri, }; use crate::io::AsyncInputStream; -use wasi::http::outgoing_handler::OutgoingRequest; -use wasi::http::types::IncomingRequest; +use wasip2::http::outgoing_handler::OutgoingRequest; +use wasip2::http::types::IncomingRequest; pub use http::request::{Builder, Request}; @@ -71,7 +71,7 @@ pub(crate) fn try_into_outgoing(request: Request) -> Result<(OutgoingReque .uri .scheme() .map(to_wasi_scheme) - .unwrap_or(wasi::http::types::Scheme::Https); + .unwrap_or(wasip2::http::types::Scheme::Https); wasi_req .set_scheme(Some(&scheme)) .map_err(|()| Error::other(format!("scheme rejected by wasi-http: {scheme:?}")))?; diff --git a/src/http/response.rs b/src/http/response.rs index 2c31b86..0c80ff0 100644 --- a/src/http/response.rs +++ b/src/http/response.rs @@ -1,4 +1,4 @@ -use wasi::http::types::IncomingResponse; +use wasip2::http::types::IncomingResponse; use super::{ body::{BodyKind, IncomingBody}, diff --git a/src/http/scheme.rs b/src/http/scheme.rs index 860ce35..8a3298e 100644 --- a/src/http/scheme.rs +++ b/src/http/scheme.rs @@ -1,4 +1,4 @@ -use wasi::http::types::Scheme as WasiScheme; +use wasip2::http::types::Scheme as WasiScheme; pub use http::uri::{InvalidUri, Scheme}; use std::str::FromStr; diff --git a/src/http/server.rs b/src/http/server.rs index 2d89dda..7a9117d 100644 --- a/src/http/server.rs +++ b/src/http/server.rs @@ -28,8 +28,8 @@ use super::{ }; use crate::io::{copy, AsyncOutputStream}; use http::header::CONTENT_LENGTH; -use wasi::exports::http::incoming_handler::ResponseOutparam; -use wasi::http::types::OutgoingResponse; +use wasip2::exports::http::incoming_handler::ResponseOutparam; +use wasip2::http::types::OutgoingResponse; /// This is passed into the [`http_server`] `main` function and holds the state /// needed for a handler to produce a response, or fail. There are two ways to @@ -179,7 +179,7 @@ impl Finished { let wasi_trailers = trailers.map(|trailers| header_map_to_wasi(&trailers).expect("header error")); - wasi::http::types::OutgoingBody::finish(body, wasi_trailers) + wasip2::http::types::OutgoingBody::finish(body, wasi_trailers) .expect("body length did not match Content-Length header value"); Self(()) diff --git a/src/io/copy.rs b/src/io/copy.rs index e98b613..832f8e6 100644 --- a/src/io/copy.rs +++ b/src/io/copy.rs @@ -1,5 +1,5 @@ use crate::io::{AsyncRead, AsyncWrite, Error}; -use wasi::io::streams::StreamError; +use wasip2::io::streams::StreamError; /// Copy bytes from a reader to a writer. pub async fn copy(mut reader: R, mut writer: W) -> crate::io::Result<()> diff --git a/src/io/stdio.rs b/src/io/stdio.rs index cc9a60a..0a37e2a 100644 --- a/src/io/stdio.rs +++ b/src/io/stdio.rs @@ -1,7 +1,7 @@ use super::{AsyncInputStream, AsyncOutputStream, AsyncRead, AsyncWrite, Result}; use std::cell::LazyCell; -use wasi::cli::terminal_input::TerminalInput; -use wasi::cli::terminal_output::TerminalOutput; +use wasip2::cli::terminal_input::TerminalInput; +use wasip2::cli::terminal_output::TerminalOutput; /// Use the program's stdin as an `AsyncInputStream`. #[derive(Debug)] @@ -12,10 +12,10 @@ pub struct Stdin { /// Get the program's stdin for use as an `AsyncInputStream`. pub fn stdin() -> Stdin { - let stream = AsyncInputStream::new(wasi::cli::stdin::get_stdin()); + let stream = AsyncInputStream::new(wasip2::cli::stdin::get_stdin()); Stdin { stream, - terminput: LazyCell::new(wasi::cli::terminal_stdin::get_terminal_stdin), + terminput: LazyCell::new(wasip2::cli::terminal_stdin::get_terminal_stdin), } } @@ -52,10 +52,10 @@ pub struct Stdout { /// Get the program's stdout for use as an `AsyncOutputStream`. pub fn stdout() -> Stdout { - let stream = AsyncOutputStream::new(wasi::cli::stdout::get_stdout()); + let stream = AsyncOutputStream::new(wasip2::cli::stdout::get_stdout()); Stdout { stream, - termoutput: LazyCell::new(wasi::cli::terminal_stdout::get_terminal_stdout), + termoutput: LazyCell::new(wasip2::cli::terminal_stdout::get_terminal_stdout), } } @@ -97,10 +97,10 @@ pub struct Stderr { /// Get the program's stdout for use as an `AsyncOutputStream`. pub fn stderr() -> Stderr { - let stream = AsyncOutputStream::new(wasi::cli::stderr::get_stderr()); + let stream = AsyncOutputStream::new(wasip2::cli::stderr::get_stderr()); Stderr { stream, - termoutput: LazyCell::new(wasi::cli::terminal_stderr::get_terminal_stderr), + termoutput: LazyCell::new(wasip2::cli::terminal_stderr::get_terminal_stderr), } } diff --git a/src/io/streams.rs b/src/io/streams.rs index d7139c1..d8b35ec 100644 --- a/src/io/streams.rs +++ b/src/io/streams.rs @@ -1,7 +1,7 @@ use super::{AsyncPollable, AsyncRead, AsyncWrite}; use std::cell::OnceCell; use std::io::Result; -use wasi::io::streams::{InputStream, OutputStream, StreamError}; +use wasip2::io::streams::{InputStream, OutputStream, StreamError}; /// A wrapper for WASI's `InputStream` resource that provides implementations of `AsyncRead` and /// `AsyncPollable`. diff --git a/src/lib.rs b/src/lib.rs index 5502555..ccbc2c1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -72,7 +72,7 @@ pub use wstd_macro::attr_macro_test as test; // Re-export the wasi crate for use by the `http_server` macro. #[doc(hidden)] -pub use wasi; +pub use wasip2; pub mod prelude { pub use crate::future::FutureExt as _; diff --git a/src/net/tcp_listener.rs b/src/net/tcp_listener.rs index 99cdeb4..830d673 100644 --- a/src/net/tcp_listener.rs +++ b/src/net/tcp_listener.rs @@ -1,5 +1,5 @@ -use wasi::sockets::network::Ipv4SocketAddress; -use wasi::sockets::tcp::{ErrorCode, IpAddressFamily, IpSocketAddress, TcpSocket}; +use wasip2::sockets::network::Ipv4SocketAddress; +use wasip2::sockets::tcp::{ErrorCode, IpAddressFamily, IpSocketAddress, TcpSocket}; use crate::io; use crate::iter::AsyncIterator; @@ -30,8 +30,8 @@ impl TcpListener { SocketAddr::V6(_) => IpAddressFamily::Ipv6, }; let socket = - wasi::sockets::tcp_create_socket::create_tcp_socket(family).map_err(to_io_err)?; - let network = wasi::sockets::instance_network::instance_network(); + wasip2::sockets::tcp_create_socket::create_tcp_socket(family).map_err(to_io_err)?; + let network = wasip2::sockets::instance_network::instance_network(); let local_address = sockaddr_to_wasi(addr); @@ -83,25 +83,29 @@ impl<'a> AsyncIterator for Incoming<'a> { pub(super) fn to_io_err(err: ErrorCode) -> io::Error { match err { - wasi::sockets::network::ErrorCode::Unknown => ErrorKind::Other.into(), - wasi::sockets::network::ErrorCode::AccessDenied => ErrorKind::PermissionDenied.into(), - wasi::sockets::network::ErrorCode::NotSupported => ErrorKind::Unsupported.into(), - wasi::sockets::network::ErrorCode::InvalidArgument => ErrorKind::InvalidInput.into(), - wasi::sockets::network::ErrorCode::OutOfMemory => ErrorKind::OutOfMemory.into(), - wasi::sockets::network::ErrorCode::Timeout => ErrorKind::TimedOut.into(), - wasi::sockets::network::ErrorCode::WouldBlock => ErrorKind::WouldBlock.into(), - wasi::sockets::network::ErrorCode::InvalidState => ErrorKind::InvalidData.into(), - wasi::sockets::network::ErrorCode::AddressInUse => ErrorKind::AddrInUse.into(), - wasi::sockets::network::ErrorCode::ConnectionRefused => ErrorKind::ConnectionRefused.into(), - wasi::sockets::network::ErrorCode::ConnectionReset => ErrorKind::ConnectionReset.into(), - wasi::sockets::network::ErrorCode::ConnectionAborted => ErrorKind::ConnectionAborted.into(), - wasi::sockets::network::ErrorCode::ConcurrencyConflict => ErrorKind::AlreadyExists.into(), + wasip2::sockets::network::ErrorCode::Unknown => ErrorKind::Other.into(), + wasip2::sockets::network::ErrorCode::AccessDenied => ErrorKind::PermissionDenied.into(), + wasip2::sockets::network::ErrorCode::NotSupported => ErrorKind::Unsupported.into(), + wasip2::sockets::network::ErrorCode::InvalidArgument => ErrorKind::InvalidInput.into(), + wasip2::sockets::network::ErrorCode::OutOfMemory => ErrorKind::OutOfMemory.into(), + wasip2::sockets::network::ErrorCode::Timeout => ErrorKind::TimedOut.into(), + wasip2::sockets::network::ErrorCode::WouldBlock => ErrorKind::WouldBlock.into(), + wasip2::sockets::network::ErrorCode::InvalidState => ErrorKind::InvalidData.into(), + wasip2::sockets::network::ErrorCode::AddressInUse => ErrorKind::AddrInUse.into(), + wasip2::sockets::network::ErrorCode::ConnectionRefused => { + ErrorKind::ConnectionRefused.into() + } + wasip2::sockets::network::ErrorCode::ConnectionReset => ErrorKind::ConnectionReset.into(), + wasip2::sockets::network::ErrorCode::ConnectionAborted => { + ErrorKind::ConnectionAborted.into() + } + wasip2::sockets::network::ErrorCode::ConcurrencyConflict => ErrorKind::AlreadyExists.into(), _ => ErrorKind::Other.into(), } } fn sockaddr_from_wasi(addr: IpSocketAddress) -> std::net::SocketAddr { - use wasi::sockets::network::Ipv6SocketAddress; + use wasip2::sockets::network::Ipv6SocketAddress; match addr { IpSocketAddress::Ipv4(Ipv4SocketAddress { address, port }) => { std::net::SocketAddr::V4(std::net::SocketAddrV4::new( @@ -127,7 +131,7 @@ fn sockaddr_from_wasi(addr: IpSocketAddress) -> std::net::SocketAddr { } fn sockaddr_to_wasi(addr: std::net::SocketAddr) -> IpSocketAddress { - use wasi::sockets::network::Ipv6SocketAddress; + use wasip2::sockets::network::Ipv6SocketAddress; match addr { std::net::SocketAddr::V4(addr) => { let ip = addr.ip().octets(); diff --git a/src/net/tcp_stream.rs b/src/net/tcp_stream.rs index 2f1a4b5..fc6ef99 100644 --- a/src/net/tcp_stream.rs +++ b/src/net/tcp_stream.rs @@ -1,4 +1,4 @@ -use wasi::{ +use wasip2::{ io::streams::{InputStream, OutputStream}, sockets::tcp::TcpSocket, }; @@ -36,7 +36,9 @@ impl TcpStream { impl Drop for TcpStream { fn drop(&mut self) { - let _ = self.socket.shutdown(wasi::sockets::tcp::ShutdownType::Both); + let _ = self + .socket + .shutdown(wasip2::sockets::tcp::ShutdownType::Both); } } @@ -104,7 +106,7 @@ impl<'a> Drop for ReadHalf<'a> { let _ = self .0 .socket - .shutdown(wasi::sockets::tcp::ShutdownType::Receive); + .shutdown(wasip2::sockets::tcp::ShutdownType::Receive); } } @@ -128,6 +130,6 @@ impl<'a> Drop for WriteHalf<'a> { let _ = self .0 .socket - .shutdown(wasi::sockets::tcp::ShutdownType::Send); + .shutdown(wasip2::sockets::tcp::ShutdownType::Send); } } diff --git a/src/rand/mod.rs b/src/rand/mod.rs index d2e0686..8474b80 100644 --- a/src/rand/mod.rs +++ b/src/rand/mod.rs @@ -1,6 +1,6 @@ //! Random number generation. -use wasi::random; +use wasip2::random; /// Fill the slice with cryptographically secure random bytes. pub fn get_random_bytes(buf: &mut [u8]) { diff --git a/src/runtime/mod.rs b/src/runtime/mod.rs index e5d4b17..24b9fc2 100644 --- a/src/runtime/mod.rs +++ b/src/runtime/mod.rs @@ -3,7 +3,7 @@ //! The way to use this is to call [`block_on()`]. Inside the future, [`Reactor::current`] //! will give an instance of the [`Reactor`] running the event loop, which can be //! to [`AsyncPollable::wait_for`] instances of -//! [`wasi::Pollable`](https://docs.rs/wasi/latest/wasi/io/poll/struct.Pollable.html). +//! [`wasip2::Pollable`](https://docs.rs/wasi/latest/wasi/io/poll/struct.Pollable.html). //! This will automatically wait for the futures to resolve, and call the //! necessary wakers to work. diff --git a/src/runtime/reactor.rs b/src/runtime/reactor.rs index a4a34e9..67d1de2 100644 --- a/src/runtime/reactor.rs +++ b/src/runtime/reactor.rs @@ -8,7 +8,7 @@ use core::task::{Context, Poll, Waker}; use slab::Slab; use std::collections::{HashMap, VecDeque}; use std::rc::Rc; -use wasi::io::poll::Pollable; +use wasip2::io::poll::Pollable; /// A key for a `Pollable`, which is an index into the `Slab` in `Reactor`. #[repr(transparent)] @@ -143,9 +143,9 @@ impl Reactor { debug_assert_ne!( targets.len(), 0, - "Attempting to block on an empty list of pollables - without any pending work, no progress can be made and wasi::io::poll::poll will trap" + "Attempting to block on an empty list of pollables - without any pending work, no progress can be made and wasip2::io::poll::poll will trap" ); - wasi::io::poll::poll(targets) + wasip2::io::poll::poll(targets) }) } @@ -161,7 +161,7 @@ impl Reactor { // Lazily create a pollable which always resolves to ready. use std::sync::LazyLock; static READY_POLLABLE: LazyLock = - LazyLock::new(|| wasi::clocks::monotonic_clock::subscribe_duration(0)); + LazyLock::new(|| wasip2::clocks::monotonic_clock::subscribe_duration(0)); self.check_pollables(|targets| { // Create a new set of targets, with the addition of the ready @@ -173,7 +173,7 @@ impl Reactor { // Poll is now guaranteed to return immediately, because at least // one member is ready: - let mut ready_list = wasi::io::poll::poll(&new_targets); + let mut ready_list = wasip2::io::poll::poll(&new_targets); // Erase our extra ready pollable from the ready list: ready_list.retain(|e| *e != ready_index as u32); @@ -295,7 +295,7 @@ mod test { fn subscribe_no_duration() { crate::runtime::block_on(async { let reactor = Reactor::current(); - let pollable = wasi::clocks::monotonic_clock::subscribe_duration(0); + let pollable = wasip2::clocks::monotonic_clock::subscribe_duration(0); let sched = reactor.schedule(pollable); sched.wait_for().await; }) @@ -305,7 +305,7 @@ mod test { fn subscribe_some_duration() { crate::runtime::block_on(async { let reactor = Reactor::current(); - let pollable = wasi::clocks::monotonic_clock::subscribe_duration(10_000_000); + let pollable = wasip2::clocks::monotonic_clock::subscribe_duration(10_000_000); let sched = reactor.schedule(pollable); sched.wait_for().await; }) @@ -318,8 +318,8 @@ mod test { fn subscribe_multiple_durations() { crate::runtime::block_on(async { let reactor = Reactor::current(); - let now = wasi::clocks::monotonic_clock::subscribe_duration(0); - let soon = wasi::clocks::monotonic_clock::subscribe_duration(10_000_000); + let now = wasip2::clocks::monotonic_clock::subscribe_duration(0); + let soon = wasip2::clocks::monotonic_clock::subscribe_duration(10_000_000); let now = reactor.schedule(now); let soon = reactor.schedule(soon); soon.wait_for().await; @@ -333,9 +333,9 @@ mod test { fn subscribe_multiple_durations_zipped() { crate::runtime::block_on(async { let reactor = Reactor::current(); - let start = wasi::clocks::monotonic_clock::now(); - let soon = wasi::clocks::monotonic_clock::subscribe_duration(10_000_000); - let later = wasi::clocks::monotonic_clock::subscribe_duration(40_000_000); + let start = wasip2::clocks::monotonic_clock::now(); + let soon = wasip2::clocks::monotonic_clock::subscribe_duration(10_000_000); + let later = wasip2::clocks::monotonic_clock::subscribe_duration(40_000_000); let soon = reactor.schedule(soon); let later = reactor.schedule(later); @@ -344,14 +344,14 @@ mod test { soon.wait_for().await; println!( "*** subscribe_duration(soon) ready ({})", - wasi::clocks::monotonic_clock::now() - start + wasip2::clocks::monotonic_clock::now() - start ); }, async move { later.wait_for().await; println!( "*** subscribe_duration(later) ready ({})", - wasi::clocks::monotonic_clock::now() - start + wasip2::clocks::monotonic_clock::now() - start ); }, ) @@ -362,11 +362,11 @@ mod test { #[test] fn progresses_wasi_independent_futures() { crate::runtime::block_on(async { - let start = wasi::clocks::monotonic_clock::now(); + let start = wasip2::clocks::monotonic_clock::now(); let reactor = Reactor::current(); const LONG_DURATION: u64 = 1_000_000_000; - let later = wasi::clocks::monotonic_clock::subscribe_duration(LONG_DURATION); + let later = wasip2::clocks::monotonic_clock::subscribe_duration(LONG_DURATION); let later = reactor.schedule(later); let mut polled_before = false; // This is basically futures_lite::future::yield_now, except with a boolean @@ -391,11 +391,11 @@ mod test { "wasi_independent_future should win the race" ); const SHORT_DURATION: u64 = LONG_DURATION / 100; - let soon = wasi::clocks::monotonic_clock::subscribe_duration(SHORT_DURATION); + let soon = wasip2::clocks::monotonic_clock::subscribe_duration(SHORT_DURATION); let soon = reactor.schedule(soon); soon.wait_for().await; - let end = wasi::clocks::monotonic_clock::now(); + let end = wasip2::clocks::monotonic_clock::now(); let duration = end - start; assert!( diff --git a/src/time/duration.rs b/src/time/duration.rs index 7df9708..7f67ceb 100644 --- a/src/time/duration.rs +++ b/src/time/duration.rs @@ -1,7 +1,7 @@ use super::{Instant, Wait}; use std::future::IntoFuture; use std::ops::{Add, AddAssign, Sub, SubAssign}; -use wasi::clocks::monotonic_clock; +use wasip2::clocks::monotonic_clock; /// A Duration type to represent a span of time, typically used for system /// timeouts. diff --git a/src/time/instant.rs b/src/time/instant.rs index 8509c79..f5beaca 100644 --- a/src/time/instant.rs +++ b/src/time/instant.rs @@ -1,7 +1,7 @@ use super::{Duration, Wait}; use std::future::IntoFuture; use std::ops::{Add, AddAssign, Sub, SubAssign}; -use wasi::clocks::monotonic_clock; +use wasip2::clocks::monotonic_clock; /// A measurement of a monotonically nondecreasing clock. Opaque and useful only /// with Duration. @@ -24,7 +24,7 @@ impl Instant { /// ``` #[must_use] pub fn now() -> Self { - Instant(wasi::clocks::monotonic_clock::now()) + Instant(wasip2::clocks::monotonic_clock::now()) } /// Returns the amount of time elapsed from another instant to this one, or zero duration if diff --git a/src/time/mod.rs b/src/time/mod.rs index 9383241..ff99832 100644 --- a/src/time/mod.rs +++ b/src/time/mod.rs @@ -11,7 +11,7 @@ use pin_project_lite::pin_project; use std::future::Future; use std::pin::Pin; use std::task::{Context, Poll}; -use wasi::clocks::{ +use wasip2::clocks::{ monotonic_clock::{subscribe_duration, subscribe_instant}, wall_clock, };