wasmtime-wasi-http 50.0.1

#[cfg(feature = "p2")]
use crate::p2::bindings::http::types as p2;
#[cfg(feature = "p3")]
use crate::p3::bindings::http::types as p3;
use crate::{DEFAULT_FORBIDDEN_HEADERS, Error, RequestOptions, Result};
use bytes::Bytes;
use http::{HeaderName, uri::Scheme};
use http_body_util::combinators::UnsyncBoxBody;
use std::marker;
use std::sync::{Arc, LazyLock};
use wasmtime::component::{HasData, ResourceTable};
use wasmtime_wasi::{NamedId, WasiCtxNamedView};

/// A helper struct which implements [`HasData`] for the `wasi:http` APIs.
///
/// This can be useful when directly calling `add_to_linker` functions directly,
/// such as [`wasmtime_wasi_http::p3::bindings::http::types::add_to_linker`] as
/// the `D` type parameter. See [`HasData`] for more information about the type
/// parameter's purpose.
///
/// When using this type you can skip the [`WasiHttpView`] trait, for example.
///
/// [`wasmtime_wasi_http::p3::bindings::http::types::add_to_linker`]: crate::p3::bindings::http::types::add_to_linker
///
/// # Examples
///
/// ```
/// use wasmtime::component::Linker;
/// use wasmtime::{Engine, Result};
/// use wasmtime_wasi_http::{WasiHttp, WasiHttpCtxView};
///
/// struct MyStoreState {
///     // ...
/// }
///
/// impl MyStoreState {
///     fn http(&mut self) -> WasiHttpCtxView<'_> {
///         // ...
/// #       todo!()
///     }
/// }
///
/// fn main() -> Result<()> {
///     let engine = Engine::default();
///     let mut linker = Linker::new(&engine);
///
///     wasmtime_wasi_http::p3::bindings::http::types::add_to_linker::<MyStoreState, WasiHttp>(
///         &mut linker,
///         |state| state.http(),
///     )?;
///     Ok(())
/// }
/// ```
pub struct WasiHttp;

impl HasData for WasiHttp {
    type Data<'a> = WasiHttpCtxView<'a>;
}

/// A trait which provides internal WASI HTTP state.
///
/// This trait is used by the [`add_to_linker`] convenience functions of this
/// crate. This trait can be implemented for the `T` in `Store<T>` to provide
/// access to wasi:http information at runtime.
///
/// [`add_to_linker`]: crate::p3::add_to_linker
///
/// # Example
///
/// ```
/// use wasmtime::component::ResourceTable;
/// use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView, WasiHttpCtxView};
///
/// struct MyState {
///     http_ctx: WasiHttpCtx,
///     table: ResourceTable,
/// }
///
/// impl WasiHttpView for MyState {
///     fn http(&mut self) -> WasiHttpCtxView<'_> {
///         WasiHttpCtxView {
///             ctx: &mut self.http_ctx,
///             table: &mut self.table,
///             hooks: Default::default(),
///         }
///     }
/// }
/// ```
pub trait WasiHttpView: Send {
    /// Return a [WasiHttpCtxView] from mutable reference to self.
    fn http(&mut self) -> WasiHttpCtxView<'_>;
}

/// Basis of implementation of all `wasi:http` APIs in this crate.
///
/// This type provides a temporary view into information such as a WASI
/// resource table, HTTP context information, and embedder-provided hooks if
/// so desired. THe fields in this structure are typically stored within the
/// `T` of `Store<T>` and this struct borrows from there. All `Host` traits
/// generated by `bindgen!` are implemented for this type.
pub struct WasiHttpCtxView<'a> {
    /// Mutable reference to the WASI HTTP hooks.
    ///
    /// Note that [`default_hooks`] or [`Default::default()`] can be used if
    /// you don't want or need to customize this.
    pub hooks: &'a mut dyn WasiHttpHooks,

    /// Mutable reference to table used to manage resources.
    pub table: &'a mut ResourceTable,

    /// Mutable reference to the WASI HTTP context.
    pub ctx: &'a mut WasiHttpCtx,
}

