Struct App 

pub struct App<M: Module> { /* private fields */ }

Implementations

impl<M: Module> App<M>

pub fn new( name: &'static str, version: &'static str, module_builder: ModuleBuilder<M>, ) -> Self

It is recommended to use the new_app![ModuleType,...] macro to create an App. This method is mainly provided for use by this macro.

pub fn with_component_parameters<C: Component<M>>( self, params: C::Parameters, ) -> Self

where M: HasComponent<C::Interface>,

Set the parameters of the specified component. If the parameters are not manually set, the defaults will be used.

pub fn with_component_override<I: Interface + ?Sized>( self, component: Box<I>, ) -> Self

where M: HasComponent<I>,

Override a component implementation. This method is best used when the overriding component has no injected dependencies.

pub fn with_component_override_fn<I: Interface + ?Sized>( self, component_fn: ComponentFn<M, I>, ) -> Self

where M: HasComponent<I>,

Override a component implementation. This method is best used when the overriding component has injected dependencies.

pub const fn with_routable_preset(self, routable_preset: bool) -> Self

Set the preset value of routable.

pub fn with_unroutable_scribe( self, unroutable_scribe: Arc<dyn UnroutableScribe>, ) -> Self

Set up a scribe that provides a response when the module is not allowed to be accessed.

pub fn path_prefix(self, path: impl Into<String>) -> Self

Set the global route path prefix.

Panics

Panics if path value is not in correct format.

pub fn router_push(self, router: Router) -> Self

Push a router as child of current router.

pub fn dm_router_hoop<H: Handler>(self, hoop: H) -> Self

Add middleware for the routes of dynamic modules.

pub fn dm_router_hoop_when<H, F>(self, hoop: H, filter: F) -> Self

where H: Handler, F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static,

Add middleware for the routes of dynamic modules. This middleware only effective when the filter return true.

pub fn router_then<F>(self, func: F) -> Self

where F: FnOnce(Router) -> Router,

When you want write router chain, this function will be useful, You can write your custom logic in FnOnce.

pub fn router_scheme(self, scheme: Scheme) -> Self

Add a SchemeFilter to current router.

pub fn router_host(self, host: impl Into<String>) -> Self

Add a HostFilter to current router.

pub fn service_catcher(self, catcher: impl Into<Arc<Catcher>>) -> Self

When the response code is 400-600 and the body is empty, capture and set the error page content. If catchers is not set, the default error page will be used.

Example

use dipper::{catcher::Catcher, prelude::*};

#[handler]
async fn handle404(
    &self,
    _req: &Request,
    _depot: &Depot,
    res: &mut Response,
    ctrl: &mut FlowCtrl,
) {
    if let Some(StatusCode::NOT_FOUND) = res.status_code {
        res.render("Custom 404 Error Page");
        ctrl.skip_rest();
    }
}

#[tokio::main]
async fn main() {
    Service::new(Router::new()).catcher(Catcher::default().hoop(handle404));
}

pub fn service_hoop<H: Handler>(self, hoop: H) -> Self

Add a handler as middleware, it will run the handler when request received.

pub fn service_hoop_when<H, F>(self, hoop: H, filter: F) -> Self

where H: Handler, F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static,

Add a handler as middleware, it will run the handler when request received.

This middleware only effective when the filter return true.

pub fn allowed_media_types<T>(self, allowed_media_types: T) -> Self

where T: Into<Arc<Vec<Mime>>>,

Sets allowed media types list and returns Self for write code chained.

Example

let service = Service::new(Router::new()).allowed_media_types(vec![mime::TEXT_PLAIN]);

pub async fn run(self, local_addr: impl ToSocketAddrs + Send)

Run server. local_addr can be "0.0.0.0:8888".