Struct StaticDir 

#[non_exhaustive]
pub struct StaticDir {
    pub roots: Vec<PathBuf>,
    pub chunk_size: Option<u64>,
    pub include_dot_files: bool,
    pub auto_list: bool,
    pub compressed_variations: HashMap<CompressionAlgo, Vec<String>>,
    pub defaults: Vec<String>,
    pub fallback: Option<String>,
    /* private fields */
}

Handler that serves static files from directories.

This handler can serve files from one or more directory paths, with support for directory listing, compressed file variants, and default files.

Examples

use salvo_core::prelude::*;
use salvo_serve_static::StaticDir;

let router = Router::new()
    .push(Router::with_path("static/<**>")
        .get(StaticDir::new(["assets", "static"])
            .defaults("index.html")
            .auto_list(true)));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

roots: Vec<PathBuf>

Static root directories to search for files

chunk_size: Option<u64>

Chunk size for file reading (in bytes)

include_dot_files: bool

Whether to include dot files (files/directories starting with .)

auto_list: bool

Whether to automatically list directories when default file isn’t found

compressed_variations: HashMap<CompressionAlgo, Vec<String>>

Map of compression algorithms to file extensions for compressed variants

defaults: Vec<String>

Default file names to look for in directories (e.g., “index.html”)

fallback: Option<String>

Fallback file to serve when requested file isn’t found

Implementations

impl StaticDir

pub fn new<T>(roots: T) -> StaticDir

where T: StaticRoots,

Create new StaticDir.

pub fn include_dot_files(self, include_dot_files: bool) -> StaticDir

Sets include_dot_files.

pub fn exclude<F>(self, filter: F) -> StaticDir

where F: Fn(&str) -> bool + Send + Sync + 'static,

Exclude files.

The filter function returns true to exclude the file.

pub fn auto_list(self, auto_list: bool) -> StaticDir

Sets auto_list.

pub fn compressed_variation<A>(self, algo: A, exts: &str) -> StaticDir

where A: Into<CompressionAlgo>,

Sets compressed_variations.

pub fn defaults(self, defaults: impl IntoVecString) -> StaticDir

Sets defaults.

pub fn fallback(self, fallback: impl Into<String>) -> StaticDir

Sets fallback.

pub fn chunk_size(self, size: u64) -> StaticDir

During the file chunk read, the maximum read size at one time will affect the access experience and the demand for server memory.

Please set it according to your own situation.

The default is 1M.

Trait Implementations

impl Handler for StaticDir

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, _depot: &'life2 mut Depot, res: &'life3 mut Response, _ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, StaticDir: 'async_trait,

Handle http request.

fn arc(self) -> ArcHandler

where Self: Sized,

Wrap to ArcHandler.

fn hooped<H>(self) -> HoopedHandler

where H: Handler, Self: Sized,

Wrap to HoopedHandler.

fn hoop<H>(self, hoop: H) -> HoopedHandler

where H: Handler, Self: Sized,

Hoop this handler with middleware.

fn hoop_when<H, F>(self, hoop: H, filter: F) -> HoopedHandler

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

Hoop this handler with middleware.