/// Default maximum size for the contents of a fields resource.
///
/// Typically, HTTP proxies limit headers to 8k. This number is higher than that
/// because it not only includes the wire-size of headers but it additionally
/// includes factors for the in-memory representation of `HeaderMap`. This is in
/// theory high enough that no one runs into it but low enough such that a
/// completely full `HeaderMap` doesn't break the bank in terms of memory
/// consumption.
const DEFAULT_FIELD_SIZE_LIMIT: usize = 128 * 1024;

/// Capture the state necessary for use in the wasi-http API implementation.
#[derive(Debug, Clone)]
pub struct WasiHttpCtx {
    pub(crate) field_size_limit: usize,
}

impl WasiHttpCtx {
    /// Create a new context.
    pub fn new() -> Self {
        Self {
            field_size_limit: DEFAULT_FIELD_SIZE_LIMIT,
        }
    }

    /// Set the maximum size for any fields resources created by this context.
    ///
    /// The limit specified here is roughly a byte limit for the size of the
    /// in-memory representation of headers. This means that the limit needs to
    /// be larger than the literal representation of headers on the wire to
    /// account for in-memory Rust-side data structures representing the header
    /// names/values/etc.
    pub fn set_field_size_limit(&mut self, limit: usize) {
        self.field_size_limit = limit;
    }
}

impl Default for WasiHttpCtx {
    fn default() -> Self {
        Self::new()
    }
}

/// Convenience type definition for the bodies used in this crate.
pub type WasiBody = UnsyncBoxBody<Bytes, Error>;

/// A cloneable predicate deciding whether a header name is forbidden. This
/// predicate needs to be executed in tasks which do not have access to the
/// store.
pub type ForbiddenHeaderFilter = Arc<dyn Fn(&HeaderName) -> bool + Send + Sync>;

/// A trait which provides hooks into internal WASI HTTP operations.
///
/// Note that when using this type if state is needed to implement the methods
/// the state will need to be stored separately in a distinct structure to
/// implement this trait as the same type can't implement both [`WasiHttpView`]
/// and [`WasiHttpHooks`] and be usable.
///
/// # Example
///
/// ```
/// use wasmtime::component::ResourceTable;
/// use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView, WasiHttpCtxView, WasiHttpHooks};
///
/// struct MyState {
///     http_ctx: WasiHttpCtx,
///     table: ResourceTable,
///     hooks: MyHooks,
/// }
///
/// impl MyState {
///     fn new() -> MyState {
///         MyState {
///             table: ResourceTable::new(),
///             http_ctx: WasiHttpCtx::new(),
///             hooks: MyHooks,
///         }
///     }
/// }
///
/// impl WasiHttpView for MyState {
///     fn http(&mut self) -> WasiHttpCtxView<'_> {
///         WasiHttpCtxView {
///             ctx: &mut self.http_ctx,
///             table: &mut self.table,
///             hooks: &mut self.hooks,
///         }
///     }
/// }
///
/// struct MyHooks;
///
/// impl WasiHttpHooks for MyHooks {
///     fn forbidden_header_filter(&mut self) -> wasmtime_wasi_http::ForbiddenHeaderFilter {
///         std::sync::Arc::new(|name| {
///             *name == http::header::AUTHORIZATION ||
///                 wasmtime_wasi_http::DEFAULT_FORBIDDEN_HEADERS.contains(name)
///         })
///     }
/// }
/// ```
pub trait WasiHttpHooks: Send {
    /// Returns a predicate deciding whether a given header should be
    /// considered forbidden and not allowed.
    ///
    /// The predicate applies to header and trailer fields crossing the guest
    /// boundary in either direction. It may be retained and invoked after the
    /// store has been dropped, e.g. for trailers of a host body forwarded by a
    /// guest, so it is obtained as a value rather than called on `self`.
    ///
    /// The default forbids [`DEFAULT_FORBIDDEN_HEADERS`].
    fn forbidden_header_filter(&mut self) -> ForbiddenHeaderFilter {
        static DEFAULT: LazyLock<ForbiddenHeaderFilter> =
            LazyLock::new(|| Arc::new(|name| DEFAULT_FORBIDDEN_HEADERS.contains(name)));
        DEFAULT.clone()
    }

