Struct rocket::Rocket

pub struct Rocket<P: Phase>(/* private fields */);

The application server itself.

Phases

A Rocket instance represents a web server and its state. It progresses through three statically-enforced phases: build, ignite, orbit.

• Build: application and server configuration

  This phase enables:

  • setting configuration options
  • mounting/registering routes/catchers
  • managing state
  • attaching fairings

  This is the only phase in which an instance can be modified. To finalize changes, an instance is ignited via Rocket::ignite(), progressing it into the ignite phase, or directly launched into orbit with Rocket::launch() which progress the instance through ignite into orbit.

• Ignite: verification and finalization of configuration

  An instance in the Ignite phase is in its final configuration, available via Rocket::config(). Barring user-supplied interior mutation, application state is guaranteed to remain unchanged beyond this point. An instance in the ignite phase can be launched into orbit to serve requests via Rocket::launch().

• Orbit: a running web server

  An instance in the Orbit phase represents a running application, actively serving requests.

Launching

To launch a Rocket application, the suggested approach is to return an instance of Rocket<Build> from a function named rocket marked with the #[launch] attribute:

#[launch]
fn rocket() -> _ {
    rocket::build()
}

This generates a main function with an async runtime that runs the returned Rocket instance.

• Manual Launching

  To launch an instance of Rocket, it must progress through all three phases. To progress into the ignite or launch phases, a tokio async runtime is required. The #[main] attribute initializes a Rocket-specific tokio runtime and runs the attributed async fn inside of it:

  #[rocket::main]
  async fn main() -> Result<(), rocket::Error> {
      let _rocket = rocket::build()
          .ignite().await?
          .launch().await?;
  
      Ok(())
  }

  Note that Rocket::launch() automatically progresses an instance of Rocket from any phase into orbit:

  #[rocket::main]
  async fn main() -> Result<(), rocket::Error> {
      let _rocket = rocket::build().launch().await?;
      Ok(())
  }

  For extreme and rare cases in which #[main] imposes obstinate restrictions, use rocket::execute() to execute Rocket’s launch() future.

• Automatic Launching

  Manually progressing an instance of Rocket though its phases is only necessary when either an instance’s finalized state is to be inspected (in the ignite phase) or the instance is expected to deorbit due to Rocket::shutdown(). In the more common case when neither is required, the #[launch] attribute can be used. When applied to a function that returns a Rocket<Build>, it automatically initializes an async runtime and launches the function’s returned instance:

  use rocket::{Rocket, Build};
  
  #[launch]
  fn rocket() -> Rocket<Build> {
      rocket::build()
  }

  To avoid needing to import any items in the common case, the launch attribute will infer a return type written as _ as Rocket<Build>:

  #[launch]
  fn rocket() -> _ {
      rocket::build()
  }

Implementations

impl Rocket<Build>

pub fn build() -> Self

Create a new Rocket application using the default configuration provider, Config::figment().

This method is typically called through the rocket::build() alias.

Examples

#[launch]
fn rocket() -> _ {
    rocket::build()
}

pub fn custom<T: Provider>(provider: T) -> Self

Creates a new Rocket application using the supplied configuration provider.

This method is typically called through the rocket::custom() alias.

Example

use rocket::figment::{Figment, providers::{Toml, Env, Format}};

#[launch]
fn rocket() -> _ {
    let figment = Figment::from(rocket::Config::default())
        .merge(Toml::file("MyApp.toml").nested())
        .merge(Env::prefixed("MY_APP_").global());

    rocket::custom(figment)
}

pub fn reconfigure<T: Provider>(self, provider: T) -> Self

Overrides the current configuration provider with provider.

The default provider, or a provider previously set with Rocket::custom() or Rocket::reconfigure(), is overridden by provider.

Example

use rocket::config::{Config, Ident};

let config = Config {
    ident: Ident::try_new("MyServer").expect("valid ident"),
    temp_dir: "/tmp/config-example".into(),
    ..Config::debug_default()
};

let rocket = rocket::custom(&config).ignite().await?;
assert_eq!(rocket.config().ident.as_str(), Some("MyServer"));
assert_eq!(rocket.config().temp_dir.relative(), Path::new("/tmp/config-example"));

