Struct SourceHostState 

pub struct SourceHostState {
    pub table: ResourceTable,
    pub wasi: WasiCtx,
    pub request_rx: Arc<Mutex<Receiver<(HttpMeta, Receiver<Result<Bytes, CamelError>>)>>>,
    pub exchange_tx: Sender<(Exchange, Sender<SubmitOutcome>)>,
    pub cancel_token: CancellationToken,
    pub max_request_body_bytes: u64,
}

Host state for a source consumer. Lives inside the wasmtime::Store.

Separate from crate::runtime::WasmHostState because the source world has a fundamentally different lifecycle: the guest IS the source, owns a run loop, and communicates via channels rather than direct call-process.

request_rx is wrapped in Arc<tokio::sync::Mutex<…>> because the async host imports receive &Accessor (shared access), not &mut self; the Mutex provides the interior mutability needed to recv().await the receiver across import calls.

Fields

table: ResourceTable

wasi: WasiCtx

request_rx: Arc<Mutex<Receiver<(HttpMeta, Receiver<Result<Bytes, CamelError>>)>>>

exchange_tx: Sender<(Exchange, Sender<SubmitOutcome>)>

cancel_token: CancellationToken

max_request_body_bytes: u64

Maximum bytes the guest may read from a single request body before the stream producer terminates with an overflow error. Restores the DoS backstop that the old to_bytes(MAX_BODY_BYTES) path provided.

Trait Implementations

impl Host for SourceHostState

fn is_cancelled(&mut self) -> bool

Check if the host has cancelled the run loop. Stays sync — a quick peek that must not yield (called in tight guest loops).

impl HostHttpListener for SourceHostState

fn drop(&mut self, _resource: Resource<HttpListenerHandle>) -> Result<()>

impl HostWithStore<SourceHostState> for HasSelf<SourceHostState>

Async host imports. The guest’s run (async) awaits these; each receives &Accessor<SourceHostState, HasSelf<SourceHostState>> (shared access into the store, NOT &mut self). We snapshot owned values (clones) out of a with call, then .await OUTSIDE it — Accessor::with is sync and must not be held across an await. Cancellation races every await against the shared CancellationToken so stop() unblocks a parked import promptly.

async fn accept_http( accessor: &Accessor<SourceHostState, HasSelf<SourceHostState>>, _listener: Resource<HttpListenerHandle>, ) -> Result<Option<HttpRequest>, WasmError>

Accept the next HTTP request, or none if cancelled. Async: the guest awaits, yielding back to the host until a request arrives (or the run is cancelled). The body is a stream-body-handle — the guest reads incrementally via stream<u8>.read, removing the materialization cap.

async fn submit_exchange( accessor: &Accessor<SourceHostState, HasSelf<SourceHostState>>, exchange: WasmExchange, ) -> Result<SubmitOutcome, WasmError>

Push an exchange into the pipeline. Returns once the pipeline accepts the envelope (before full body drain). The guest MUST keep run alive while a submitted body stream is still draining; the stream’s terminal future resolves when the body finished.

impl WasiView for SourceHostState

fn ctx(&mut self) -> WasiCtxView<'_>

Yields mutable access to the WasiCtx configuration used for this context.