Struct Request 

pub struct Request { /* private fields */ }

An HTTP request.

Implementations

impl Request

pub fn new() -> Request

Creates an empty request.

impl Request

pub fn with_payload(payload: Payload) -> Request

Creates a request with the supplied payload.

pub fn head(&self) -> &RequestHead

Returns the request head.

pub fn uri(&self) -> &Url

Returns the request URI.

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

Returns mutable access to the request URI.

pub fn method(&self) -> &Method

Returns the request method.

pub fn version(&self) -> Version

Returns the HTTP version.

pub fn path(&self) -> &str

Returns the path component of the request URI.

pub fn headers(&self) -> &HeaderMap

Returns the request headers.

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

Returns mutable access to the request headers.

pub fn upgrade(&self) -> bool

Returns whether this is an upgrade or CONNECT request.

pub fn io(&self) -> Option<&IoRef>

Returns the I/O object for the current connection, when available.

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

Returns the peer socket address.

Peer address is actual socket address, if proxy is used in front of ntex http server, then peer address would be address of this proxy.

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

Returns mutable access to the request payload.

pub fn take_payload(&mut self) -> Payload

Takes the request payload, leaving an empty payload behind.

pub fn replace_payload(&mut self, payload: Payload) -> Payload

Replaces the request payload and returns the previous value.

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

Returns the request extensions.

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

Returns mutable access to the request extensions.

Trait Implementations

impl Debug for Request

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

Formats the value using the given formatter.

impl Default for Request

fn default() -> Request

Returns the “default value” for a type.

impl HttpMessage for Request

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

Request extensions

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

Mutable reference to a the request’s extensions

fn message_headers(&self) -> &HeaderMap

Returns the message headers.

fn content_type(&self) -> &str

Returns the media type from the Content-Type header.

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

Returns the character encoding declared by Content-Type.

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

Parses the Content-Type header as a MIME type.

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

Returns whether Transfer-Encoding contains chunked.

fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, ParseError>

Parses and caches cookies from the Cookie headers.

fn cookie(&self, name: &str) -> Option<Cookie<'static>>

Returns the first request cookie with the given name.

impl<St, F> Service<St, Request> for AppService<St, F>

where St: State, F: Service<St, WebRequest<()>, Res = WebResponse, Error = WebError<St, St::Error>>,

type Res = Response

Response produced by the service.

type Error = <F as Service<St, WebRequest>>::Error

Error produced while checking readiness or processing a request.

async fn ready(&self, ctx: Ctx<'_, Self, St>) -> Result<(), Self::Error>

Waits until the service is ready to process a request.

async fn shutdown(&self, ctx: Ctx<'_, Self, St>)

Shuts down the service.

async fn call( &self, req: Request, ctx: Ctx<'_, Self, St>, ) -> Result<Self::Res, F::Error>

Processes a request and asynchronously returns the response.

fn map<F, Res>(self, f: F) -> ServiceChain<Map<F, Self, Res>, St, Req>

where Self: Sized, F: Fn(Self::Res) -> Res,

Maps this service’s output to a different type, returning a new service.

fn map_err<F, E>(self, f: F) -> ServiceChain<MapErr<F, Self, E>, St, Req>

where Self: Sized, F: Fn(Self::Error) -> E,

Maps this service’s error to a different type, returning a new service.

fn and_then<Next, F>(self, f: F) -> ServiceChain<AndThen<Self, Next>, St, Req>

where Self: Sized, Next: Service<St, Self::Res, Error = Self::Error>, F: IntoService<Next, St, Self::Res>,

Calls another service after this service completes successfully.

fn pipeline(self, st: St) -> Pipeline<Req, Self::Res, Self::Error>

where Self: Sized + 'static, St: 'static, Req: 'static,

Wraps this service and its state in a Pipeline.