    /// Whether a given scheme should be considered supported.
    ///
    /// `handle` will return [Error::HttpProtocolError] for unsupported schemes.
    fn is_supported_scheme(&mut self, scheme: &Scheme) -> bool {
        *scheme == Scheme::HTTP || *scheme == Scheme::HTTPS
    }

    /// Whether to set `host` header in the request passed to `send_request`.
    fn set_host_header(&mut self) -> bool {
        true
    }

    /// Scheme to default to, when not set by the guest.
    ///
    /// If [None], `handle` will return [Error::HttpProtocolError]
    /// for requests missing a scheme.
    fn default_scheme(&mut self) -> Option<Scheme> {
        Some(Scheme::HTTPS)
    }

    /// Send an outgoing request.
    ///
    /// This function will be used by the `wasi:http/handler#handle` implementation.
    ///
    /// The specified [Future] `fut` will be used to communicate
    /// a response processing error, if any.
    /// For example, if the response body is consumed via `wasi:http/types.response#consume-body`,
    /// a result will be sent on `fut`.
    ///
    /// The returned [Future] can be used to communicate
    /// a request processing error, if any, to the constructor of the request.
    /// For example, if the request was constructed via `wasi:http/types.request#new`,
    /// a result resolved from it will be forwarded to the guest on the future handle returned.
    ///
    /// `Content-Length` of the request passed to this function will be validated, however no
    /// `Content-Length` validation will be performed for the received response.
    #[cfg(feature = "default-send-request")]
    fn send_request(
        &mut self,
        request: http::Request<WasiBody>,
        options: Option<RequestOptions>,
        fut: Box<dyn Future<Output = Result<(), Error>> + Send>,
    ) -> Box<
        dyn Future<
                Output = Result<(
                    http::Response<WasiBody>,
                    Box<dyn Future<Output = Result<(), Error>> + Send>,
                )>,
            > + Send,
    > {
        _ = fut;
        Box::new(async move {
            use http_body_util::BodyExt;

            let (res, io) = crate::default_send_request(request, options).await?;
            Ok((
                res.map(BodyExt::boxed_unsync),
                Box::new(io) as Box<dyn Future<Output = _> + Send>,
            ))
        })
    }

    /// Send an outgoing request.
    ///
    /// This function will be used by the `wasi:http/handler#handle` implementation.
    ///
    /// The specified [Future] `fut` will be used to communicate
    /// a response processing error, if any.
    /// For example, if the response body is consumed via `wasi:http/types.response#consume-body`,
    /// a result will be sent on `fut`.
    ///
    /// The returned [Future] can be used to communicate
    /// a request processing error, if any, to the constructor of the request.
    /// For example, if the request was constructed via `wasi:http/types.request#new`,
    /// a result resolved from it will be forwarded to the guest on the future handle returned.
    ///
    /// `Content-Length` of the request passed to this function will be validated, however no
    /// `Content-Length` validation will be performed for the received response.
    #[cfg(not(feature = "default-send-request"))]
    fn send_request(
        &mut self,
        request: http::Request<WasiBody>,
        options: Option<RequestOptions>,
        fut: Box<dyn Future<Output = Result<(), Error>> + Send>,
    ) -> Box<
        dyn Future<
                Output = Result<(
                    http::Response<WasiBody>,
                    Box<dyn Future<Output = Result<(), Error>> + Send>,
                )>,
            > + Send,
    >;

