Struct actix_files::Files

pub struct Files { /* fields omitted */ }

Static files handling

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

use actix_web::App;
use actix_files as fs;

fn main() {
    let app = App::new()
        .service(fs::Files::new("/static", "."));
}

Methods

impl Files

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

Create new Files instance for specified base directory.

File uses ThreadPool for blocking filesystem operations. By default pool with 5x threads of available cpus is used. Pool size can be changed by setting ACTIX_CPU_POOL environment variable.

pub fn show_files_listing(self) -> Self

Show files listing for directories.

By default show files listing is disabled.

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 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: IntoNewService<U>,
    U: NewService<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error> + 'static, 

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

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 NewService for Files

type Config = ()

Service factory configuration

type Request = ServiceRequest

Requests handled by the service.

type Response = ServiceResponse

Responses given by the service

type Error = Error

Errors produced by the service

type Service = FilesService

The Service value created by this factory

type InitError = ()

Errors produced while building a service.

type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>

The future of the Service instance.

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

Create and return a new service value asynchronously.

fn apply<T, T1, B, B1>(
    self,
    transform: T1,
    service: B1
) -> AndThenTransform<T, Self, B> where
    B: NewService<Config = Self::Config, InitError = Self::InitError>,
    B1: IntoNewService<B>,
    T: Transform<<B as NewService>::Service, Request = Self::Response, InitError = Self::InitError>,
    T1: IntoTransform<T, <B as NewService>::Service>,
    <T as Transform<<B as NewService>::Service>>::Error: From<Self::Error>, 

Apply transform service to specified service and use it as a next service in chain.

fn apply_fn<B, I, F, Out>(
    self,
    service: I,
    f: F
) -> AndThenApplyNewService<Self, B, F, Out> where
    B: NewService<Config = Self::Config, Error = Self::Error, InitError = Self::InitError>,
    F: FnMut(Self::Response, &mut <B as NewService>::Service) -> Out,
    I: IntoNewService<B>,
    Out: IntoFuture,
    <Out as IntoFuture>::Error: Into<Self::Error>, 

Apply function to specified service and use it as a next service in chain.

fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B> where
    B: NewService<Config = Self::Config, Request = Self::Response, Error = Self::Error, InitError = Self::InitError>,
    F: IntoNewService<B>, 

Call another service after call to this one has resolved successfully.

fn from_err<E>(self) -> FromErrNewService<Self, E> where
    E: From<Self::Error>, 

NewService that create service to map this service's error and new service's init error to any error implementing From for this services Error`.

fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B> where
    B: NewService<Config = Self::Config, Request = Result<Self::Response, Self::Error>, Error = Self::Error, InitError = Self::InitError>,
    F: IntoNewService<B>, 

Create NewService to chain on a computation for when a call to the service finished, passing the result of the call to the next service B.

fn map<F, R>(self, f: F) -> MapNewService<Self, F, R> where
    F: FnMut(Self::Response) -> R, 

Map this service's output to a different type, returning a new service of the resulting type.

fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E> where
    F: Fn(Self::Error) -> E + Clone, 

Map this service's error to a different error, returning a new service.

fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E> where
    F: Fn(Self::InitError) -> E, 

Map this factory's init error to a different error, returning a new service.

fn map_config<F, C>(self, f: F) -> MapConfig<Self, F, C> where
    F: Fn(&C) -> MappedConfig<Self::Config>, 

Map config to a different error, returning a new service.

fn unit_config<C>(self) -> UnitConfig<Self, C> where
    Self: NewService<Config = ()>, 

Replace config with unit

impl HttpServiceFactory for Files

fn register(self, config: &mut AppService)