Struct Engine

pub struct Engine { /* private fields */ }

A collection of controllers mounted on a route.

Implementations

impl Engine

pub fn new(handlers: Vec<Handler>) -> Self

Create new engine for the given routes.

pub fn remount(self, mount: &Path) -> Self

Move the engine to this mount point.

pub fn auth(self, auth: AuthHandler) -> Self

Set authentication on the engine.

pub fn mount(&self) -> &Path

Get the engine mount point.

Trait Implementations

impl Controller for Engine

fn handle<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 Request, ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle the request and return a response. Implement this function to define how your controller will respond to requests. This method is asynchronous, and since we use async_trait, the signature can be a bit confusing. The actual method is:

fn auth(&self) -> &AuthHandler

Set the authentication mechanism for this controller. Default authentication method is to allow all requests, but can be adjusted through configuration.

fn middleware(&self) -> &MiddlewareSet

Configure middleware on this controller. Global middleware can be set in the configuration. By default, controllers have no middleware.

fn skip_csrf(&self) -> bool

Don’t use CSRF protection on this controller. You generally don’t want to disable this unless you have another mechanism to make sure your users are not being duped into making requests to your app from somewhere else.

fn route(self, path: &str) -> Handler

where Self: Sized + 'static,

Create a basic route handler for this controller.

fn wildcard(self, path: &str) -> Handler

where Self: Sized + 'static,

Create a wildcard route handler for this controller.

fn handle_stream<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, request: &'life1 Request, stream: Stream<'life2>, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Internal function that handlers the TCP connection directly after a response has been sent to the client by the controller. This is typically used for WebSocket connections, but can also be used to stream data like video.

fn handle_internal<'life0, 'async_trait>( &'life0 self, request: Request, ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Internal function which implements the bulk of Rwf controller logic. Do not implement this unless you’re looking to do something entirely different.

fn controller_name(&self) -> &'static str

The name of this controller. Used for logging. All names are globally unique, so you won’t need to override this method.

impl Default for Engine

fn default() -> Engine

Returns the “default value” for a type.