Merge pull request #160 from bytecodealliance/pch/separate-sockets

separate crates for wasi-sockets

Author: pchickey

Cargo.lock

@@ -4,7 +4,19 @@ version.workspace = true
 edition.workspace = true
 
 [workspace]
-members = ["verify", "host", "test-programs", "test-programs/wasi-tests", "test-programs/reactor-tests", "wasi-common", "byte-array", "wasi"]
+members = [
+    "verify",
+    "host",
+    "test-programs",
+    "test-programs/wasi-tests",
+    "test-programs/reactor-tests",
+    "wasi-common",
+    "wasi-common/cap-std-sync",
+    "wasi-sockets",
+    "wasi-sockets/sync",
+    "byte-array",
+    "wasi"
+]
 
 [workspace.package]
 version = "0.0.0"
@@ -26,6 +38,8 @@ async-trait = "0.1.59"
 io-lifetimes = { version = "1.0.0", default-features = false }
 wasi-common = { path = "wasi-common" }
 wasi-cap-std-sync = { path = "wasi-common/cap-std-sync" }
+wasmtime-wasi-sockets = { path = "wasi-sockets" }
+wasmtime-wasi-sockets-sync = { path = "wasi-sockets/sync" }
 once_cell = "1.12.0"
 system-interface = { version = "0.25.1", features = ["cap_std_impls"] }
 wit-bindgen = { version = "0.4.0", default-features = false }

Cargo.toml

@@ -9,6 +9,8 @@ cap-std = { workspace = true }
 wasmtime = { workspace = true }
 wasi-common = { workspace = true }
 wasi-cap-std-sync = { workspace = true }
+wasmtime-wasi-sockets = { workspace = true }
+wasmtime-wasi-sockets-sync = { workspace = true }
 clap = { version = "4.1.9", features = ["derive"] }
 tracing-subscriber = { version = "0.3", default-features = false, features = ["env-filter", "fmt" ]}
 tokio = { version = "1", features = ["full"] }

host/Cargo.toml

@@ -1,10 +1,12 @@
 use anyhow::{Context, Result};
 use wasi_cap_std_sync::WasiCtxBuilder;
-use wasi_common::{wasi, WasiCtx};
+use wasi_common::{wasi, Table, WasiCtx, WasiView};
 use wasmtime::{
     component::{Component, Linker},
     Config, Engine, Store,
 };
+use wasmtime_wasi_sockets::{WasiSocketsCtx, WasiSocketsView};
+use wasmtime_wasi_sockets_sync::WasiSocketsCtxBuilder;
 
 use clap::Parser;
 