// Create a new figment which modifies _some_ keys the existing figment:
let figment = rocket.figment().clone()
    .merge((Config::IDENT, "Example"));

let rocket = rocket::custom(&config)
    .reconfigure(figment)
    .ignite().await?;

assert_eq!(rocket.config().ident.as_str(), Some("Example"));
assert_eq!(rocket.config().temp_dir.relative(), Path::new("/tmp/config-example"));

pub fn mount<'a, B, R>(self, base: B, routes: R) -> Self

where B: TryInto<Origin<'a>> + Clone + Display, B::Error: Display, R: Into<Vec<Route>>,

Mounts all of the routes at the given base mount point.

A route mounted at base has an effective URI of base/route, where route is the route URI. In other words, base is added as a prefix to the route’s URI. The URI resulting from joining the base URI and the route URI is called the route’s effective URI, as this is the URI used for request matching during routing.

A base URI is not allowed to have a query part. If a base does have a query part, it is ignored when producing the effective URI.

A base may have an optional trailing slash. A route with a URI path of / (and any optional query) mounted at a base has an effective URI equal to the base (plus any optional query). That is, if the base has a trailing slash, the effective URI path has a trailing slash, and otherwise it does not. Routes with URI paths other than / are not effected by trailing slashes in their corresponding mount point.

As concrete examples, consider the following table:

mount point	route URI	effective URI
/	/foo	/foo
/	/foo/	/foo/
/foo	/	/foo
/foo	/?bar	/foo?bar
/foo	/bar	/foo/bar
/foo	/bar/	/foo/bar/
/foo/	/	/foo/
/foo/	/bar	/foo/bar
/foo/	/?bar	/foo/?bar
/foo/bar	/	/foo/bar
/foo/bar/	/	/foo/bar/
/foo/?bar	/	/foo/
/foo/?bar	/baz	/foo/baz
/foo/?bar	/baz/	/foo/baz/

Panics

Panics if either:

• the base mount point is not a valid origin URI without dynamic parameters

• any route URI is not a valid origin URI. (Note: This kind of panic is guaranteed not to occur if the routes were generated using Rocket’s code generation.)

Examples

Use the routes! macro to mount routes created using the code generation facilities. Requests to both /world and /hello/world URI will be dispatched to the hi route.

#[get("/world")]
fn hi() -> &'static str {
    "Hello!"
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/", routes![hi])
        .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, route};
use rocket::http::Method;

fn hi<'r>(req: &'r Request, _: Data<'r>) -> route::BoxFuture<'r> {
    route::Outcome::from(req, "Hello!").pin()
}

#[launch]
fn rocket() -> _ {
    let hi_route = Route::new(Method::Get, "/world", hi);
    rocket::build().mount("/hello", vec![hi_route])
}

pub fn register<'a, B, C>(self, base: B, catchers: C) -> Self

where B: TryInto<Origin<'a>> + Clone + Display, B::Error: Display, C: Into<Vec<Catcher>>,

Registers all of the catchers in the supplied vector, scoped to base.

Panics

Panics if base is not a valid static path: a valid origin URI without dynamic parameters.

Examples

use rocket::Request;

#[catch(500)]
fn internal_error() -> &'static str {
    "Whoops! Looks like we messed up."
}

#[catch(404)]
fn not_found(req: &Request) -> String {
    format!("I couldn't find '{}'. Try something else?", req.uri())
}

#[launch]
fn rocket() -> _ {
    rocket::build().register("/", catchers![internal_error, not_found])
}

pub fn manage<T>(self, state: T) -> Self

where T: Send + Sync + 'static,

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 refers 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 MyInt(isize);
struct MyString(String);

#[get("/int")]
fn int(state: &State<MyInt>) -> String {
    format!("The stateful int is: {}", state.0)
}

#[get("/string")]
fn string(state: &State<MyString>) -> &str {
    &state.0
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .manage(MyInt(10))
        .manage(MyString("Hello, managed state!".to_string()))
        .mount("/", routes![int, string])
}

pub fn attach<F: Fairing>(self, fairing: F) -> Self

Attaches a fairing to this instance of Rocket. No fairings are eagerly executed; fairings are executed at their appropriate time.

If the attached fairing is a singleton and a fairing of the same type has already been attached, this fairing replaces it. Otherwise the fairing gets attached without replacing any existing fairing.

