Struct WasiSocketsNamed 

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

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

This structure is similar in purpose to WasiSockets and is used when using the named_imports module for wasi:sockets. 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 WasiSocketsNamedView. The corresponding Data for this type is WasiCtxNamedView which internally will contain &mut T.

Effectively you’re going to implement WasiSocketsNamedView 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::sockets::*;
use wasmtime_wasi::p2::bindings::named_imports;
use std::collections::HashMap;

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

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::sockets::instance_network::add_to_linker::<MyStoreState, WasiSocketsNamed<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 WasiSocketsNamedView for MyStoreState {
    fn sockets(&mut self, id: NamedId) -> WasiSocketsCtxView<'_> {
        let ctx = self.states.get_mut(&id).expect("state for id");
        WasiSocketsCtxView {
            table: &mut self.table,
            ctx,
        }
    }
}

Trait Implementations

impl<T> HasData for WasiSocketsNamed<T>

where T: WasiSocketsNamedView,

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> HostTcpSocketWithStore<U> for WasiSocketsNamed<T>

where T: WasiSocketsNamedView, U: Send,

Available on crate feature p3 only.

async fn connect( store: &Accessor<U, Self>, id: NamedId, socket: Resource<TcpSocket>, remote_address: IpSocketAddress, ) -> SocketResult<()>

Connect to a remote endpoint.

async fn listen( store: Access<'_, U, Self>, id: NamedId, socket_resource: Resource<TcpSocket>, ) -> SocketResult<StreamReader<Resource<TcpSocket>>>

Start listening and return a stream of new inbound connections.

fn send( store: Access<'_, U, Self>, id: NamedId, socket: Resource<TcpSocket>, data: StreamReader<u8>, ) -> Result<FutureReader<Result<(), ErrorCode>>>

Transmit data to peer.

fn receive( store: Access<'_, U, Self>, id: NamedId, socket: Resource<TcpSocket>, ) -> Result<(StreamReader<u8>, FutureReader<Result<(), ErrorCode>>)>

Read data from peer.

impl<T, U> HostUdpSocketWithStore<U> for WasiSocketsNamed<T>

where T: WasiSocketsNamedView,

Available on crate feature p3 only.

async fn send( store: &Accessor<U, Self>, id: NamedId, socket: Resource<UdpSocket>, data: Vec<u8>, remote_address: Option<IpSocketAddress>, ) -> SocketResult<()>

Send a message on the socket to a particular peer.

async fn receive( store: &Accessor<U, Self>, id: NamedId, socket: Resource<UdpSocket>, ) -> SocketResult<(Vec<u8>, IpSocketAddress)>

Receive a message on the socket.

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

where T: WasiSocketsNamedView,

Available on crate feature p3 only.

async fn resolve_addresses( store: &Accessor<U, Self>, id: NamedId, name: String, ) -> Result<Result<Vec<IpAddress>, ErrorCode>>

Resolve an internet host name to a list of IP addresses.