Struct actix_http::Request

pub struct Request<P = BoxedPayloadStream> { /* private fields */ }

An HTTP request.

Implementations

impl Request<BoxedPayloadStream>

pub fn new() -> Request<BoxedPayloadStream>

Create new Request instance

impl<P> Request<P>

pub fn with_payload(payload: Payload<P>) -> Request<P>

Create new Request instance

pub fn replace_payload<P1>( self, payload: Payload<P1> ) -> (Request<P1>, Payload<P>)

Create new Request instance

pub fn payload(&mut self) -> &mut Payload<P>

Get request’s payload

pub fn take_payload(&mut self) -> Payload<P>

Get request’s payload

pub fn into_parts(self) -> (Message<RequestHead>, Payload<P>)

Split request into request head and payload

pub fn head(&self) -> &RequestHead

Http message part of the request

pub fn headers_mut(&mut self) -> &mut HeaderMap

Mutable reference to the message’s headers.

pub fn uri(&self) -> &Uri

Request’s uri.

pub fn uri_mut(&mut self) -> &mut Uri

Mutable reference to the request’s uri.

pub fn method(&self) -> &Method

Read the Request method.

pub fn version(&self) -> Version

Read the Request Version.

pub fn path(&self) -> &str

The target path of this Request.

pub fn upgrade(&self) -> bool

Check if request requires connection upgrade

pub fn peer_addr(&self) -> Option<SocketAddr>

Peer socket address.

Peer address is the directly connected peer’s socket address. If a proxy is used in front of the Actix Web server, then it would be address of this proxy.

Will only return None when called in unit tests.

pub fn conn_data<T: 'static>(&self) -> Option<&T>

Returns a reference a piece of connection data set in an on-connect callback.

let opt_t = req.conn_data::<PeerCertificate>();

pub fn take_conn_data(&mut self) -> Option<Rc<Extensions>>

Returns the connection-level data/extensions container if an on-connect callback was registered, leaving an empty one in its place.

pub fn take_req_data(&mut self) -> Extensions

Returns the request-local data/extensions container, leaving an empty one in its place.

Trait Implementations

impl<P> Debug for Request<P>

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

Formats the value using the given formatter.

impl From<Message<RequestHead>> for Request<BoxedPayloadStream>

fn from(head: Message<RequestHead>) -> Self

Converts to this type from the input type.

impl<P> HttpMessage for Request<P>

type Stream = P

Type of message payload stream

fn headers(&self) -> &HeaderMap

Read the message headers.

fn take_payload(&mut self) -> Payload<P>

Message payload stream

fn extensions(&self) -> Ref<'_, Extensions>

Returns a reference to the request-local data/extensions container.

fn extensions_mut(&self) -> RefMut<'_, Extensions>

Returns a mutable reference to the request-local data/extensions container.

fn content_type(&self) -> &str

Read the request content type. If request did not contain a Content-Type header, an empty string is returned.

fn encoding(&self) -> Result<&'static Encoding, ContentTypeError>

Get content type encoding.

fn mime_type(&self) -> Result<Option<Mime>, ContentTypeError>

Convert the request content type to a known mime type.

fn chunked(&self) -> Result<bool, ParseError>

Check if request has chunked transfer encoding.

impl Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>> for ExpectHandler

type Response = Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>

Responses given by the service.

type Error = Error

Errors produced by the service when polling readiness or executing call.

type Future = Ready<Result<<ExpectHandler as Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Response, <ExpectHandler as Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Error>>

The future response value.

fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Ready when the service is able to process requests.

fn call(&self, req: Request) -> Self::Future

Process the request and return the response asynchronously.

impl ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>> for ExpectHandler

type Response = Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>

Responses given by the created services.

type Error = Error

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = ExpectHandler

The kind of Service created by this factory.

type InitError = Error

Errors potentially raised while building a service.

type Future = Ready<Result<<ExpectHandler as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Service, <ExpectHandler as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::InitError>>

The future of the Service instance.g

fn new_service(&self, _: Self::Config) -> Self::Future

Create and return a new service asynchronously.