chore: rename WasiCtx -> WasiP2Ctx

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

Author: rvolosatovs

benches/instantiation.rs

@@ -6,15 +6,15 @@ use std::process::Command;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
 use std::sync::Arc;
 use std::thread;
-use wasi_common::{sync::WasiCtxBuilder, WasiCtx};
+use wasi_common::{sync::WasiP2CtxBuilder, WasiP2Ctx};
 use wasmtime::*;
 
-fn store(engine: &Engine) -> Store<WasiCtx> {
-    let wasi = WasiCtxBuilder::new().build();
+fn store(engine: &Engine) -> Store<WasiP2Ctx> {
+    let wasi = WasiP2CtxBuilder::new().build();
     Store::new(engine, wasi)
 }
 
-fn instantiate(pre: &InstancePre<WasiCtx>, engine: &Engine) -> Result<()> {
+fn instantiate(pre: &InstancePre<WasiP2Ctx>, engine: &Engine) -> Result<()> {
     let mut store = store(engine);
     let _instance = pre.instantiate(&mut store)?;
     Ok(())

benches/wasi.rs

@@ -2,7 +2,7 @@
 
 use criterion::{criterion_group, criterion_main, Criterion};
 use std::{fs::File, path::Path, time::Instant};
-use wasi_common::{sync::WasiCtxBuilder, WasiCtx};
+use wasi_common::{sync::WasiP2CtxBuilder, WasiP2Ctx};
 use wasmtime::{Engine, Linker, Module, Store, TypedFunc};
 
 criterion_group!(benches, bench_wasi);
@@ -47,7 +47,7 @@ fn bench_wasi(c: &mut Criterion) {
 /// - execute the body of the function for that number of loop iterations
 /// - return a single `u64` indicating how many loop iterations were executed
 ///   (to double-check)
-fn instantiate(wat: &[u8]) -> (Store<WasiCtx>, TypedFunc<u64, u64>) {
+fn instantiate(wat: &[u8]) -> (Store<WasiP2Ctx>, TypedFunc<u64, u64>) {
     let engine = Engine::default();
     let wasi = wasi_context();
     let mut store = Store::new(&engine, wasi);
@@ -60,8 +60,8 @@ fn instantiate(wat: &[u8]) -> (Store<WasiCtx>, TypedFunc<u64, u64>) {
 }
 
 /// Build a WASI context with some actual data to retrieve.
-fn wasi_context() -> WasiCtx {
-    WasiCtxBuilder::new()
+fn wasi_context() -> WasiP2Ctx {
+    WasiP2CtxBuilder::new()
         .envs(&[
             ("a".to_string(), "b".to_string()),
             ("b".to_string(), "c".to_string()),

crates/bench-api/src/lib.rs

@@ -141,7 +141,7 @@ use clap::Parser;
 use std::os::raw::{c_int, c_void};
 use std::slice;
 use std::{env, path::PathBuf};
-use wasi_common::{sync::WasiCtxBuilder, I32Exit, WasiCtx};
+use wasi_common::{sync::WasiP2CtxBuilder, I32Exit, WasiP2Ctx};
 use wasmtime::{Engine, Instance, Linker, Module, Store};
 use wasmtime_cli_flags::CommonOptions;
 
@@ -298,7 +298,7 @@ pub extern "C" fn wasm_bench_create(
             config.execution_start,
             config.execution_end,
             move || {
-                let mut cx = WasiCtxBuilder::new();
+                let mut cx = WasiP2CtxBuilder::new();
 
                 let stdout = std::fs::File::create(&stdout_path)
                     .with_context(|| format!("failed to create {}", stdout_path.display()))?;
@@ -407,15 +407,15 @@ struct BenchState {
     instantiation_timer: *mut u8,
     instantiation_start: extern "C" fn(*mut u8),
     instantiation_end: extern "C" fn(*mut u8),
-    make_wasi_cx: Box<dyn FnMut() -> Result<WasiCtx>>,
+    make_wasi_cx: Box<dyn FnMut() -> Result<WasiP2Ctx>>,
     module: Option<Module>,
     store_and_instance: Option<(Store<HostState>, Instance)>,
     epoch_interruption: bool,
     fuel: Option<u64>,
 }
 
 struct HostState {
-    wasi: WasiCtx,
+    wasi: WasiP2Ctx,
     #[cfg(feature = "wasi-nn")]
     wasi_nn: wasmtime_wasi_nn::witx::WasiNnCtx,
 }
@@ -432,7 +432,7 @@ impl BenchState {
         execution_timer: *mut u8,
         execution_start: extern "C" fn(*mut u8),
         execution_end: extern "C" fn(*mut u8),
-        make_wasi_cx: impl FnMut() -> Result<WasiCtx> + 'static,
+        make_wasi_cx: impl FnMut() -> Result<WasiP2Ctx> + 'static,
     ) -> Result<Self> {
         let mut config = options.config(None)?;
         // NB: always disable the compilation cache.

crates/c-api/src/wasi.rs

@@ -6,7 +6,7 @@ use std::ffi::{c_char, CStr};
 use std::fs::File;
 use std::path::Path;
 use std::slice;
-use wasmtime_wasi::p2::WasiCtxBuilder;
+use wasmtime_wasi::p2::WasiP2CtxBuilder;
 use wasmtime_wasi::preview1::WasiP1Ctx;
 
 unsafe fn cstr_to_path<'a>(path: *const c_char) -> Option<&'a Path> {
@@ -27,7 +27,7 @@ unsafe fn create_file(path: *const c_char) -> Option<File> {
 
 #[repr(C)]
 pub struct wasi_config_t {
-    builder: WasiCtxBuilder,
+    builder: WasiP2CtxBuilder,
 }
 
 wasmtime_c_api_macros::declare_own!(wasi_config_t);
@@ -41,7 +41,7 @@ impl wasi_config_t {
 #[unsafe(no_mangle)]
 pub extern "C" fn wasi_config_new() -> Box<wasi_config_t> {
     Box::new(wasi_config_t {
-        builder: WasiCtxBuilder::new(),
+        builder: WasiP2CtxBuilder::new(),
     })
 }
 

crates/wasi-common/src/ctx.rs

@@ -16,9 +16,9 @@ use std::sync::{Arc, Mutex};
 /// improvements that can be made (TODO:
 /// <https://github.com/bytecodealliance/wasmtime/issues/5643)>.
 #[derive(Clone)]
-pub struct WasiCtx(Arc<WasiCtxInner>);
+pub struct WasiP2Ctx(Arc<WasiP2CtxInner>);
 
-pub struct WasiCtxInner {
+pub struct WasiP2CtxInner {
     pub args: StringArray,
     pub env: StringArray,
     // TODO: this mutex should not be necessary, it forces threads to serialize
@@ -30,14 +30,14 @@ pub struct WasiCtxInner {
     pub table: Table,
 }
 
-impl WasiCtx {
+impl WasiP2Ctx {
     pub fn new(
         random: Box<dyn RngCore + Send + Sync>,
         clocks: WasiClocks,
         sched: Box<dyn WasiSched>,
         table: Table,
     ) -> Self {
-        let s = WasiCtx(Arc::new(WasiCtxInner {
+        let s = WasiP2Ctx(Arc::new(WasiP2CtxInner {
             args: StringArray::new(),
             env: StringArray::new(),
             random: Mutex::new(random),
@@ -120,8 +120,8 @@ impl WasiCtx {
     }
 }
 
-impl Deref for WasiCtx {
-    type Target = WasiCtxInner;
+impl Deref for WasiP2Ctx {
+    type Target = WasiP2CtxInner;
     fn deref(&self) -> &Self::Target {
         &self.0
     }

crates/wasi-common/src/lib.rs

@@ -63,8 +63,8 @@
 //!   `sched_yield` and `poll_oneoff` functions.
 //!
 //! Users can provide implementations of each of these interfaces to the
-//! `WasiCtx::builder(...)` function. The
-//! `wasi_cap_std_sync::WasiCtxBuilder::new()` function uses this public
+//! `WasiP2Ctx::builder(...)` function. The
+//! `wasi_cap_std_sync::WasiP2CtxBuilder::new()` function uses this public
 //! interface to plug in its own implementations of each of these resources.
 
 #![warn(clippy::cast_sign_loss)]
@@ -91,7 +91,7 @@ pub mod tokio;
 
 pub use cap_rand::RngCore;
 pub use clocks::{SystemTimeSpec, WasiClocks, WasiMonotonicClock, WasiSystemClock};
-pub use ctx::WasiCtx;
+pub use ctx::WasiP2Ctx;
 pub use dir::WasiDir;
 pub use error::{Error, ErrorExt, I32Exit};
 pub use file::WasiFile;

crates/wasi-common/src/pipe.rs

@@ -20,14 +20,14 @@ use std::sync::{Arc, RwLock};
 /// A variety of `From` impls are provided so that common pipe types are easy to create. For example:
 ///
 /// ```no_run
-/// use wasi_common::{pipe::ReadPipe, WasiCtx, Table};
+/// use wasi_common::{pipe::ReadPipe, WasiP2Ctx, Table};
 /// let stdin = ReadPipe::from("hello from stdin!");
 /// // Brint these instances from elsewhere (e.g. wasi-cap-std-sync):
 /// let random = todo!();
 /// let clocks = todo!();
 /// let sched = todo!();
 /// let table = Table::new();
-/// let mut ctx = WasiCtx::new(random, clocks, sched, table);
+/// let mut ctx = WasiP2Ctx::new(random, clocks, sched, table);
 /// ctx.set_stdin(Box::new(stdin.clone()));
 /// ```
 #[derive(Debug)]
@@ -116,14 +116,14 @@ impl<R: Read + Any + Send + Sync> WasiFile for ReadPipe<R> {
 /// A virtual pipe write end.
 ///
 /// ```no_run
-/// use wasi_common::{pipe::WritePipe, WasiCtx, Table};
+/// use wasi_common::{pipe::WritePipe, WasiP2Ctx, Table};
 /// let stdout = WritePipe::new_in_memory();
 /// // Brint these instances from elsewhere (e.g. wasi-cap-std-sync):
 /// let random = todo!();
 /// let clocks = todo!();
 /// let sched = todo!();
 /// let table = Table::new();
-/// let mut ctx = WasiCtx::new(random, clocks, sched, table);
+/// let mut ctx = WasiP2Ctx::new(random, clocks, sched, table);
 /// ctx.set_stdout(Box::new(stdout.clone()));
 /// // use ctx in an instance, then make sure it is dropped:
 /// drop(ctx);

crates/wasi-common/src/snapshots/mod.rs

@@ -1,5 +1,5 @@
 //! One goal of `wasi-common` is for multiple WASI snapshots to provide an
-//! interface to the same underlying `crate::WasiCtx`. This provides us a path
+//! interface to the same underlying `crate::WasiP2Ctx`. This provides us a path
 //! to evolve WASI by allowing the same WASI Command to import functions from
 //! different snapshots - e.g. the user could use Rust's `std` which imports
 //! snapshot 1, but also depend directly on the `wasi` crate which imports
@@ -10,14 +10,14 @@
 //!
 //! * Snapshots are arranged into modules under `crate::snapshots::`.
 //! * Each snapshot should invoke `wiggle::from_witx!` with `ctx:
-//!   crate::WasiCtx` in its module, and impl all of the required traits.
+//!   crate::WasiP2Ctx` in its module, and impl all of the required traits.
 //! * Snapshots can be implemented in terms of other snapshots. For example,
 //!   snapshot 0 is mostly implemented by calling the snapshot 1 implementation,
 //!   and converting its own types back and forth with the snapshot 1 types. In a
 //!   few cases, that is not feasible, so snapshot 0 carries its own
 //!   implementations in terms of the `WasiFile` and `WasiSched` traits.
 //! * Snapshots can be implemented in terms of the `Wasi*` traits given by
-//!   `WasiCtx`. No further downcasting via the `as_any` escape hatch is
+//!   `WasiP2Ctx`. No further downcasting via the `as_any` escape hatch is
 //!   permitted.
 
 pub mod preview_0;

crates/wasi-common/src/snapshots/preview_0.rs

@@ -5,7 +5,7 @@ use crate::sched::{
 };
 use crate::snapshots::preview_1::types as snapshot1_types;
 use crate::snapshots::preview_1::wasi_snapshot_preview1::WasiSnapshotPreview1 as Snapshot1;
-use crate::{ErrorExt, WasiCtx};
+use crate::{ErrorExt, WasiP2Ctx};
 use cap_std::time::Duration;
 use std::collections::HashSet;
 use wiggle::{GuestMemory, GuestPtr};
@@ -384,7 +384,7 @@ convert_flags_bidirectional!(
 // This implementation, wherever possible, delegates directly to the Snapshot1 implementation,
 // performing the no-op type conversions along the way.
 #[wiggle::async_trait]
-impl wasi_unstable::WasiUnstable for WasiCtx {
+impl wasi_unstable::WasiUnstable for WasiP2Ctx {
     async fn args_get(
         &mut self,
         memory: &mut GuestMemory<'_>,

crates/wasi-common/src/snapshots/preview_1.rs

@@ -8,7 +8,7 @@ use crate::{
         subscription::{RwEventFlags, SubscriptionResult},
         Poll, Userdata,
     },
-    I32Exit, SystemTimeSpec, WasiCtx,
+    I32Exit, SystemTimeSpec, WasiP2Ctx,
 };
 use cap_std::time::{Duration, SystemClock};
 use std::borrow::Cow;
@@ -42,7 +42,7 @@ impl wiggle::GuestErrorType for types::Errno {
 }
 
 #[wiggle::async_trait]
-impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
+impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiP2Ctx {
     async fn args_get(
         &mut self,
         memory: &mut GuestMemory<'_>,

crates/wasi-common/src/sync/mod.rs

@@ -6,11 +6,11 @@
 //! exception of the `sched` implementation, which is provided for both unix
 //! and windows in separate modules.
 //!
-//! Any `wasi_common::{WasiCtx, WasiCtxBuilder}` is interoperable with the
+//! Any `wasi_common::{WasiP2Ctx, WasiP2CtxBuilder}` is interoperable with the
 //! implementations provided in `wasi_common::sync`. However, for convenience,
-//! this module provides its own `WasiCtxBuilder` that hooks up to all of the
+//! this module provides its own `WasiP2CtxBuilder` that hooks up to all of the
 //! crate's components, i.e. it fills in all of the arguments to
-//! `WasiCtx::builder(...)`, presents `preopen_dir` in terms of
+//! `WasiP2Ctx::builder(...)`, presents `preopen_dir` in terms of
 //! `cap_std::fs::Dir`, and provides convenience methods for inheriting the
 //! parent process's stdio, args, and env.
 
@@ -28,20 +28,20 @@ pub use clocks::clocks_ctx;
 pub use sched::sched_ctx;
 
 use self::net::Socket;
-use crate::{file::FileAccessMode, table::Table, Error, WasiCtx, WasiFile};
+use crate::{file::FileAccessMode, table::Table, Error, WasiFile, WasiP2Ctx};
 use cap_rand::{Rng, RngCore, SeedableRng};
 use std::mem;
 use std::path::Path;
 
-pub struct WasiCtxBuilder {
-    ctx: WasiCtx,
+pub struct WasiP2CtxBuilder {
+    ctx: WasiP2Ctx,
     built: bool,
 }
 
-impl WasiCtxBuilder {
+impl WasiP2CtxBuilder {
     pub fn new() -> Self {
-        WasiCtxBuilder {
-            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
+        WasiP2CtxBuilder {
+            ctx: WasiP2Ctx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
             built: false,
         }
     }
@@ -121,9 +121,9 @@ impl WasiCtxBuilder {
             .insert_file(fd, file, FileAccessMode::READ | FileAccessMode::WRITE);
         Ok(self)
     }
-    pub fn build(&mut self) -> WasiCtx {
+    pub fn build(&mut self) -> WasiP2Ctx {
         assert!(!self.built);
-        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
+        let WasiP2CtxBuilder { ctx, .. } = mem::replace(self, Self::new());
         self.built = true;
         ctx
     }

crates/wasi-common/src/table.rs

@@ -4,8 +4,8 @@ use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 
 /// The `Table` type is designed to map u32 handles to resources. The table is now part of the
-/// public interface to a `WasiCtx` - it is reference counted so that it can be shared beyond a
-/// `WasiCtx` with other WASI proposals (e.g. `wasi-crypto` and `wasi-nn`) to manage their
+/// public interface to a `WasiP2Ctx` - it is reference counted so that it can be shared beyond a
+/// `WasiP2Ctx` with other WASI proposals (e.g. `wasi-crypto` and `wasi-nn`) to manage their
 /// resources. Elements in the `Table` are `Any` typed.
 ///
 /// The `Table` type is intended to model how the Interface Types concept of Resources is shaping

crates/wasi-common/src/tokio/mod.rs

@@ -7,23 +7,23 @@ pub mod stdio;
 use self::sched::sched_ctx;
 use crate::sync::net::Socket;
 pub use crate::sync::{clocks_ctx, random_ctx};
-use crate::{file::FileAccessMode, Error, Table, WasiCtx, WasiFile};
+use crate::{file::FileAccessMode, Error, Table, WasiFile, WasiP2Ctx};
 pub use dir::Dir;
 pub use file::File;
 pub use net::*;
 use std::future::Future;
 use std::mem;
 use std::path::Path;
 
-pub struct WasiCtxBuilder {
-    ctx: WasiCtx,
+pub struct WasiP2CtxBuilder {
+    ctx: WasiP2Ctx,
     built: bool,
 }
 
-impl WasiCtxBuilder {
+impl WasiP2CtxBuilder {
     pub fn new() -> Self {
-        WasiCtxBuilder {
-            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
+        WasiP2CtxBuilder {
+            ctx: WasiP2Ctx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
             built: false,
         }
     }
@@ -104,9 +104,9 @@ impl WasiCtxBuilder {
         Ok(self)
     }
 
-    pub fn build(&mut self) -> WasiCtx {
+    pub fn build(&mut self) -> WasiP2Ctx {
         assert!(!self.built);
-        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
+        let WasiP2CtxBuilder { ctx, .. } = mem::replace(self, Self::new());
         self.built = true;
         ctx
     }

crates/wasi-common/tests/all/async_.rs

@@ -1,6 +1,6 @@
 use super::*;
 use test_programs_artifacts::*;
-use wasi_common::tokio::{add_to_linker, WasiCtxBuilder};
+use wasi_common::tokio::{add_to_linker, WasiP2CtxBuilder};
 
 foreach_preview1!(assert_test_exists);
 
@@ -25,7 +25,7 @@ async fn run(path: &str, inherit_stdio: bool) -> Result<()> {
 
         // Create our wasi context.
         // Additionally register any preopened directories if we have them.
-        let mut builder = WasiCtxBuilder::new();
+        let mut builder = WasiP2CtxBuilder::new();
 
         if inherit_stdio {
             builder.inherit_stdio();