    /// Number of distinct write calls to the outgoing body's output-stream
    /// that the implementation will buffer.
    /// Default: 1.
    #[cfg(feature = "p2")]
    fn p2_outgoing_body_buffer_chunks(&mut self) -> usize {
        crate::p2::DEFAULT_OUTGOING_BODY_BUFFER_CHUNKS
    }

    /// Maximum size allowed in a write call to the outgoing body's
    /// output-stream.  Default: 1024 * 1024.
    #[cfg(feature = "p2")]
    fn p2_outgoing_body_chunk_size(&mut self) -> usize {
        crate::p2::DEFAULT_OUTGOING_BODY_CHUNK_SIZE
    }

    /// Optional hook to configure the error code for hyper errors.
    #[cfg(feature = "p2")]
    fn p2_error_from_hyper(&mut self, err: &hyper::Error) -> p2::ErrorCode {
        tracing::warn!("hyper error: {err:?}");
        p2::ErrorCode::HttpProtocolError
    }

    /// Optional hook to configure the error code for connect I/O errors.
    ///
    /// The default distinguishes refused, unreachable, timed out, and terminated
    /// connections. Unrecognized errors become `connection-refused`.
    #[cfg(feature = "p2")]
    fn p2_error_from_connect(&mut self, err: &std::io::Error) -> p2::ErrorCode {
        tracing::warn!("connect error: {err:?}");
        use std::io::ErrorKind;
        match err.kind() {
            ErrorKind::ConnectionRefused => p2::ErrorCode::ConnectionRefused,
            ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable | ErrorKind::NetworkDown => {
                p2::ErrorCode::DestinationUnavailable
            }
            ErrorKind::TimedOut => p2::ErrorCode::ConnectionTimeout,
            ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted => {
                p2::ErrorCode::ConnectionTerminated
            }
            _ if is_address_family_unsupported(err) => p2::ErrorCode::DestinationUnavailable,
            _ => p2::ErrorCode::ConnectionRefused,
        }
    }

    /// Optional hook to configure the error code for TLS I/O errors.
    ///
    /// The default distinguishes terminated connections and, with the
    /// `default-send-request` feature, rustls certificate errors and received
    /// alerts. Other errors become `TLS-protocol-error`.
    #[cfg(feature = "p2")]
    fn p2_error_from_tls(&mut self, err: &std::io::Error) -> p2::ErrorCode {
        tracing::warn!("tls error: {err:?}");
        #[cfg(feature = "default-send-request")]
        if let Some(err) = err
            .get_ref()
            .and_then(|err| err.downcast_ref::<rustls::Error>())
        {
            return match err {
                rustls::Error::InvalidCertificate(_) => p2::ErrorCode::TlsCertificateError,
                rustls::Error::AlertReceived(alert) => {
                    p2::ErrorCode::TlsAlertReceived(p2::TlsAlertReceivedPayload {
                        alert_id: Some(u8::from(*alert)),
                        alert_message: None,
                    })
                }
                _ => p2::ErrorCode::TlsProtocolError,
            };
        }
        match err.kind() {
            std::io::ErrorKind::ConnectionReset
            | std::io::ErrorKind::ConnectionAborted
            | std::io::ErrorKind::BrokenPipe
            | std::io::ErrorKind::UnexpectedEof => p2::ErrorCode::ConnectionTerminated,
            _ => p2::ErrorCode::TlsProtocolError,
        }
    }

    /// Optional hook to configure the error code for DNS errors.
    #[cfg(all(feature = "p2", feature = "default-send-request"))]
    fn p2_error_from_dns(&mut self, err: &rustls::pki_types::InvalidDnsNameError) -> p2::ErrorCode {
        tracing::warn!("dns lookup error: {err:?}");
        p2::ErrorCode::DnsError(p2::DnsErrorPayload {
            rcode: Some("invalid dns name".to_string()),
            info_code: None,
        })
    }

