Struct Request 

pub struct Request { /* private fields */ }

Incoming HTTP request with an attached per-request Context.

Implementations

impl Request

pub fn ctx(&self) -> &Context

Read-only access to the per-request Context.

Examples found in repository

examples/homepage.rs (line 27)

async fn logger(req: Request, next: Next) -> Result<Response, Error> {
    let method = req.method().clone();
    let path = req.uri().path().to_owned();
    let id = req.ctx().get::<RequestId>().map(|r| r.0);
    let user = rustio_core::auth::identity(req.ctx()).map(|i| i.user_id.clone());
    let started = Instant::now();
    let result = next.run(req).await;
    let status = match &result {
        Ok(resp) => resp.status().as_u16(),
        Err(err) => err.status(),
    };
    let id_display = id.map(|i| format!("req-{i}")).unwrap_or_else(|| "-".into());
    let user_display = user.unwrap_or_else(|| "-".into());
    eprintln!(
        "[{:>3}] {:>4} {} id={} user={} ({:?})",
        status,
        method,
        path,
        id_display,
        user_display,
        started.elapsed()
    );
    result
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    let router = with_defaults(Router::new())
        .get("/whoami", |req, _params| async move {
            let id = req
                .ctx()
                .get::<RequestId>()
                .map(|r| r.0.to_string())
                .unwrap_or_else(|| "unknown".into());
            Ok::<Response, Error>(text(format!("your request id is req-{id}\n")))
        })
        .get("/me", |req, _params| async move {
            let id = require_auth(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello {}\n", id.user_id)))
        })
        .get("/admin-only", |req, _params| async move {
            let id = require_admin(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello admin {}\n", id.user_id)))
        })
        .get("/crash", |_req, _params| async {
            Err::<Response, Error>(Error::Internal("simulated failure".into()))
        })
        .get("/unauth", |_req, _params| async {
            Err::<Response, Error>(Error::Unauthorized)
        })
        .wrap(request_id)
        .wrap(authenticate)
        .wrap(logger);
    Server::bind(addr).serve_router(router).await
}

pub fn ctx_mut(&mut self) -> &mut Context

Mutable access to the per-request Context.

Examples found in repository

examples/homepage.rs (line 16)

async fn request_id(mut req: Request, next: Next) -> Result<Response, Error> {
    let id = REQUEST_COUNTER.fetch_add(1, Ordering::Relaxed);
    req.ctx_mut().insert(RequestId(id));
    let mut resp = resolve(next.run(req).await);
    if let Ok(header) = format!("req-{id}").parse() {
        resp.headers_mut().insert("x-request-id", header);
    }
    Ok(resp)
}

pub fn query(&self) -> FormData

Parse the URL query string into a FormData.

Returns an empty FormData when the request has no query string.

pub fn into_parts(self) -> (Parts, Incoming, Context)

Consume this request, returning the underlying hyper parts, body, and the attached context.

Methods from Deref<Target = Request<Incoming>>

pub fn method(&self) -> &Method

Returns a reference to the associated HTTP method.

Examples

let request: Request<()> = Request::default();
assert_eq!(*request.method(), Method::GET);

Examples found in repository

examples/homepage.rs (line 25)

async fn logger(req: Request, next: Next) -> Result<Response, Error> {
    let method = req.method().clone();
    let path = req.uri().path().to_owned();
    let id = req.ctx().get::<RequestId>().map(|r| r.0);
    let user = rustio_core::auth::identity(req.ctx()).map(|i| i.user_id.clone());
    let started = Instant::now();
    let result = next.run(req).await;
    let status = match &result {
        Ok(resp) => resp.status().as_u16(),
        Err(err) => err.status(),
    };
    let id_display = id.map(|i| format!("req-{i}")).unwrap_or_else(|| "-".into());
    let user_display = user.unwrap_or_else(|| "-".into());
    eprintln!(
        "[{:>3}] {:>4} {} id={} user={} ({:?})",
        status,
        method,
        path,
        id_display,
        user_display,
        started.elapsed()
    );
    result
}

pub fn method_mut(&mut self) -> &mut Method

Returns a mutable reference to the associated HTTP method.

Examples

let mut request: Request<()> = Request::default();
*request.method_mut() = Method::PUT;
assert_eq!(*request.method(), Method::PUT);

pub fn uri(&self) -> &Uri

Returns a reference to the associated URI.

Examples

let request: Request<()> = Request::default();
assert_eq!(*request.uri(), *"/");

Examples found in repository

examples/homepage.rs (line 26)

async fn logger(req: Request, next: Next) -> Result<Response, Error> {
    let method = req.method().clone();
    let path = req.uri().path().to_owned();
    let id = req.ctx().get::<RequestId>().map(|r| r.0);
    let user = rustio_core::auth::identity(req.ctx()).map(|i| i.user_id.clone());
    let started = Instant::now();
    let result = next.run(req).await;
    let status = match &result {
        Ok(resp) => resp.status().as_u16(),
        Err(err) => err.status(),
    };
    let id_display = id.map(|i| format!("req-{i}")).unwrap_or_else(|| "-".into());
    let user_display = user.unwrap_or_else(|| "-".into());
    eprintln!(
        "[{:>3}] {:>4} {} id={} user={} ({:?})",
        status,
        method,
        path,
        id_display,
        user_display,
        started.elapsed()
    );
    result
}

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

Returns a mutable reference to the associated URI.

Examples

let mut request: Request<()> = Request::default();
*request.uri_mut() = "/hello".parse().unwrap();
assert_eq!(*request.uri(), *"/hello");

pub fn version(&self) -> Version

Returns the associated version.

Examples

let request: Request<()> = Request::default();
assert_eq!(request.version(), Version::HTTP_11);

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the associated version.

Examples

let mut request: Request<()> = Request::default();
*request.version_mut() = Version::HTTP_2;
assert_eq!(request.version(), Version::HTTP_2);

pub fn headers(&self) -> &HeaderMap

Returns a reference to the associated header field map.

Examples

let request: Request<()> = Request::default();
assert!(request.headers().is_empty());

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

Returns a mutable reference to the associated header field map.

Examples

let mut request: Request<()> = Request::default();
request.headers_mut().insert(HOST, HeaderValue::from_static("world"));
assert!(!request.headers().is_empty());

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

Examples

let request: Request<()> = Request::default();
assert!(request.extensions().get::<i32>().is_none());

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

Examples

let mut request: Request<()> = Request::default();
request.extensions_mut().insert("hello");
assert_eq!(request.extensions().get(), Some(&"hello"));

pub fn body(&self) -> &T

Returns a reference to the associated HTTP body.

Examples

let request: Request<String> = Request::default();
assert!(request.body().is_empty());

pub fn body_mut(&mut self) -> &mut T

Returns a mutable reference to the associated HTTP body.

Examples

let mut request: Request<String> = Request::default();
request.body_mut().push_str("hello world");
assert!(!request.body().is_empty());

Trait Implementations

impl Deref for Request

type Target = Request<Incoming>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Request

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.