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,
    pub pending_principal: Option<AuthenticatedPrincipal>,
    pub accept_outstanding: bool,
}

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.

pending_principal: Option<AuthenticatedPrincipal>

Principal minted at the host edge for the most recently accepted, not-yet-submitted request (Task 2.1). Stashed by accept_http, consumed by submit_exchange when the typed carrier is installed on the native Exchange. None while no request is in flight or when the edge handshake minted no principal.

accept_outstanding: bool

One-outstanding-request invariant marker: an accept-http returned without an intervening submit-exchange. While set, a further accept-http fails closed instead of overwriting pending_principal — the WIT contract does not force accept/submit alternation, so the host enforces it for identity integrity.

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.