    /// Maximum number of bytes the implementation will copy out of the guest in
    /// a single write to an outgoing body's stream.
    #[cfg(feature = "p3")]
    fn p3_outgoing_body_chunk_size(&mut self) -> usize {
        crate::p3::DEFAULT_OUTGOING_BODY_CHUNK_SIZE
    }

    /// Optional hook to configure the error code for hyper errors.
    #[cfg(feature = "p3")]
    fn p3_error_from_hyper(&mut self, err: &hyper::Error) -> p3::ErrorCode {
        tracing::warn!("hyper error: {err:?}");
        p3::ErrorCode::HttpProtocolError
    }

    /// Optional hook to configure the error code for connect I/O errors.
    ///
    /// The default distinguishes refused, unreachable, timed out, and terminated
    /// connections. Unrecognized errors become `connection-refused`.
    #[cfg(feature = "p3")]
    fn p3_error_from_connect(&mut self, err: &std::io::Error) -> p3::ErrorCode {
        tracing::warn!("connect error: {err:?}");
        use std::io::ErrorKind;
        match err.kind() {
            ErrorKind::ConnectionRefused => p3::ErrorCode::ConnectionRefused,
            ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable | ErrorKind::NetworkDown => {
                p3::ErrorCode::DestinationUnavailable
            }
            ErrorKind::TimedOut => p3::ErrorCode::ConnectionTimeout,
            ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted => {
                p3::ErrorCode::ConnectionTerminated
            }
            _ if is_address_family_unsupported(err) => p3::ErrorCode::DestinationUnavailable,
            _ => p3::ErrorCode::ConnectionRefused,
        }
    }

    /// Optional hook to configure the error code for TLS I/O errors.
    ///
    /// The default distinguishes terminated connections and, with the
    /// `default-send-request` feature, rustls certificate errors and received
    /// alerts. Other errors become `TLS-protocol-error`.
    #[cfg(feature = "p3")]
    fn p3_error_from_tls(&mut self, err: &std::io::Error) -> p3::ErrorCode {
        tracing::warn!("tls error: {err:?}");
        #[cfg(feature = "default-send-request")]
        if let Some(err) = err
            .get_ref()
            .and_then(|err| err.downcast_ref::<rustls::Error>())
        {
            return match err {
                rustls::Error::InvalidCertificate(_) => p3::ErrorCode::TlsCertificateError,
                rustls::Error::AlertReceived(alert) => {
                    p3::ErrorCode::TlsAlertReceived(p3::TlsAlertReceivedPayload {
                        alert_id: Some(u8::from(*alert)),
                        alert_message: None,
                    })
                }
                _ => p3::ErrorCode::TlsProtocolError,
            };
        }
        match err.kind() {
            std::io::ErrorKind::ConnectionReset
            | std::io::ErrorKind::ConnectionAborted
            | std::io::ErrorKind::BrokenPipe
            | std::io::ErrorKind::UnexpectedEof => p3::ErrorCode::ConnectionTerminated,
            _ => p3::ErrorCode::TlsProtocolError,
        }
    }

    /// Optional hook to configure the error code for DNS errors.
    #[cfg(all(feature = "p3", feature = "default-send-request"))]
    fn p3_error_from_dns(&mut self, err: &rustls::pki_types::InvalidDnsNameError) -> p3::ErrorCode {
        tracing::warn!("dns lookup error: {err:?}");
        p3::ErrorCode::DnsError(p3::DnsErrorPayload {
            rcode: Some("invalid dns name".to_string()),
            info_code: None,
        })
    }
}

// EAFNOSUPPORT has no corresponding stable ErrorKind.
#[cfg(any(feature = "p2", feature = "p3"))]
fn is_address_family_unsupported(err: &std::io::Error) -> bool {
    use rustix::io::Errno;
    Errno::from_io_error(err) == Some(Errno::AFNOSUPPORT)
}