@@ -60,74 +62,119 @@ async fn main() -> Result<()> {
 
     let engine = Engine::new(&config)?;
     let component = Component::from_file(&engine, &input)?;
-    let mut linker = Linker::new(&engine);
 
     let mut argv: Vec<&str> = vec!["wasm"];
     argv.extend(args.args.iter().map(String::as_str));
 
-    let mut builder = WasiCtxBuilder::new()
-        .inherit_stdio()
-        .inherit_network(cap_std::ambient_authority())
-        .args(&argv);
+    let mut builder = WasiCtxBuilder::new().inherit_stdio().args(&argv);
 
     for (guest, host) in args.map_dirs {
         let dir = cap_std::fs::Dir::open_ambient_dir(&host, cap_std::ambient_authority())
             .context(format!("opening directory {host:?}"))?;
         builder = builder.preopened_dir(dir, &guest);
     }
 
-    let wasi_ctx = builder.build()?;
+    let mut table = Table::new();
+    let wasi = builder.build(&mut table)?;
 
     if args.world == "command" {
-        run_command(&mut linker, &engine, &component, wasi_ctx).await?;
+        struct CommandCtx {
+            table: Table,
+            wasi: WasiCtx,
+            sockets: WasiSocketsCtx,
+        }
+        impl WasiView for CommandCtx {
+            fn table(&self) -> &Table {
+                &self.table
+            }
+            fn table_mut(&mut self) -> &mut Table {
+                &mut self.table
+            }
+            fn ctx(&self) -> &WasiCtx {
+                &self.wasi
+            }
+            fn ctx_mut(&mut self) -> &mut WasiCtx {
+                &mut self.wasi
+            }
+        }
+        let sockets = WasiSocketsCtxBuilder::new()
+            .inherit_network(cap_std::ambient_authority())
+            .build();
+        impl WasiSocketsView for CommandCtx {
+            fn table(&self) -> &Table {
+                &self.table
+            }
+            fn table_mut(&mut self) -> &mut Table {
+                &mut self.table
+            }
+            fn ctx(&self) -> &WasiSocketsCtx {
+                &self.sockets
+            }
+            fn ctx_mut(&mut self) -> &mut WasiSocketsCtx {
+                &mut self.sockets
+            }
+        }
+
+        let mut linker = Linker::new(&engine);
+        wasi::command::add_to_linker(&mut linker)?;
+        wasmtime_wasi_sockets::add_to_linker(&mut linker)?;
+        let mut store = Store::new(
+            &engine,
+            CommandCtx {
+                table,
+                wasi,
+                sockets,
+            },
+        );
+
+        let (wasi, _instance) =
+            wasi::command::Command::instantiate_async(&mut store, &component, &linker).await?;
+
+        let result: Result<(), ()> = wasi.call_main(&mut store).await?;
+
+        if result.is_err() {
+            anyhow::bail!("command returned with failing exit status");
+        }
+
+        Ok(())
     } else if args.world == "proxy" {
-        run_proxy(&mut linker, &engine, &component, wasi_ctx).await?;
+        struct ProxyCtx {
+            table: Table,
+            wasi: WasiCtx,
+        }
+        impl WasiView for ProxyCtx {
+            fn table(&self) -> &Table {
+                &self.table
+            }
+            fn table_mut(&mut self) -> &mut Table {
+                &mut self.table
+            }
+            fn ctx(&self) -> &WasiCtx {
+                &self.wasi
+            }
+            fn ctx_mut(&mut self) -> &mut WasiCtx {
+                &mut self.wasi
+            }
+        }
+
+        let mut linker = Linker::new(&engine);
+        wasi::proxy::add_to_linker(&mut linker)?;
+
+        let mut store = Store::new(&engine, ProxyCtx { table, wasi });
+
+        let (wasi, _instance) =
+            wasi::proxy::Proxy::instantiate_async(&mut store, &component, &linker).await?;
+
+        // TODO: do something
+        let _ = wasi;
+        let result: Result<(), ()> = Ok(());
+
+        if result.is_err() {
+            anyhow::bail!("proxy returned with failing exit status");
+        }
+
+        Ok(())
+    } else {
+        anyhow::bail!("no such world {}", args.world)
     }
-
-    Ok(())
-}
-
-async fn run_command(
-    linker: &mut Linker<WasiCtx>,
-    engine: &Engine,
-    component: &Component,
-    wasi_ctx: WasiCtx,
-) -> anyhow::Result<()> {
-    wasi::command::add_to_linker(linker, |x| x)?;
-    let mut store = Store::new(engine, wasi_ctx);
-
-    let (wasi, _instance) =
-        wasi::command::Command::instantiate_async(&mut store, component, linker).await?;
-
-    let result: Result<(), ()> = wasi.call_main(&mut store).await?;
-
-    if result.is_err() {
-        anyhow::bail!("command returned with failing exit status");
-    }
-
-    Ok(())
-}
-
-async fn run_proxy(
-    linker: &mut Linker<WasiCtx>,
-    engine: &Engine,
-    component: &Component,
-    wasi_ctx: WasiCtx,
-) -> anyhow::Result<()> {
-    wasi::proxy::add_to_linker(linker, |x| x)?;
-
-    let mut store = Store::new(engine, wasi_ctx);
-
-    let (wasi, _instance) =
-        wasi::proxy::Proxy::instantiate_async(&mut store, component, linker).await?;
-
-    // TODO: do something
-    let _ = wasi;
-    let result: Result<(), ()> = Ok(());
-
-    if result.is_err() {
-        anyhow::bail!("proxy returned with failing exit status");
-    }
-
-    Ok(())
 }