Wasmtime's WASI HTTP Implementation

This crate is Wasmtime's host implementation of the wasi:http package as part of WASIp2. This crate's implementation is primarily built on top of [hyper] and [tokio].

WASI HTTP Interfaces

This crate contains implementations of the following interfaces:

• wasi:http/incoming-handler
• wasi:http/outgoing-handler
• wasi:http/types

The crate also contains an implementation of the wasi:http/proxy world.

This crate is very similar to [wasmtime-wasi] in the it uses the bindgen! macro in Wasmtime to generate bindings to interfaces. Bindings are located in the [bindings] module.

The WasiHttpView trait

All bindgen!-generated Host traits are implemented in terms of a [WasiHttpView] trait which provides basic access to [WasiHttpCtx], configuration for WASI HTTP, and a [wasmtime_wasi::ResourceTable], the state for all host-defined component model resources.

The [WasiHttpView] trait additionally offers a few other configuration methods such as [WasiHttpView::send_request] to customize how outgoing HTTP requests are handled.

Async and Sync

There are both asynchronous and synchronous bindings in this crate. For example [add_to_linker_async] is for asynchronous embedders and [add_to_linker_sync] is for synchronous embedders. Note that under the hood both versions are implemented with async on top of [tokio].

Examples

Usage of this crate is done through a few steps to get everything hooked up:

1. First implement [WasiHttpView] for your type which is the T in [wasmtime::Store<T>].
2. Add WASI HTTP interfaces to a [wasmtime::component::Linker<T>]. There are a few options of how to do this:

• Use [add_to_linker_async] to bundle all interfaces in wasi:http/proxy together
• Use [add_only_http_to_linker_async] to add only HTTP interfaces but no others. This is useful when working with [wasmtime_wasi::add_to_linker_async] for example.
• Add individual interfaces such as with the [bindings::http::outgoing_handler::add_to_linker_get_host] function.

3. Use ProxyPre to pre-instantiate a component before serving requests.
4. When serving requests use ProxyPre::instantiate_async to create instances and handle HTTP requests.

A standalone example of doing all this looks like:

use anyhow::bail;
use hyper::server::conn::http1;
use std::sync::Arc;
use tokio::net::TcpListener;
use wasmtime::component::{Component, Linker, ResourceTable};
use wasmtime::{Config, Engine, Result, Store};
use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiView};
use wasmtime_wasi_http::bindings::ProxyPre;
use wasmtime_wasi_http::bindings::http::types::Scheme;
use wasmtime_wasi_http::body::HyperOutgoingBody;
use wasmtime_wasi_http::io::TokioIo;
use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};

#[tokio::main]
async fn main() -> Result<()> {
let component = std::env::args().nth(1).unwrap();

// Prepare the `Engine` for Wasmtime
let mut config = Config::new();
config.async_support(true);
let engine = Engine::new(&config)?;

// Compile the component on the command line to machine code
let component = Component::from_file(&engine, &component)?;

// Prepare the `ProxyPre` which is a pre-instantiated version of the
// component that we have. This will make per-request instantiation
// much quicker.
let mut linker = Linker::new(&engine);
wasmtime_wasi_http::add_to_linker_async(&mut linker)?;
let pre = ProxyPre::new(linker.instantiate_pre(&component)?)?;

// Prepare our server state and start listening for connections.
let server = Arc::new(MyServer { pre });
let listener = TcpListener::bind("127.0.0.1:8000").await?;
println!("Listening on {}", listener.local_addr()?);

loop {
// Accept a TCP connection and serve all of its requests in a separate
// tokio task. Note that for now this only works with HTTP/1.1.
let (client, addr) = listener.accept().await?;
println!("serving new client from {addr}");

let server = server.clone();
tokio::task::spawn(async move {
if let Err(e) = http1::Builder::new()
.keep_alive(true)
.serve_connection(
TokioIo::new(client),
hyper::service::service_fn(move |req| {
let server = server.clone();
async move { server.handle_request(req).await }
}),
)
.await
{
eprintln!("error serving client[{addr}]: {e:?}");
}
});
}
}

struct MyServer {
pre: ProxyPre<MyClientState>,
}

impl MyServer {
async fn handle_request(
&self,
req: hyper::Request<hyper::body::Incoming>,
) -> Result<hyper::Response<HyperOutgoingBody>> {
// Create per-http-request state within a `Store` and prepare the
// initial resources  passed to the `handle` function.
let mut store = Store::new(
self.pre.engine(),
MyClientState {
table: ResourceTable::new(),
wasi: WasiCtxBuilder::new().inherit_stdio().build(),
http: WasiHttpCtx::new(),
},
);
let (sender, receiver) = tokio::sync::oneshot::channel();
let req = store.data_mut().new_incoming_request(Scheme::Http, req)?;
let out = store.data_mut().new_response_outparam(sender)?;
let pre = self.pre.clone();

// Run the http request itself in a separate task so the task can
// optionally continue to execute beyond after the initial
// headers/response code are sent.
let task = tokio::task::spawn(async move {
let proxy = pre.instantiate_async(&mut store).await?;

if let Err(e) = proxy
.wasi_http_incoming_handler()
.call_handle(store, req, out)
.await
{
return Err(e);
}

Ok(())
});

match receiver.await {
// If the client calls `response-outparam::set` then one of these
// methods will be called.
Ok(Ok(resp)) => Ok(resp),
Ok(Err(e)) => Err(e.into()),

// Otherwise the `sender` will get dropped along with the `Store`
// meaning that the oneshot will get disconnected and here we can
// inspect the `task` result to see what happened
Err(_) => {
let e = match task.await {
Ok(r) => r.unwrap_err(),
Err(e) => e.into(),
};
bail!("guest never invoked `response-outparam::set` method: {e:?}")
}
}
}
}

struct MyClientState {
wasi: WasiCtx,
http: WasiHttpCtx,
table: ResourceTable,
}

impl WasiView for MyClientState {
fn ctx(&mut self) -> &mut WasiCtx {
&mut self.wasi
}
fn table(&mut self) -> &mut ResourceTable {
&mut self.table
}
}

impl WasiHttpView for MyClientState {
fn ctx(&mut self) -> &mut WasiHttpCtx {
&mut self.http
}
fn table(&mut self) -> &mut ResourceTable {
&mut self.table
}
}