/// Returns a value suitable for the `WasiHttpCtxView::hooks` field which has
/// the default behavior for `wasi:http`.
#[cfg(feature = "default-send-request")]
pub fn default_hooks() -> &'static mut dyn WasiHttpHooks {
    Default::default()
}

#[cfg(feature = "default-send-request")]
impl<'a> Default for &'a mut dyn WasiHttpHooks {
    fn default() -> Self {
        let x: &mut [(); 0] = &mut [];
        x
    }
}

#[doc(hidden)]
#[cfg(feature = "default-send-request")]
impl WasiHttpHooks for [(); 0] {}

/// 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.
///
/// [`named_imports`]: crate::p3::bindings::named_imports::wasi::http
///
/// # 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(),
///         }
///     }
/// }
/// ```
pub struct WasiHttpNamed<T>(marker::PhantomData<fn() -> T>);

impl<T> HasData for WasiHttpNamed<T>
where
    T: WasiHttpNamedView,
{
    type Data<'a> = WasiCtxNamedView<'a, T>;
}

/// A trait used to look up a specific `wasi:http` context for a named import.
///
/// This trait is used in conjunction with the [`named_imports`] bindings
/// generated for all `wasi:http` interfaces. The purpose of this trait is for
/// embedders to define how a [`NamedId`] maps to a particular `wasi:http`
/// context, here returned as [`WasiHttpCtxView`]. Embedders are responsible
/// for assigning meaning to [`NamedId`] values themselves. These IDs are
/// assigned when [`add_named_to_linker`] is called, for example, as the
/// `lookup` argument to that function.
///
/// When using [`add_named_to_linker`] it's sufficient to implement this trait
/// for the `T` in `Store<T>`.
///
/// When using `add_to_linker` in the generated `bindings::named_imports`
/// module then values implementing this live within the `T` of `Store<T>`, and
/// be temporarily referenced in [`WasiCtxNamedView`] where internally that'll
/// hold `WasiCtxNamedView(&mut your_type)`.
///
/// [`named_imports`]: crate::p3::bindings::named_imports
/// [`add_named_to_linker`]: crate::p3::add_named_to_linker
///
/// # Examples
///
/// ```
/// use wasmtime::component::{Linker, Component, ResourceTable};
/// use wasmtime::{Engine, Result};
/// use wasmtime_wasi::NamedId;
/// use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpCtxView, WasiHttpNamedView};
/// 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();
///
///     wasmtime_wasi_http::p3::add_named_to_linker::<MyStoreState>(
///         &mut linker,
///         &component,
///         |_, name| {
///             let len = name_map.len();
///             Ok(NamedId(*name_map.entry(name.to_string()).or_insert(len)))
///         },
///     )?;
///     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(),
///         }
///     }
/// }
/// ```
pub trait WasiHttpNamedView: Send + 'static {
    /// Looks up the [`WasiHttpCtxView`] for the given [`NamedId`].
    ///
    /// This method will resolve the `id` specified to a specific HTTP context
    /// that is available to be used. Note that this method is specifically
    /// infallible meaning that an HTTP context must be returned and this cannot
    /// generate a trap or panic or similar.
    ///
    /// Embedders are responsible for allocating [`NamedId`] and assigning
    /// meaning to ids. When a `Linker` is populated embedders will have the
    /// ability to generate a `NamedId` for all imports found, and then that
    /// embedder-allocated id is then passed back here when the corresponding
    /// imported function is invoked.
    ///
    /// Note that the [`ResourceTable`] referenced in the returned
    /// [`WasiHttpCtxView`] need not be unique. It's ok to use the same
    /// [`ResourceTable`] for all imports. This is not a guest-visible
    /// abstraction and just helps the host allocate and manage state.
    fn http(&mut self, id: NamedId) -> WasiHttpCtxView<'_>;
}