Struct hyper_staticfile::Static

pub struct Static<O = TokioFileOpener> {
    pub resolver: Resolver<O>,
    pub cache_headers: Option<u32>,
}

High-level interface for serving static files.

This services serves files based on the request path. The path is first sanitized, then mapped to a file on the filesystem. If the path corresponds to a directory, it will try to look for a directory index.

This struct allows direct access to its fields, but these fields are typically initialized by the accessors, using the builder pattern. The fields are basically a bunch of settings that determine the response details.

This struct also implements the hyper::Service trait, which simply wraps Static::serve. Note that using the trait currently involves an extra Box.

Cloning this struct is a cheap operation.

Fields

resolver: Resolver<O>

The resolver instance used to open files.

cache_headers: Option<u32>

Whether to send cache headers, and what lifespan to indicate.

Implementations

impl Static<TokioFileOpener>

pub fn new(root: impl Into<PathBuf>) -> Self

Create a new instance of Static with a given root path.

The path may be absolute or relative. If Path::new("") is used, files will be served from the current directory.

impl<O: FileOpener> Static<O>

pub fn with_opener(opener: O) -> Self

Create a new instance of Static with the given root directory.

pub fn cache_headers(&mut self, value: Option<u32>) -> &mut Self

Add cache headers to responses for the given lifespan.

pub fn allowed_encodings( &mut self, allowed_encodings: AcceptEncoding ) -> &mut Self

Set the encodings the client is allowed to request via the Accept-Encoding header.

pub async fn serve<B>( self, request: Request<B> ) -> Result<Response<Body<<O::File as IntoFileAccess>::Output>>, IoError>

Serve a request.

Trait Implementations

impl<O> Clone for Static<O>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O, B> Service<Request<B>> for Static<O>where O: FileOpener, B: Send + Sync + 'static,

type Response = Response<Body<<<O as FileOpener>::File as IntoFileAccess>::Output>>

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<Static<O> as Service<Request<B>>>::Response, <Static<O> as Service<Request<B>>>::Error>> + Send>>

The future response value.

fn call(&self, request: Request<B>) -> Self::Future

Process the request and return the response asynchronously. call takes a &self instead of a mut &self because: