Struct actix_files::Files

pub struct Files { /* fields omitted */ }

Static files handling service.

Files service must be registered with App::service() method.

use actix_web::App;
use actix_files::Files;

let app = App::new()
    .service(Files::new("/static", "."));

Implementations

impl Files

pub fn new<T: Into<PathBuf>>(mount_path: &str, serve_from: T) -> Files

Create new Files instance for a specified base directory.

Argument Order

The first argument (mount_path) is the root URL at which the static files are served. For example, /assets will serve files at example.com/assets/....

The second argument (serve_from) is the location on disk at which files are loaded. This can be a relative path. For example, ./ would serve files from the current working directory.

Implementation Notes

If the mount path is set as the root path /, services registered after this one will be inaccessible. Register more specific handlers and services first.

Files utilizes the existing Tokio thread-pool for blocking filesystem operations. The number of running threads is adjusted over time as needed, up to a maximum of 512 times the number of server workers, by default.

pub fn show_files_listing(self) -> Self

Show files listing for directories.

By default show files listing is disabled.

pub fn redirect_to_slash_directory(self) -> Self

Redirects to a slash-ended path when browsing a directory.

By default never redirect.

pub fn files_listing_renderer<F>(self, f: F) -> Self where
    F: Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, Error> + 'static, 

Set custom directory renderer

pub fn mime_override<F>(self, f: F) -> Self where
    F: Fn(&Name<'_>) -> DispositionType + 'static, 

Specifies mime override callback

pub fn index_file<T: Into<String>>(self, index: T) -> Self

Set index file

Shows specific index file for directory “/” instead of showing files listing.

pub fn use_etag(self, value: bool) -> Self

Specifies whether to use ETag or not.

Default is true.

pub fn use_last_modified(self, value: bool) -> Self

Specifies whether to use Last-Modified or not.

Default is true.

pub fn prefer_utf8(self, value: bool) -> Self

Specifies whether text responses should signal a UTF-8 encoding.

Default is false (but will default to true in a future version).

pub fn guard<G: Guard + 'static>(self, guard: G) -> Self

Adds a routing guard.

Use this to allow multiple chained file services that respond to strictly different properties of a request. Due to the way routing works, if a guard check returns true and the request starts being handled by the file service, it will not be able to back-out and try the next service, you will simply get a 404 (or 405) error response.

To allow POST requests to retrieve files, see Files::use_guards.

Examples

use actix_web::{guard::Header, App};
use actix_files::Files;

App::new().service(
    Files::new("/","/my/site/files")
        .guard(Header("Host", "example.com"))
);

pub fn method_guard<G: Guard + 'static>(self, guard: G) -> Self

Specifies guard to check before fetching directory listings or files.

Note that this guard has no effect on routing; it’s main use is to guard on the request’s method just before serving the file, only allowing GET and HEAD requests by default. See Files::guard for routing guards.

pub fn disable_content_disposition(self) -> Self

Disable Content-Disposition header.

By default Content-Disposition` header is enabled.

pub fn default_handler<F, U>(self, f: F) -> Self where
    F: IntoServiceFactory<U, ServiceRequest>,
    U: ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse, Error = Error> + 'static, 

Sets default handler which is used when no matched file could be found.

Examples

Setting a fallback static file handler:

use actix_files::{Files, NamedFile};

let files = Files::new("/", "./static")
    .index_file("index.html")
    .default_handler(NamedFile::open("./static/404.html")?);

pub fn use_hidden_files(self) -> Self

Enables serving hidden files and directories, allowing a leading dots in url fragments.

Trait Implementations

impl Clone for Files

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Files

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HttpServiceFactory for Files

fn register(self, config: &mut AppService)

impl ServiceFactory<ServiceRequest> for Files

type Response = ServiceResponse

Responses given by the created services.

type Error = Error

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = FilesService

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>

The future of the Service instance.g

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service asynchronously.