Struct rocket::Request[][src]

pub struct Request<'r> { /* fields omitted */ }

The type of an incoming web request.

This should be used sparingly in Rocket applications. In particular, it should likely only be used when writing FromRequest implementations. It contains all of the information for a given web request except for the body data. This includes the HTTP method, URI, cookies, headers, and more.


impl<'r> Request<'r>[src]

pub fn method(&self) -> Method[src]

Retrieve the method from self.


use rocket::http::Method;

assert_eq!(request.method(), Method::Get);

pub fn set_method(&mut self, method: Method)[src]

Set the method of self.


use rocket::http::Method;

assert_eq!(request.method(), Method::Get);

assert_eq!(request.method(), Method::Post);

pub fn uri(&self) -> &Origin<'_>[src]

Borrow the Origin URI from self.


assert_eq!(request.uri().path(), "/uri");

pub fn set_uri<'u: 'r>(&mut self, uri: Origin<'u>)[src]

Set the URI in self to uri.


use rocket::http::uri::Origin;

let uri = Origin::parse("/hello/Sergio?type=greeting").unwrap();
assert_eq!(request.uri().path(), "/hello/Sergio");
assert_eq!(request.uri().query().unwrap(), "type=greeting");

pub fn remote(&self) -> Option<SocketAddr>[src]

Returns the address of the remote connection that initiated this request if the address is known. If the address is not known, None is returned.

Because it is common for proxies to forward connections for clients, the remote address may contain information about the proxy instead of the client. For this reason, proxies typically set the “X-Real-IP” header with the client’s true IP. To extract this IP from the request, use the real_ip() or client_ip() methods.



pub fn set_remote(&mut self, address: SocketAddr)[src]

Sets the remote address of self to address.


Set the remote address to be

use std::net::{SocketAddr, IpAddr, Ipv4Addr};

let (ip, port) = (IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8000);
let localhost = SocketAddr::new(ip, port);

assert_eq!(request.remote(), Some(localhost));

pub fn real_ip(&self) -> Option<IpAddr>[src]

Returns the IP address in the “X-Real-IP” header of the request if such a header exists and contains a valid IP address.


request.add_header(Header::new("X-Real-IP", ""));
assert_eq!(request.real_ip(), Some("".parse().unwrap()));

pub fn client_ip(&self) -> Option<IpAddr>[src]

Attempts to return the client’s IP address by first inspecting the “X-Real-IP” header and then using the remote connection’s IP address.

If the “X-Real-IP” header exists and contains a valid IP address, that address is returned. Otherwise, if the address of the remote connection is known, that address is returned. Otherwise, None is returned.


// starting without an "X-Real-IP" header or remote addresss

// add a remote address; this is done by Rocket automatically
assert_eq!(request.client_ip(), Some("".parse().unwrap()));

// now with an X-Real-IP header
request.add_header(Header::new("X-Real-IP", ""));
assert_eq!(request.client_ip(), Some("".parse().unwrap()));

pub fn cookies(&self) -> &CookieJar<'r>[src]

Returns a wrapped borrow to the cookies in self.

CookieJar implements internal mutability, so this method allows you to get and add/remove cookies in self.


Add a new cookie to a request’s cookies:

use rocket::http::Cookie;

request.cookies().add(Cookie::new("key", "val"));
request.cookies().add(Cookie::new("ans", format!("life: {}", 38 + 4)));

pub fn headers(&self) -> &HeaderMap<'r>[src]

Returns a HeaderMap of all of the headers in self.


let header_map = request.headers();

pub fn add_header<'h: 'r, H: Into<Header<'h>>>(&mut self, header: H)[src]

Add header to self’s headers. The type of header can be any type that implements the Into<Header> trait. This includes common types such as ContentType and Accept.


use rocket::http::ContentType;


assert_eq!(request.headers().len(), 1);

pub fn replace_header<'h: 'r, H: Into<Header<'h>>>(&mut self, header: H)[src]

Replaces the value of the header with name with header.value. If no such header exists, header is added as a header to self.


use rocket::http::ContentType;


assert_eq!(request.headers().get_one("Content-Type"), Some("*/*"));
assert_eq!(request.content_type(), Some(&ContentType::Any));

assert_eq!(request.headers().get_one("Content-Type"), Some("image/png"));
assert_eq!(request.content_type(), Some(&ContentType::PNG));

pub fn content_type(&self) -> Option<&ContentType>[src]

Returns the Content-Type header of self. If the header is not present, returns None.


use rocket::http::ContentType;

assert_eq!(request.content_type(), Some(&ContentType::JSON));

pub fn accept(&self) -> Option<&Accept>[src]

Returns the Accept header of self. If the header is not present, returns None.


use rocket::http::Accept;

assert_eq!(request.accept(), Some(&Accept::JSON));

pub fn format(&self) -> Option<&MediaType>[src]

Returns the media type “format” of the request.

The “format” of a request is either the Content-Type, if the request methods indicates support for a payload, or the preferred media type in the Accept header otherwise. If the method indicates no payload and no Accept header is specified, a media type of Any is returned.

The media type returned from this method is used to match against the format route attribute.


use rocket::http::{Method, Accept, ContentType, MediaType};


assert_eq!(request.format(), Some(&MediaType::HTML));

assert_eq!(request.format(), Some(&MediaType::JSON));

pub fn config(&self) -> &'r Config[src]

Returns the Rocket server configuration.

pub fn limits(&self) -> &'r Limits[src]

Returns the configured application data limits.


let json_limit = request.limits().get("json");

pub fn route(&self) -> Option<&'r Route>[src]

Get the presently matched route, if any.

This method returns Some any time a handler or its guards are being invoked. This method returns None before routing has commenced; this includes during request fairing callbacks.


let route = request.route();

pub fn guard<'z, 'a, T>(&'a self) -> BoxFuture<'z, Outcome<T, T::Error>> where
    T: FromRequest<'a, 'r> + 'z,
    'a: 'z,
    'r: 'z, 

Invokes the request guard implementation for T, returning its outcome.


Assuming a User request guard exists, invoke it:

let outcome = request.guard::<User>();

pub fn managed_state<T>(&self) -> Option<&'r T> where
    T: Send + Sync + 'static, 

Retrieve managed state.


use rocket::State;

let pool = request.managed_state::<Pool>();

pub fn local_cache<T, F>(&self, f: F) -> &T where
    F: FnOnce() -> T,
    T: Send + Sync + 'static, 

Retrieves the cached value for type T from the request-local cached state of self. If no such value has previously been cached for this request, f is called to produce the value which is subsequently returned.

Different values of the same type cannot be cached without using a proxy, wrapper type. To avoid the need to write these manually, or for libraries wishing to store values of public types, use the local_cache! macro to generate a locally anonymous wrapper type, store, and retrieve the wrapped value from request-local cache.


// The first store into local cache for a given type wins.
let value = request.local_cache(|| "hello");
assert_eq!(*request.local_cache(|| "hello"), "hello");

// The following return the cached, previously stored value for the type.
assert_eq!(*request.local_cache(|| "goodbye"), "hello");

pub async fn local_cache_async<'a, T, F>(&'a self, fut: F) -> &'a T where
    F: Future<Output = T>,
    T: Send + Sync + 'static, 

Retrieves the cached value for type T from the request-local cached state of self. If no such value has previously been cached for this request, fut is awaited to produce the value which is subsequently returned.


async fn current_user<'r>(request: &Request<'r>) -> User {
    // Validate request for a given user, load from database, etc.

let user = request.local_cache_async(async {

pub fn param<'a, T>(&'a self, n: usize) -> Option<Result<T, T::Error>> where
    T: FromParam<'a>, 

Retrieves and parses into T the 0-indexed nth segment from the request. Returns None if n is greater than the number of segments. Returns Some(Err(T::Error)) if the parameter type T failed to be parsed from the nth dynamic parameter.

This method exists only to be used by manual routing. To retrieve parameters from a request, use Rocket’s code generation facilities.


use rocket::http::uri::Origin;

fn string<'s>(req: &'s mut Request, uri: &'static str, n: usize) -> &'s str {

        .and_then(|r| r.ok())

assert_eq!(string(req, "/", 0), "unnamed");
assert_eq!(string(req, "/a/b/this_one", 0), "a");
assert_eq!(string(req, "/a/b/this_one", 1), "b");
assert_eq!(string(req, "/a/b/this_one", 2), "this_one");
assert_eq!(string(req, "/a/b/this_one", 3), "unnamed");
assert_eq!(string(req, "/a/b/c/d/e/f/g/h", 7), "h");

pub fn segments<'a, T>(
    &'a self,
    n: RangeFrom<usize>
) -> Option<Result<T, T::Error>> where
    T: FromSegments<'a>, 

Retrieves and parses into T all of the path segments in the request URI beginning and including the 0-indexed nth non-empty segment. T must implement FromSegments, which is used to parse the segments.

This method exists only to be used by manual routing. To retrieve segments from a request, use Rocket’s code generation facilities.


If there are fewer than n non-empty segments, returns None. If parsing the segments failed, returns Some(Err(T:Error)).


use std::path::PathBuf;

use rocket::http::uri::Origin;

fn path<'s>(req: &'s mut Request, uri: &'static str, n: usize) -> PathBuf {

        .and_then(|r| r.ok())
        .unwrap_or_else(|| "whoops".into())

assert_eq!(path(req, "/", 0), PathBuf::from("whoops"));
assert_eq!(path(req, "/a/", 0), PathBuf::from("a"));
assert_eq!(path(req, "/a/b/c", 0), PathBuf::from("a/b/c"));
assert_eq!(path(req, "/a/b/c", 1), PathBuf::from("b/c"));
assert_eq!(path(req, "/a/b/c", 2), PathBuf::from("c"));
assert_eq!(path(req, "/a/b/c", 6), PathBuf::from("whoops"));

pub fn query_value<'a, T>(&'a self, name: &str) -> Option<Result<'a, T>> where
    T: FromForm<'a>, 

Retrieves and parses into T the query value with field name name. T must implement [FromFormValue], which is used to parse the query’s value. Key matching is performed case-sensitively. If there are multiple pairs with key key, the first one is returned.


This method exists only to be used by manual routing and should never be used in a regular Rocket application. It is much more expensive to use this method than to retrieve query parameters via Rocket’s codegen. To retrieve query values from a request, always prefer to use Rocket’s code generation facilities.


If a query segment with name name isn’t present, returns None. If parsing the value fails, returns Some(Err(T:Error)).


with_request("/?a=apple&z=zebra&a=aardvark", |req| {
    assert_eq!(req.query_value::<&str>("a").unwrap(), Ok("apple"));
    assert_eq!(req.query_value::<&str>("z").unwrap(), Ok("zebra"));
    assert_eq!(req.query_value::<&str>("b"), None);

    let a_seq = req.query_value::<Vec<&str>>("a").unwrap();
    assert_eq!(a_seq.unwrap(), ["apple", "aardvark"]);

#[derive(Debug, PartialEq, FromForm)]
struct Dog<'r> {
    name: &'r str,
    age: usize

with_request("/?", |req| {
    let dog = req.query_value::<Dog>("dog").unwrap().unwrap();
    assert_eq!(dog, Dog { name: "Max Fido", age: 3 });

Trait Implementations

impl Debug for Request<'_>[src]

impl Display for Request<'_>[src]

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

Pretty prints a Request. This is primarily used by Rocket’s logging infrastructure.

Auto Trait Implementations

impl<'r> !RefUnwindSafe for Request<'r>

impl<'r> Send for Request<'r>

impl<'r> Sync for Request<'r>

impl<'r> Unpin for Request<'r>

impl<'r> !UnwindSafe for Request<'r>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> IntoCollection<T> for T

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToString for T where
    T: Display + ?Sized

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,