Module rustful::context [] [src]

Handler context and request body reading extensions.


The Context contains all the input data for the request handlers, as well as some utilities. This is where request data, like headers, client address and the request body can be retrieved from and it can safely be picked apart, since its ownership is transferred to the handler.

##Accessing Headers

The headers are stored in the headers field. See the Headers struct for more information about how to access them.

use rustful::{Context, Response};
use rustful::header::UserAgent;

fn my_handler(context: Context, response: Response) {
    if let Some(&UserAgent(ref user_agent)) = context.headers.get() {
        response.send(format!("got user agent string \"{}\"", user_agent));
    } else {
        response.send("no user agent string provided");

##Path Variables

A router may collect variable data from paths (for example id in /products/:id). The values from these variables can be accessed through the variables field.

use rustful::{Context, Response};

fn my_handler(context: Context, response: Response) {
    if let Some(id) = context.variables.get("id") {
        response.send(format!("asking for product with id \"{}\"", id));
    } else {
        //This will usually not happen, unless the handler is also
        //assigned to a path without the `id` variable
        response.send("no id provided");

##Other URL Parts

##Global Data

There is also infrastructure for globally accessible data, that can be accessed through the global field. This is meant to provide a place for things like database connections or cached data that should be available to all handlers. The storage space itself is immutable when the server has started, so the only way to change it is through some kind of inner mutability.

#[macro_use] extern crate log;
use rustful::{Context, Response};
use rustful::StatusCode::InternalServerError;

fn my_handler(context: Context, mut response: Response) {
    if let Some(some_wise_words) =<&str>() {
        response.send(format!("food for thought: {}", some_wise_words));
    } else {
        error!("there should be a string literal in `global`");

##Request Body

The body will not be read in advance, unlike the other parts of the request. It is instead available as a BodyReader in the field body, through which it can be read and parsed as various data formats, like JSON and query strings. The documentation for BodyReader gives more examples.

use std::io::{BufReader, BufRead};
use rustful::{Context, Response};

fn my_handler(context: Context, response: Response) {
    let mut numbered_lines = BufReader::new(context.body).lines().enumerate();
    let mut writer = response.into_chunked();

    while let Some((line_no, Ok(line))) = {
        writer.send(format!("{}: {}", line_no + 1, line));



Anything related to reading the request body.


Anything related to hypermedia and hyperlinks.



A byte buffer for more efficient MaybeUtf8 manipulation.


A container for handler input, like request data and utilities.


An extended HashMap with extra functionality for value parsing.



String data that may or may not be UTF-8 encoded.


A URI Path that can be a path or an asterisk (*).

Type Definitions


An owned string that may be UTF-8 encoded.


A slice of a string that may be UTF-8 encoded.