Example

use rocket::Rocket;
use rocket::fairing::AdHoc;

#[launch]
fn rocket() -> _ {
    rocket::build()
        .attach(AdHoc::on_liftoff("Liftoff Message", |_| Box::pin(async {
            println!("We have liftoff!");
        })))
}

pub async fn ignite(self) -> Result<Rocket<Ignite>, Error>

Returns a Future that transitions this instance of Rocket into the ignite phase.

When awaited, the future runs all ignite fairings in serial, attach order, and verifies that self represents a valid instance of Rocket ready for launch. This means that:

• All ignite fairings succeeded.
• A valid Config was extracted from Rocket::figment().
• If secrets are enabled, the extracted Config contains a safe secret key.
• There are no Route or Catcher collisions.
• No Sentinel triggered an abort.

If any of these conditions fail to be met, a respective Error is returned.

Example

use rocket::fairing::AdHoc;

#[rocket::main]
async fn main() -> Result<(), rocket::Error> {
    let rocket = rocket::build()
        .attach(AdHoc::on_ignite("Manage State", |rocket| async move {
            rocket.manage(String::from("managed string"))
        }));

    // No fairings are run until ignition occurs.
    assert!(rocket.state::<String>().is_none());

    let rocket = rocket.ignite().await?;
    assert_eq!(rocket.state::<String>().unwrap(), "managed string");

    Ok(())
}

impl Rocket<Ignite>

pub fn config(&self) -> &Config

Returns the finalized, active configuration. This is guaranteed to remain stable through ignition and into orbit.

Example

#[rocket::main]
async fn main() -> Result<(), rocket::Error> {
    let rocket = rocket::build().ignite().await?;
    let config = rocket.config();
    Ok(())
}

pub fn shutdown(&self) -> Shutdown

Returns a handle which can be used to trigger a shutdown and detect a triggered shutdown.

A completed graceful shutdown resolves the future returned by Rocket::launch(). If Shutdown::notify() is called before an instance is launched, it will be immediately shutdown after liftoff. See Shutdown and ShutdownConfig for details on graceful shutdown.

Example

use rocket::tokio::{self, time};

#[rocket::main]
async fn main() -> Result<(), rocket::Error> {
    let rocket = rocket::build().ignite().await?;

    let shutdown = rocket.shutdown();
    tokio::spawn(async move {
        time::sleep(time::Duration::from_secs(5)).await;
        shutdown.notify();
    });

    // The `launch()` future resolves after ~5 seconds.
    let result = rocket.launch().await;
    assert!(result.is_ok());

    Ok(())
}

impl Rocket<Orbit>

pub fn config(&self) -> &Config

Returns the finalized, active configuration. This is guaranteed to remain stable after Rocket::ignite(), through ignition and into orbit.

Example

use rocket::fairing::AdHoc;

#[launch]
fn rocket() -> _ {
    rocket::build()
        .attach(AdHoc::on_liftoff("Config", |rocket| Box::pin(async move {
            println!("Rocket launch config: {:?}", rocket.config());
        })))
}

pub fn endpoints(&self) -> impl Iterator<Item = &Endpoint>

pub fn shutdown(&self) -> Shutdown

Returns a handle which can be used to trigger a shutdown and detect a triggered shutdown.

A completed graceful shutdown resolves the future returned by Rocket::launch(). See Shutdown and ShutdownConfig for details on graceful shutdown.

Example

use rocket::tokio::{self, time};
use rocket::fairing::AdHoc;

#[launch]
fn rocket() -> _ {
    rocket::build()
        .attach(AdHoc::on_liftoff("Shutdown", |rocket| Box::pin(async move {
            let shutdown = rocket.shutdown();
            tokio::spawn(async move {
                time::sleep(time::Duration::from_secs(5)).await;
                shutdown.notify();
            });
        })))
}

impl<P: Phase> Rocket<P>

pub fn routes(&self) -> impl Iterator<Item = &Route>

Returns an iterator over all of the routes mounted on this instance of Rocket. The order is unspecified.

Example

use rocket::Rocket;
use rocket::fairing::AdHoc;

#[get("/hello")]
fn hello() -> &'static str {
    "Hello, world!"
}

