Struct ServeFile 

pub struct ServeFile(/* private fields */);

Service that serves a file.

Implementations

impl ServeFile

pub fn new<P>(path: P) -> ServeFile

where P: AsRef<Path>,

Create a new ServeFile.

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

pub fn new_with_mime<P>(path: P, mime: &Mime) -> ServeFile

where P: AsRef<Path>,

Create a new ServeFile with a specific mime type.

Panics

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

pub fn precompressed_gzip(self) -> ServeFile

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

If the client has an Accept-Encoding header that allows the gzip encoding, the file foo.txt.gz will be served instead of 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 same directory. Different precompressed variants can be combined.

pub fn precompressed_br(self) -> ServeFile

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

If the client has an Accept-Encoding header that allows the brotli encoding, the file foo.txt.br will be served instead of 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 same directory. Different precompressed variants can be combined.

pub fn precompressed_deflate(self) -> ServeFile

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

If the client has an Accept-Encoding header that allows the deflate encoding, the file foo.txt.zz will be served instead of 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 same directory. Different precompressed variants can be combined.

pub fn precompressed_zstd(self) -> ServeFile

Informs the service that it should also look for a precompressed zstd version of the file.

If the client has an Accept-Encoding header that allows the zstd encoding, the file foo.txt.zst will be served instead of 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 same directory. Different precompressed variants can be combined.

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

Set a specific read buffer chunk size.

The default capacity is 64kb.

pub fn try_call<ReqBody>( &mut self, req: Request<ReqBody>, ) -> ResponseFuture<ReqBody>

where ReqBody: Send + 'static,

Call the service and get a future that contains any std::io::Error that might have happened.

See ServeDir::try_call for more details.

Trait Implementations

impl Clone for ServeFile

fn clone(&self) -> ServeFile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ServeFile

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

Formats the value using the given formatter.

impl<ReqBody> Service<Request<ReqBody>> for ServeFile

where ReqBody: Send + 'static,

type Error = <ServeDir as Service<Request<ReqBody>>>::Error

Errors produced by the service.

type Response = <ServeDir as Service<Request<ReqBody>>>::Response

Responses given by the service.

type Future = <ServeDir as Service<Request<ReqBody>>>::Future

The future response value.

fn poll_ready( &mut self, _cx: &mut Context<'_>, ) -> Poll<Result<(), <ServeFile as Service<Request<ReqBody>>>::Error>>

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

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

Process the request and return the response asynchronously.