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>())
}
sourcepub fn uri_normalizer() -> impl Fairing
pub fn uri_normalizer() -> impl Fairing
Constructs an AdHoc
request fairing that strips trailing slashes from
all URIs in all incoming requests.
The fairing returned by this method is intended largely for applications
that migrated from Rocket v0.4 to Rocket v0.5. In Rocket v0.4, requests
with a trailing slash in the URI were treated as if the trailing slash
were not present. For example, the request URI /foo/
would match the
route /<a>
with a = foo
. If the application depended on this
behavior, say by using URIs with previously innocuous trailing slashes
in an external application, requests will not be routed as expected.
This fairing resolves this issue by stripping a trailing slash, if any, in all incoming URIs. When it does so, it logs a warning. It is recommended to use this fairing as a stop-gap measure instead of a permanent resolution, if possible.
Example
With the fairing attached, request URIs have a trailing slash stripped:
use rocket::local::blocking::Client;
use rocket::fairing::AdHoc;
#[get("/<param>")]
fn foo(param: &str) -> &str {
param
}
#[launch]
fn rocket() -> _ {
rocket::build()
.mount("/", routes![foo])
.attach(AdHoc::uri_normalizer())
}
let response = client.get("/bar/").dispatch();
assert_eq!(response.into_string().unwrap(), "bar");
Without it, request URIs are unchanged and routed normally:
use rocket::local::blocking::Client;
use rocket::fairing::AdHoc;
#[get("/<param>")]
fn foo(param: &str) -> &str {
param
}
#[launch]
fn rocket() -> _ {
rocket::build().mount("/", routes![foo])
}
let response = client.get("/bar/").dispatch();
assert!(response.status().class().is_client_error());
let response = client.get("/bar").dispatch();
assert_eq!(response.into_string().unwrap(), "bar");
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 moresource§fn on_liftoff<'life0, 'life1, 'async_trait>(
&'life0 self,
rocket: &'life1 Rocket<Orbit>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
fn on_liftoff<'life0, 'life1, 'async_trait>( &'life0 self, rocket: &'life1 Rocket<Orbit> ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,
source§fn on_request<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
&'life0 self,
req: &'life1 mut Request<'life2>,
data: &'life3 mut Data<'life4>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
fn on_request<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request<'life2>, data: &'life3 mut Data<'life4> ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,
source§fn on_response<'r, 'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
req: &'r Request<'life1>,
res: &'life2 mut Response<'r>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
Self: 'async_trait,
'r: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
fn on_response<'r, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, req: &'r Request<'life1>, res: &'life2 mut Response<'r> ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,
Auto Trait Implementations§
impl !RefUnwindSafe for AdHoc
impl Send for AdHoc
impl Sync for AdHoc
impl Unpin for AdHoc
impl !UnwindSafe for AdHoc
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
source§impl<T> Paint for Twhere
T: ?Sized,
impl<T> Paint for Twhere T: ?Sized,
source§fn fg(&self, value: Color) -> Painted<&T>
fn fg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self
with the foreground set to
value
.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like red()
and
green()
, which have the same functionality but are
pithier.
Example
Set foreground color to white using fg()
:
use yansi::{Paint, Color};
painted.fg(Color::White);
Set foreground color to white using white()
.
use yansi::Paint;
painted.white();
source§fn bright_black(&self) -> Painted<&T>
fn bright_black(&self) -> Painted<&T>
source§fn bright_red(&self) -> Painted<&T>
fn bright_red(&self) -> Painted<&T>
source§fn bright_green(&self) -> Painted<&T>
fn bright_green(&self) -> Painted<&T>
source§fn bright_yellow(&self) -> Painted<&T>
fn bright_yellow(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightYellow
.
Example
println!("{}", value.bright_yellow());
source§fn bright_blue(&self) -> Painted<&T>
fn bright_blue(&self) -> Painted<&T>
source§fn bright_magenta(&self) -> Painted<&T>
fn bright_magenta(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightMagenta
.
Example
println!("{}", value.bright_magenta());
source§fn bright_cyan(&self) -> Painted<&T>
fn bright_cyan(&self) -> Painted<&T>
source§fn bright_white(&self) -> Painted<&T>
fn bright_white(&self) -> Painted<&T>
source§fn bg(&self, value: Color) -> Painted<&T>
fn bg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self
with the background set to
value
.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like on_red()
and
on_green()
, which have the same functionality but
are pithier.
Example
Set background color to red using fg()
:
use yansi::{Paint, Color};
painted.bg(Color::Red);
Set background color to red using on_red()
.
use yansi::Paint;
painted.on_red();
source§fn on_primary(&self) -> Painted<&T>
fn on_primary(&self) -> Painted<&T>
source§fn on_magenta(&self) -> Painted<&T>
fn on_magenta(&self) -> Painted<&T>
source§fn on_bright_black(&self) -> Painted<&T>
fn on_bright_black(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightBlack
.
Example
println!("{}", value.on_bright_black());
source§fn on_bright_red(&self) -> Painted<&T>
fn on_bright_red(&self) -> Painted<&T>
source§fn on_bright_green(&self) -> Painted<&T>
fn on_bright_green(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightGreen
.
Example
println!("{}", value.on_bright_green());
source§fn on_bright_yellow(&self) -> Painted<&T>
fn on_bright_yellow(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightYellow
.
Example
println!("{}", value.on_bright_yellow());
source§fn on_bright_blue(&self) -> Painted<&T>
fn on_bright_blue(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightBlue
.
Example
println!("{}", value.on_bright_blue());
source§fn on_bright_magenta(&self) -> Painted<&T>
fn on_bright_magenta(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightMagenta
.
Example
println!("{}", value.on_bright_magenta());
source§fn on_bright_cyan(&self) -> Painted<&T>
fn on_bright_cyan(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightCyan
.
Example
println!("{}", value.on_bright_cyan());
source§fn on_bright_white(&self) -> Painted<&T>
fn on_bright_white(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightWhite
.
Example
println!("{}", value.on_bright_white());
source§fn attr(&self, value: Attribute) -> Painted<&T>
fn attr(&self, value: Attribute) -> Painted<&T>
Enables the styling Attribute
value
.
This method should be used rarely. Instead, prefer to use
attribute-specific builder methods like bold()
and
underline()
, which have the same functionality
but are pithier.
Example
Make text bold using attr()
:
use yansi::{Paint, Attribute};
painted.attr(Attribute::Bold);
Make text bold using using bold()
.
use yansi::Paint;
painted.bold();
source§fn underline(&self) -> Painted<&T>
fn underline(&self) -> Painted<&T>
Returns self
with the
attr()
set to
Attribute::Underline
.
Example
println!("{}", value.underline());
source§fn rapid_blink(&self) -> Painted<&T>
fn rapid_blink(&self) -> Painted<&T>
Returns self
with the
attr()
set to
Attribute::RapidBlink
.
Example
println!("{}", value.rapid_blink());
source§fn quirk(&self, value: Quirk) -> Painted<&T>
fn quirk(&self, value: Quirk) -> Painted<&T>
Enables the yansi
Quirk
value
.
This method should be used rarely. Instead, prefer to use quirk-specific
builder methods like mask()
and
wrap()
, which have the same functionality but are
pithier.
Example
Enable wrapping using .quirk()
:
use yansi::{Paint, Quirk};
painted.quirk(Quirk::Wrap);
Enable wrapping using wrap()
.
use yansi::Paint;
painted.wrap();
source§fn whenever(&self, value: Condition) -> Painted<&T>
fn whenever(&self, value: Condition) -> Painted<&T>
Conditionally enable styling based on whether the Condition
value
applies. Replaces any previous condition.
See the crate level docs for more details.
Example
Enable styling painted
only when both stdout
and stderr
are TTYs:
use yansi::{Paint, Condition};
painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);