Struct http_dir::ServeFile

pub struct ServeFile<FS, F = DefaultServeDirFallback> { /* private fields */ }

Service that serves a file

Implementations

impl<FS> ServeFile<FS, DefaultServeDirFallback>

pub fn new<P: Into<PathBuf>>(path: P, filesystem: FS) -> Self

Create a new ServeFile.

The Content-Type will be guessed from the file extension.

pub fn new_with_mime<P: Into<PathBuf>>(
    path: P,
    mime: &Mime,
    filesystem: FS
) -> Self

Create a new ServeFile with a specific mime type.

Panics

Will panic if the mime type isn’t a valid header value.

impl<FS, F> ServeFile<FS, F>

pub fn with_buf_chunk_size(self, chunk_size: usize) -> Self

Set a specific read buffer chunk size.

The default capacity is 64kb.

pub fn precompressed_gzip(self) -> Self

Informs the service that it should also look for a precompressed gzip version of any file in the directory.

Assuming the dir directory is being served and dir/foo.txt is requested, a client with an Accept-Encoding header that allows the gzip encoding will receive the file dir/foo.txt.gz instead of dir/foo.txt. If the precompressed file is not available, or the client doesn’t support it, the uncompressed version will be served instead. Both the precompressed version and the uncompressed version are expected to be present in the directory. Different precompressed variants can be combined.

pub fn precompressed_br(self) -> Self

Informs the service that it should also look for a precompressed brotli version of any file in the directory.

Assuming the dir directory is being served and dir/foo.txt is requested, a client with an Accept-Encoding header that allows the brotli encoding will receive the file dir/foo.txt.br instead of dir/foo.txt. If the precompressed file is not available, or the client doesn’t support it, the uncompressed version will be served instead. Both the precompressed version and the uncompressed version are expected to be present in the directory. Different precompressed variants can be combined.

pub fn precompressed_deflate(self) -> Self

Informs the service that it should also look for a precompressed deflate version of any file in the directory.

Assuming the dir directory is being served and dir/foo.txt is requested, a client with an Accept-Encoding header that allows the deflate encoding will receive the file dir/foo.txt.zz instead of dir/foo.txt. If the precompressed file is not available, or the client doesn’t support it, the uncompressed version will be served instead. Both the precompressed version and the uncompressed version are expected to be present in the directory. Different precompressed variants can be combined.

Trait Implementations

impl<FS: Clone, F: Clone> Clone for ServeFile<FS, F>

fn clone(&self) -> ServeFile<FS, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<FS: Debug, F: Debug> Debug for ServeFile<FS, F>

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

Formats the value using the given formatter.

impl<ReqBody, F, FResBody, FS> Service<Request<ReqBody>> for ServeFile<FS, F>where
    F: Service<Request<ReqBody>, Response = Response<FResBody>> + Clone,
    F::Error: Into<Error>,
    F::Future: Send,
    FResBody: Body<Data = Bytes> + Send + 'static,
    FResBody::Error: Into<Box<dyn Error + Send + Sync>>,
    FS: Filesystem + Clone + Send + Sync + 'static,
    FS::File: 'static,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = impl Future<Output = Result<<ServeFile<FS, F> as Service<Request<ReqBody>>>::Response, <ServeFile<FS, F> as Service<Request<ReqBody>>>::Error>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<ReqBody>) -> Self::Future

Process the request and return the response asynchronously.