Struct fire_http::FireBuilder

pub struct FireBuilder { /* private fields */ }

FireBuilder gathers all materials needed to light a fire (start a server).

Implementations

impl FireBuilder

pub fn data(&self) -> &Data

Returns a reference to the current data.

pub fn add_data<D>(&mut self, data: D)

where D: Any + Send + Sync,

pub fn add_raw_route<R>(&mut self, route: R)

where R: RawRoute + 'static,

Adds a RawRoute to the fire.

pub fn add_route<R>(&mut self, route: R)

where R: IntoRoute + 'static,

Adds a Route to the fire.

pub fn add_catcher<C>(&mut self, catcher: C)

where C: Catcher + 'static,

Adds a Catcher to the fire.

pub fn request_size_limit(&mut self, size_limit: usize)

Sets the request size limit. The default is 4 kilobytes.

This can be changed in every Route.

Panics

If the size is zero.

pub fn request_timeout(&mut self, timeout: Duration)

Sets the request timeout. The default is 60 seconds.

This can be changed in every Route.

pub fn hide_startup_message(&mut self)

Prevents the fire from showing a message when the server get’s started.

pub async fn build(self) -> Result<Fire>

Binds to the address and prepares to serve requests.

You need to call ignite on the Fire so that it starts handling requests.

pub async fn ignite(self) -> Result<()>

Ignites the fire, which starts the server.

Note

Under normal conditions this function should run forever.

pub fn ignite_task(self) -> JoinHandle<()>

Ignites the fire, and spawns it on a new tokio task.

Note

Under normal conditions this task should run forever.

pub fn into_pit(self) -> FirePit

Creates a FirePit without starting the server.

In most cases you should use build and then call pit on the Fire.

Creating a FirePit might be useful for testing or if you want to manually create a server.