Struct ProxyHandler 

pub struct ProxyHandler<S: HandlerState>(/* private fields */);

Available on crate feature component-model-async only.

Represents the state of a web server.

Note that this supports optional instance reuse, enabled when S::WorkerState::should_accept_request returns ShouldAccept::Yes more than once for a given instance. See WorkerState for details.

Implementations

impl<S> ProxyHandler<S>

where S: HandlerState,

pub fn new(state: S) -> Self

Create a new ProxyHandler with the specified application state and pre-instance.

pub async fn handle( &self, id: <S::WorkerState as WorkerState>::RequestId, request: Request, ) -> Result<Response, Error>

Handle the specified request, returning a response on success or the tuple of the request and error on failure.

This function will return a wasmtime::Error on failure, which may be downcast to a more specific type in certain scenarios:

• InstantiationError if a new worker was created to handle the request but could not instantiate the guest component.

• ExpirationError if the request expired before it produced a response. See WorkerState::on_request_start for details.

• TrapOrPanicError if the worker responsible for handling the request trapped or panicked before it produced a response. This may be used when a trap occurs but cannot be traced to a specific request, e.g. during concurrent request handling.

In other failure cases (e.g. wasi:http/types#error-code return values and/or traps when executing synchronous WASIp2 handler functions), the original error returned by the handler will be returned.

Backpressure

Note that this API does not implement any form of backpressure to limit the number of in-flight Requests being processed. This function may spawn new tokio tasks, instantiate new modules under new stores, and queue up pending Requests while waiting for previous instances. In all of these situations invoking this function will consume some host-side resources until the request is done.

Embedders using this API must ensure to take this into account. If an infinite number of requests can be fed into this function then it’s recommended to take a semaphore, for example, around this function call to limit the number of concurrent requests that are being processed.

pub fn state(&self) -> &S

Return a reference to the application state.

Trait Implementations

impl<S: HandlerState> Clone for ProxyHandler<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.