let rocket = rocket::build()
    .mount("/", routes![hello])
    .mount("/hi", routes![hello]);

assert_eq!(rocket.routes().count(), 2);
assert!(rocket.routes().any(|r| r.uri == "/hello"));
assert!(rocket.routes().any(|r| r.uri == "/hi/hello"));

pub fn catchers(&self) -> impl Iterator<Item = &Catcher>

Returns an iterator over all of the catchers registered on this instance of Rocket. The order is unspecified.

Example

use rocket::Rocket;
use rocket::fairing::AdHoc;

#[catch(404)] fn not_found() -> &'static str { "Nothing here, sorry!" }
#[catch(500)] fn just_500() -> &'static str { "Whoops!?" }
#[catch(default)] fn some_default() -> &'static str { "Everything else." }

let rocket = rocket::build()
    .register("/foo", catchers![not_found])
    .register("/", catchers![just_500, some_default]);

assert_eq!(rocket.catchers().count(), 3);
assert!(rocket.catchers().any(|c| c.code == Some(404) && c.base() == "/foo"));
assert!(rocket.catchers().any(|c| c.code == Some(500) && c.base() == "/"));
assert!(rocket.catchers().any(|c| c.code == None && c.base() == "/"));

pub fn state<T: Send + Sync + 'static>(&self) -> Option<&T>

Returns Some of the managed state value for the type T if it is being managed by self. Otherwise, returns None.

Example

