Struct rocket::Rocket
[−]
[src]
pub struct Rocket { /* fields omitted */ }
The main Rocket
type: used to mount routes and catchers and launch the
application.
Methods
impl Rocket
[src]
fn ignite() -> Rocket
Create a new Rocket
application using the configuration information in
Rocket.toml
. If the file does not exist or if there is an I/O error
reading the file, the defaults are used. See the
config documentation for more information
on defaults.
This method is typically called through the rocket::ignite
alias.
Panics
If there is an error parsing the Rocket.toml
file, this functions
prints a nice error message and then exits the process.
Examples
rocket::ignite()
fn custom(config: Config, log: bool) -> Rocket
Creates a new Rocket
application using the supplied custom
configuration information. The Rocket.toml
file, if present, is
ignored. Any environment variables setting config parameters are
ignored. If log
is true
, logging is enabled.
This method is typically called through the rocket::custom
alias.
Examples
use rocket::config::{Config, Environment}; let config = Config::build(Environment::Staging) .address("1.2.3.4") .port(9234) .finalize()?; let app = rocket::custom(config, false);
fn mount(self, base: &str, routes: Vec<Route>) -> Self
Mounts all of the routes in the supplied vector at the given base
path. Mounting a route with path path
at path base
makes the route
available at base/path
.
Examples
Use the routes!
macro to mount routes created using the code
generation facilities. Requests to the /hello/world
URI will be
dispatched to the hi
route.
Panics
The base
mount point must be a static path. That is, the mount point
must not contain dynamic path parameters: <param>
.
#[get("/world")] fn hi() -> &'static str { "Hello!" } fn main() { rocket::ignite().mount("/hello", routes![hi]) }
Manually create a route named hi
at path "/world"
mounted at base
"/hello"
. Requests to the /hello/world
URI will be dispatched to the
hi
route.
use rocket::{Request, Route, Data}; use rocket::handler::Outcome; use rocket::http::Method::*; fn hi(_: &Request, _: Data) -> Outcome<'static> { Outcome::of("Hello!") } rocket::ignite().mount("/hello", vec![Route::new(Get, "/world", hi)])
fn catch(self, catchers: Vec<Catcher>) -> Self
Registers all of the catchers in the supplied vector.
Examples
#![feature(plugin)] #![plugin(rocket_codegen)] extern crate rocket; use rocket::Request; #[error(500)] fn internal_error() -> &'static str { "Whoops! Looks like we messed up." } #[error(400)] fn not_found(req: &Request) -> String { format!("I couldn't find '{}'. Try something else?", req.uri()) } fn main() { rocket::ignite().catch(errors![internal_error, not_found]) }
fn manage<T: Send + Sync + 'static>(self, state: T) -> Self
Add state
to the state managed by this instance of Rocket.
This method can be called any number of times as long as each call
referes to a different T
.
Managed state can be retrieved by any request handler via the
State request guard. In particular, if a
value of type T
is managed by Rocket, adding State<T>
to the list of
arguments in a request handler instructs Rocket to retrieve the managed
value.
Panics
Panics if state of type T
is already being managed.
Example
use rocket::State; struct MyValue(usize); #[get("/")] fn index(state: State<MyValue>) -> String { format!("The stateful value is: {}", state.0) } fn main() { rocket::ignite() .mount("/", routes![index]) .manage(MyValue(10)) .launch() }