pub struct AdHoc { /* private fields */ }
Expand description
A ad-hoc fairing that can be created from a function or closure.
This enum can be used to create a fairing from a simple function or closure
without creating a new structure or implementing Fairing
directly.
Usage
Use AdHoc::on_ignite
, AdHoc::on_liftoff
, AdHoc::on_request()
, or
AdHoc::on_response()
to create an AdHoc
structure from a function or
closure. Then, simply attach the structure to the Rocket
instance.
Example
The following snippet creates a Rocket
instance with two ad-hoc fairings.
The first, a liftoff fairing named “Liftoff Printer”, simply prints a message
indicating that Rocket has launched. The second named “Put Rewriter”, a
request fairing, rewrites the method of all requests to be PUT
.
use rocket::fairing::AdHoc;
use rocket::http::Method;
rocket::build()
.attach(AdHoc::on_liftoff("Liftoff Printer", |_| Box::pin(async move {
println!("...annnddd we have liftoff!");
})))
.attach(AdHoc::on_request("Put Rewriter", |req, _| Box::pin(async move {
req.set_method(Method::Put);
})));
Implementations§
source§impl AdHoc
impl AdHoc
sourcepub fn on_ignite<F, Fut>(name: &'static str, f: F) -> AdHocwhere
F: FnOnce(Rocket<Build>) -> Fut + Send + 'static,
Fut: Future<Output = Rocket<Build>> + Send + 'static,
pub fn on_ignite<F, Fut>(name: &'static str, f: F) -> AdHocwhere F: FnOnce(Rocket<Build>) -> Fut + Send + 'static, Fut: Future<Output = Rocket<Build>> + Send + 'static,
Constructs an AdHoc
ignite fairing named name
. The function f
will
be called by Rocket during the Rocket::ignite()
phase.
This version of an AdHoc
ignite fairing cannot abort ignite. For a
fallible version that can, see AdHoc::try_on_ignite()
.
Example
use rocket::fairing::AdHoc;
// The no-op ignite fairing.
let fairing = AdHoc::on_ignite("Boom!", |rocket| async move {
rocket
});
sourcepub fn try_on_ignite<F, Fut>(name: &'static str, f: F) -> AdHocwhere
F: FnOnce(Rocket<Build>) -> Fut + Send + 'static,
Fut: Future<Output = Result> + Send + 'static,
pub fn try_on_ignite<F, Fut>(name: &'static str, f: F) -> AdHocwhere F: FnOnce(Rocket<Build>) -> Fut + Send + 'static, Fut: Future<Output = Result> + Send + 'static,
Constructs an AdHoc
ignite fairing named name
. The function f
will
be called by Rocket during the Rocket::ignite()
phase. Returning an
Err
aborts ignition and thus launch.
For an infallible version, see AdHoc::on_ignite()
.
Example
use rocket::fairing::AdHoc;
// The no-op try ignite fairing.
let fairing = AdHoc::try_on_ignite("No-Op", |rocket| async { Ok(rocket) });
sourcepub fn on_liftoff<F>(name: &'static str, f: F) -> AdHocwhere
F: for<'a> FnOnce(&'a Rocket<Orbit>) -> BoxFuture<'a, ()> + Send + Sync + 'static,
pub fn on_liftoff<F>(name: &'static str, f: F) -> AdHocwhere F: for<'a> FnOnce(&'a Rocket<Orbit>) -> BoxFuture<'a, ()> + Send + Sync + 'static,
Constructs an AdHoc
liftoff fairing named name
. The function f
will be called by Rocket just after Rocket::launch()
.
Example
use rocket::fairing::AdHoc;
// A fairing that prints a message just before launching.
let fairing = AdHoc::on_liftoff("Boom!", |_| Box::pin(async move {
println!("Rocket has lifted off!");
}));
sourcepub fn on_request<F>(name: &'static str, f: F) -> AdHocwhere
F: for<'a> Fn(&'a mut Request<'_>, &'a Data<'_>) -> BoxFuture<'a, ()> + Send + Sync + 'static,
pub fn on_request<F>(name: &'static str, f: F) -> AdHocwhere F: for<'a> Fn(&'a mut Request<'_>, &'a Data<'_>) -> BoxFuture<'a, ()> + Send + Sync + 'static,
Constructs an AdHoc
request fairing named name
. The function f
will be called and the returned Future
will be await
ed by Rocket
when a new request is received.
Example
use rocket::fairing::AdHoc;
// The no-op request fairing.
let fairing = AdHoc::on_request("Dummy", |req, data| {
Box::pin(async move {
// do something with the request and data...
})
});
sourcepub fn on_response<F>(name: &'static str, f: F) -> AdHocwhere
F: for<'b, 'r> Fn(&'r Request<'_>, &'b mut Response<'r>) -> BoxFuture<'b, ()> + Send + Sync + 'static,
pub fn on_response<F>(name: &'static str, f: F) -> AdHocwhere F: for<'b, 'r> Fn(&'r Request<'_>, &'b mut Response<'r>) -> BoxFuture<'b, ()> + Send + Sync + 'static,
Constructs an AdHoc
response fairing named name
. The function f
will be called and the returned Future
will be await
ed by Rocket
when a response is ready to be sent.
Example
use rocket::fairing::AdHoc;
// The no-op response fairing.
let fairing = AdHoc::on_response("Dummy", |req, resp| {
Box::pin(async move {
// do something with the request and pending response...
})
});
sourcepub fn on_shutdown<F>(name: &'static str, f: F) -> AdHocwhere
F: for<'a> FnOnce(&'a Rocket<Orbit>) -> BoxFuture<'a, ()> + Send + Sync + 'static,
pub fn on_shutdown<F>(name: &'static str, f: F) -> AdHocwhere F: for<'a> FnOnce(&'a Rocket<Orbit>) -> BoxFuture<'a, ()> + Send + Sync + 'static,
Constructs an AdHoc
shutdown fairing named name
. The function f
will be called by Rocket when shutdown is triggered.
Example
use rocket::fairing::AdHoc;
// A fairing that prints a message just before launching.
let fairing = AdHoc::on_shutdown("Bye!", |_| Box::pin(async move {
println!("Rocket is on its way back!");
}));
sourcepub fn config<'de, T>() -> AdHocwhere
T: Deserialize<'de> + Send + Sync + 'static,
pub fn config<'de, T>() -> AdHocwhere T: Deserialize<'de> + Send + Sync + 'static,
Constructs an AdHoc
launch fairing that extracts a configuration of
type T
from the configured provider and stores it in managed state. If
extractions fails, pretty-prints the error message and aborts launch.
Example
use serde::Deserialize;
use rocket::fairing::AdHoc;
#[derive(Deserialize)]
struct Config {
field: String,
other: usize,
/* and so on.. */
}
#[launch]
fn rocket() -> _ {
rocket::build().attach(AdHoc::config::<Config>())
}
Trait Implementations§
source§impl Fairing for AdHoc
impl Fairing for AdHoc
source§fn on_ignite<'life0, 'async_trait>(
&'life0 self,
rocket: Rocket<Build>
) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn on_ignite<'life0, 'async_trait>( &'life0 self, rocket: Rocket<Build> ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,
Ok
if ignition should proceed and Err
if ignition and launch should be aborted. Read more