#[derive(PartialEq, Debug)]
struct MyState(&'static str);

let rocket = rocket::build().manage(MyState("hello!"));
assert_eq!(rocket.state::<MyState>().unwrap(), &MyState("hello!"));

pub fn fairing<F: Fairing>(&self) -> Option<&F>

Returns a reference to the first fairing of type F if it is attached. Otherwise, returns None.

To retrieve a mutable reference to fairing F, use Rocket::fairing_mut() instead.

Example

// A regular, non-singleton fairing.
struct MyFairing(&'static str);

// A singleton fairing.
struct MySingletonFairing(&'static str);

// fairing is not attached, returns `None`
let rocket = rocket::build();
assert!(rocket.fairing::<MyFairing>().is_none());
assert!(rocket.fairing::<MySingletonFairing>().is_none());

// attach fairing, now returns `Some`
let rocket = rocket.attach(MyFairing("some state"));
assert!(rocket.fairing::<MyFairing>().is_some());
assert_eq!(rocket.fairing::<MyFairing>().unwrap().0, "some state");

// it returns the first fairing of a given type only
let rocket = rocket.attach(MyFairing("other state"));
assert_eq!(rocket.fairing::<MyFairing>().unwrap().0, "some state");

// attach fairing, now returns `Some`
let rocket = rocket.attach(MySingletonFairing("first"));
assert_eq!(rocket.fairing::<MySingletonFairing>().unwrap().0, "first");

// recall that new singletons replace existing attached singletons
let rocket = rocket.attach(MySingletonFairing("second"));
assert_eq!(rocket.fairing::<MySingletonFairing>().unwrap().0, "second");

pub fn fairings<F: Fairing>(&self) -> impl Iterator<Item = &F>

Returns an iterator over all attached fairings of type F, if any.

Example

// A regular, non-singleton fairing.
struct MyFairing(&'static str);

// A singleton fairing.
struct MySingletonFairing(&'static str);

let rocket = rocket::build();
assert_eq!(rocket.fairings::<MyFairing>().count(), 0);
assert_eq!(rocket.fairings::<MySingletonFairing>().count(), 0);

let rocket = rocket.attach(MyFairing("some state"))
    .attach(MySingletonFairing("first"))
    .attach(MySingletonFairing("second"))
    .attach(MyFairing("other state"))
    .attach(MySingletonFairing("third"));

let my_fairings: Vec<_> = rocket.fairings::<MyFairing>().collect();
assert_eq!(my_fairings.len(), 2);
assert_eq!(my_fairings[0].0, "some state");
assert_eq!(my_fairings[1].0, "other state");

let my_singleton: Vec<_> = rocket.fairings::<MySingletonFairing>().collect();
assert_eq!(my_singleton.len(), 1);
assert_eq!(my_singleton[0].0, "third");

pub fn fairing_mut<F: Fairing>(&mut self) -> Option<&mut F>

Returns a mutable reference to the first fairing of type F if it is attached. Otherwise, returns None.

Example

// A regular, non-singleton fairing.
struct MyFairing(&'static str);

// fairing is not attached, returns `None`
let mut rocket = rocket::build();
assert!(rocket.fairing_mut::<MyFairing>().is_none());

// attach fairing, now returns `Some`
let mut rocket = rocket.attach(MyFairing("some state"));
assert!(rocket.fairing_mut::<MyFairing>().is_some());
assert_eq!(rocket.fairing_mut::<MyFairing>().unwrap().0, "some state");

// we can modify the fairing
rocket.fairing_mut::<MyFairing>().unwrap().0 = "other state";
assert_eq!(rocket.fairing_mut::<MyFairing>().unwrap().0, "other state");

// it returns the first fairing of a given type only
let mut rocket = rocket.attach(MyFairing("yet more state"));
assert_eq!(rocket.fairing_mut::<MyFairing>().unwrap().0, "other state");

pub fn fairings_mut<F: Fairing>(&mut self) -> impl Iterator<Item = &mut F>

Returns an iterator of mutable references to all attached fairings of type F, if any.

Example

// A regular, non-singleton fairing.
struct MyFairing(&'static str);

let mut rocket = rocket::build()
    .attach(MyFairing("some state"))
    .attach(MyFairing("other state"))
    .attach(MyFairing("yet more state"));

let mut fairings: Vec<_> = rocket.fairings_mut::<MyFairing>().collect();
assert_eq!(fairings.len(), 3);
assert_eq!(fairings[0].0, "some state");
assert_eq!(fairings[1].0, "other state");
assert_eq!(fairings[2].0, "yet more state");

// we can modify the fairings
fairings[1].0 = "modified state";

let fairings: Vec<_> = rocket.fairings::<MyFairing>().collect();
assert_eq!(fairings.len(), 3);
assert_eq!(fairings[0].0, "some state");
assert_eq!(fairings[1].0, "modified state");
assert_eq!(fairings[2].0, "yet more state");

pub fn figment(&self) -> &Figment

Returns the figment derived from the configuration provider set for self. To extract a typed config, prefer to use AdHoc::config().

Note; A Figment generated from the current provider can always be retrieved via this method. However, because the provider can be changed at any point prior to ignition, a Config can only be retrieved in the ignite or orbit phases, or by manually extracting one from a particular figment.

Example

let rocket = rocket::build();
let figment = rocket.figment();

pub async fn launch(self) -> Result<Rocket<Ignite>, Error>

Returns a Future that transitions this instance of Rocket from any phase into the orbit phase. When awaited, the future drives the server forward, listening for and dispatching requests to mounted routes and catchers.

In addition to all of the processes that occur during ignition, a successful launch results in liftoff fairings being executed after binding to any respective network interfaces but before serving the first request. Liftoff fairings are run concurrently; resolution of all fairings is awaited before resuming request serving.

The Future resolves as an Err if any of the following occur:

• there is an error igniting; see Rocket::ignite().
• there is an I/O error starting the server.
• an unrecoverable, system-level error occurs while running.

The Future resolves as an Ok if any of the following occur:

• graceful shutdown via Shutdown::notify() completes.

The returned value on Ok(()) is previously running instance.

The Future does not resolve otherwise.

Error

If there is a problem starting the application or the application fails unexpectedly while running, an Error is returned. Note that a value of type Error panics if dropped without first being inspected. See the Error documentation for more information.

Example

#[rocket::main]
async fn main() {
    let result = rocket::build().launch().await;

    // this is reachable only after `Shutdown::notify()` or `Ctrl+C`.
    println!("Rocket: deorbit.");
}

pub async fn launch_with<B: Bind>(self) -> Result<Rocket<Ignite>, Error>

pub async fn try_launch_on<L, F, E>( self, listener: F, ) -> Result<Rocket<Ignite>, Error>

where L: Listener + 'static, F: Future<Output = Result<L, E>>, E: Error + Send + 'static,

pub async fn launch_on<L>(self, listener: L) -> Result<Rocket<Ignite>, Error>

where L: Listener + 'static,

Trait Implementations

impl<P: Phase> Debug for Rocket<P>

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

Formats the value using the given formatter.