Struct StaticFiles

pub struct StaticFiles { /* private fields */ }

Static files controller.

Implementations

impl StaticFiles

pub fn serve(path: &str) -> Result<Handler>

Create a controller handler to serve static files from this path.

pub fn new(path: &str) -> Result<Self>

Create a static files controller seriving this path. The path can be relative or absolute.

pub fn cached(path: &str, duration: Duration) -> Result<Handler>

Serve static files with the specified Cache-Control: max-age attribute.

pub fn preload(self, path: impl AsRef<Path> + Copy, bytes: &[u8]) -> Self

Preload a static file into memory. This allows static files to load and serve files which may not be available at runtime, e.g. by using include_bytes.

Example

StaticFiles::new("static")
    .unwrap()
    .preload("/style.css", b"body { background: black; }");

pub fn cache_control(self, cache_control: CacheControl) -> Self

Set the Cache-Control header.

pub fn prefix(self, prefix: &str) -> Self

Set the prefix used in URLs.

For example, if the prefix static is set, all URLs to static file should start with /static. They will be rewritten internally to find the right file in the static folder.

pub fn handler(self) -> Handler

Trait Implementations

impl Controller for StaticFiles

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.