Trait gotham::handler::Handler [−][src]
A Handler
is an asynchronous function, taking a State
value which represents the request
and related runtime state, and returns a future which resolves to a response.
This represents the common entry point for the parts of a Gotham application, and is used with
the Router
API to describe how a request should be dispatched and handled.
The Handler
is created and consumed by each request. In the most common case (a bare function
acting as a Handler
) the Handler + Copy
traits allow the Handler
to be copied for each
request, and the copy consumed. For a closure or a custom handler, the NewHandler
implementation creates a Handler
value for each request.
Examples
The simplest kind of handler is a bare function which returns a synchronous response. This is useful when we don’t need to do any I/O before generating a response.
fn my_handler(_state: State) -> (State, Response<Body>) { // Implementation elided. }
An asynchronous handler returns a HandlerFuture
that will resolve to the response. For
example, this allows I/O work to begin, and for the Gotham app to continue generating a
response once the work completes.
fn async_handler(_state: State) -> Pin<Box<HandlerFuture>> { // Implementation elided. }
A closure can implement Handler
automatically, in the same way as a bare function. When
constructing a Handler
in this way, a wrapping closure must also be used to implement the
NewHandler
trait.
let new_handler = || { let handler = |state: State| { // Implementation elided. }; Ok(handler) }; // Pass `new_handler` to the router, using the `to_new_handler` API.
A custom handler, which implements the NewHandler
and Handler
traits directly for greater
control. See the NewHandler
trait for more examples of custom handlers.
#[derive(Copy, Clone)] struct MyCustomHandler; impl NewHandler for MyCustomHandler { type Instance = Self; fn new_handler(&self) -> anyhow::Result<Self::Instance> { Ok(*self) } } impl Handler for MyCustomHandler { fn handle(self, _state: State) -> Pin<Box<HandlerFuture>> { // Implementation elided. } }
Required methods
fn handle(self, state: State) -> Pin<Box<HandlerFuture>>
[src]
Handles the request, returning a boxed future which resolves to a response.
Implementors
impl Handler for DirHandler
[src]
impl Handler for FileHandler
[src]
impl Handler for Router
[src]
fn handle(self, state: State) -> Pin<Box<HandlerFuture>>
[src]
Handles the Request
by determining the correct Route
from the internal Tree
, storing
any path related variables in State
and dispatching to the associated Handler
.
impl<F, R> Handler for F where
F: FnOnce(State) -> R + Send,
R: IntoHandlerFuture,
[src]
F: FnOnce(State) -> R + Send,
R: IntoHandlerFuture,