Struct WasiHttpNamed 

pub struct WasiHttpNamed<T>(/* private fields */);

A helper struct which implements HasData for the wasi:http APIs when used in combination with named imports.

This structure is similar in purpose to WasiHttp and is used when using the named_imports module for wasi:http. This structure serves as the D type parameter for add_to_linker functions.

Meaning of the T parameter

Here the T must be something that implements WasiHttpNamedView. The corresponding Data for this type is WasiCtxNamedView which internally will contain &mut T.

Effectively you’re going to implement WasiHttpNamedView for something in your embedding, and that’s the T you’ll fill in here.

Examples

use wasmtime::component::{Linker, Component, ResourceTable};
use wasmtime::{Engine, Result};
use wasmtime_wasi::{NamedId, WasiCtxNamedView};
use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpCtxView, WasiHttpNamed, WasiHttpNamedView};
use wasmtime_wasi_http::p2::bindings::named_imports;
use std::collections::HashMap;

struct MyStoreState {
    table: ResourceTable,
    states: HashMap<NamedId, WasiHttpCtx>,
}

fn main() -> Result<()> {
    let engine = Engine::default();
    let mut linker = Linker::new(&engine);
    let component = Component::new(&engine, "(component)")?;
    let mut name_map = HashMap::new();

    named_imports::wasi::http::outgoing_handler::add_to_linker::<MyStoreState, WasiHttpNamed<MyStoreState>>(
        &mut linker,
        &component,
        |name| {
            let len = name_map.len();
            Ok(NamedId(*name_map.entry(name.to_string()).or_insert(len)))
        },
        |state| WasiCtxNamedView(state),
    )?;
    Ok(())
}

impl WasiHttpNamedView for MyStoreState {
    fn http(&mut self, id: NamedId) -> WasiHttpCtxView<'_> {
        let ctx = self.states.get_mut(&id).expect("state for id");
        WasiHttpCtxView {
            ctx,
            table: &mut self.table,
            hooks: Default::default(),
        }
    }
}

Trait Implementations

impl<T> HasData for WasiHttpNamed<T>

where T: WasiHttpNamedView,

type Data<'a> = WasiCtxNamedView<'a, T>

The data associated with this trait implementation, chiefly used as a generic associated type to allow plumbing the 'a lifetime into the definition here.

impl<T, U> HostRequestWithStore<U> for WasiHttpNamed<T>

where T: WasiHttpNamedView, U: 'static,

Available on crate feature p3 only.

fn new( store: Access<'_, U, Self>, id: NamedId, headers: Resource<Headers>, contents: Option<StreamReader<u8>>, trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>, options: Option<Resource<RequestOptions>>, ) -> Result<(Resource<Request>, FutureReader<Result<(), ErrorCode>>)>

Construct a new request with a default method of GET, and none values for path-with-query, scheme, and authority.

fn consume_body( store: Access<'_, U, Self>, id: NamedId, req: Resource<Request>, fut: FutureReader<Result<(), ErrorCode>>, ) -> Result<(StreamReader<u8>, FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>)>

Get body of the Request.

fn drop( store: Access<'_, U, Self>, id: NamedId, req: Resource<Request>, ) -> Result<()>

impl<T, U> HostResponseWithStore<U> for WasiHttpNamed<T>

where T: WasiHttpNamedView, U: 'static,

Available on crate feature p3 only.

fn new( store: Access<'_, U, Self>, id: NamedId, headers: Resource<Headers>, contents: Option<StreamReader<u8>>, trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>, ) -> Result<(Resource<Response>, FutureReader<Result<(), ErrorCode>>)>

Construct a new response, with a default status-code of 200. If a different status-code is needed, it must be set via the set-status-code method.

fn consume_body( store: Access<'_, U, Self>, id: NamedId, res: Resource<Response>, fut: FutureReader<Result<(), ErrorCode>>, ) -> Result<(StreamReader<u8>, FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>)>

Get body of the Response.

fn drop( store: Access<'_, U, Self>, id: NamedId, res: Resource<Response>, ) -> Result<()>

impl<T, U> HostWithStore<U> for WasiHttpNamed<T>

where T: WasiHttpNamedView, U: 'static,

Available on crate feature p3 only.

async fn send( store: &Accessor<U, Self>, id: NamedId, req: Resource<Request>, ) -> Result<Resource<Response>, TrappableError<ErrorCode>>

This function may be used to either send an outgoing request over the network or to forward it to another component.