Struct IncomingRequest

pub struct IncomingRequest { /* private fields */ }

Represents an incoming HTTP request.

If you don’t need streaming access to the request body, you may find it easier to work with Request instead. To make outgoing requests, use Request (non-streaming) or OutgoingRequest.

Examples

Access the request body as a Rust stream:

async fn handle_request(req: IncomingRequest, response_outparam: ResponseOutparam) {
    use futures::stream::StreamExt;

    let mut stream = req.into_body_stream();
    loop {
        let chunk = stream.next().await;
        match chunk {
            None => {
                println!("end of request body");
                break;
            }
            Some(Ok(chunk)) => {
                // process the data from the stream in a very realistic way
                println!("read {} bytes", chunk.len());
            }
            Some(Err(e)) => {
                println!("error reading body: {e:?}");
                break;
            }
        }
    }
}

Access the body in a non-streaming way. This can be useful where your component must take IncomingRequest because some scenarios need streaming, but you have other scenarios that do not.

async fn handle_request(req: IncomingRequest, response_outparam: ResponseOutparam) {
    let body = req.into_body().await.unwrap();
}

Represents an incoming HTTP Request.

Implementations

impl IncomingRequest

pub fn method(&self) -> Method

Returns the method of the incoming request.

impl IncomingRequest

pub fn path_with_query(&self) -> Option<String>

Returns the path with query parameters from the request, as a string.

impl IncomingRequest

pub fn scheme(&self) -> Option<Scheme>

Returns the protocol scheme from the request.

impl IncomingRequest

pub fn authority(&self) -> Option<String>

Returns the authority from the request, if it was present.

impl IncomingRequest

pub fn headers(&self) -> Headers

Get the headers associated with the request.

The returned headers resource is immutable: set, append, and delete operations will fail with header-error.immutable.

The headers returned are a child resource: it must be dropped before the parent incoming-request is dropped. Dropping this incoming-request before all children are dropped will trap.

impl IncomingRequest

pub fn consume(&self) -> Result<IncomingBody, ()>

Gives the incoming-body associated with this request. Will only return success at most once, and subsequent calls will return error.

impl IncomingRequest

pub fn uri(&self) -> String

The incoming request Uri

pub fn into_body_stream(self) -> impl Stream<Item = Result<Vec<u8>, Error>>

Return a Stream from which the body of the specified request may be read.

Panics

Panics if the body was already consumed.

pub async fn into_body(self) -> Result<Vec<u8>, Error>

Return a Vec<u8> of the body or fails

Trait Implementations

impl Debug for IncomingRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl TryFromIncomingRequest for IncomingRequest

type Error = Infallible

The error if conversion fails

fn try_from_incoming_request<'async_trait>( request: IncomingRequest, ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait,

Try to turn the IncomingRequest into the implementing type

impl WasmResource for IncomingRequest

unsafe fn drop(_handle: u32)

Invokes the [resource-drop]... intrinsic.