Struct hyper_staticfile::Resolver

pub struct Resolver<O = TokioFileOpener> {
    pub opener: Arc<O>,
    pub allowed_encodings: AcceptEncoding,
}

Resolves request paths to files.

This struct resolves 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.

Cloning this struct is a cheap operation.

Fields

opener: Arc<O>

The (virtual) filesystem used to open files.

allowed_encodings: AcceptEncoding

Encodings the client is allowed to request with Accept-Encoding.

This only supports pre-encoded files, that exist adjacent to the original file, but with an additional .br or .gz suffix (after the original extension).

Typically initialized with AcceptEncoding::all() or AcceptEncoding::none().

Implementations

impl Resolver<TokioFileOpener>

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

Create a resolver that resolves files inside a root directory on the regular filesystem.

Examples found in repository

src/service.rs (line 40)

    pub fn new(root: impl Into<PathBuf>) -> Self {
        Self {
            resolver: Resolver::new(root),
            cache_headers: None,
        }
    }

impl<O: FileOpener> Resolver<O>

pub fn with_opener(opener: O) -> Self

Create a resolver with a custom file opener.

Examples found in repository

src/resolve.rs (line 101)

    pub fn new(root: impl Into<PathBuf>) -> Self {
        Self::with_opener(TokioFileOpener::new(root))
    }

src/service.rs (line 50)

    pub fn with_opener(opener: O) -> Self {
        Self {
            resolver: Resolver::with_opener(opener),
            cache_headers: None,
        }
    }

pub async fn resolve_request<B>(
    &self,
    req: &Request<B>
) -> Result<ResolveResult<O::File>, IoError>

Resolve the request by trying to find the file in the root.

The returned future may error for unexpected IO errors, passing on the std::io::Error. Certain expected IO errors are handled, though, and simply reflected in the result. These are NotFound and PermissionDenied.

Examples found in repository

src/service.rs (line 76)

    pub async fn serve<B>(
        self,
        request: Request<B>,
    ) -> Result<Response<Body<<O::File as IntoFileAccess>::Output>>, IoError> {
        let Self {
            resolver,
            cache_headers,
        } = self;
        resolver.resolve_request(&request).await.map(|result| {
            ResponseBuilder::new()
                .request(&request)
                .cache_headers(cache_headers)
                .build(result)
                .expect("unable to build response")
        })
    }

pub async fn resolve_path(
    &self,
    request_path: &str,
    accept_encoding: AcceptEncoding
) -> Result<ResolveResult<O::File>, IoError>

Resolve the request path by trying to find the file in the given root.

The returned future may error for unexpected IO errors, passing on the std::io::Error. Certain expected IO errors are handled, though, and simply reflected in the result. These are NotFound and PermissionDenied.

Note that, unlike resolve_request, it is up to the caller to check the request method and optionally the ‘Accept-Encoding’ header.

Examples found in repository

src/resolve.rs (line 139)

    pub async fn resolve_request<B>(
        &self,
        req: &Request<B>,
    ) -> Result<ResolveResult<O::File>, IoError> {
        // Handle only `GET`/`HEAD` and absolute paths.
        match *req.method() {
            Method::HEAD | Method::GET => {}
            _ => {
                return Ok(ResolveResult::MethodNotMatched);
            }
        }

        // Parse `Accept-Encoding` header.
        let accept_encoding = self.allowed_encodings
            & req
                .headers()
                .get(header::ACCEPT_ENCODING)
                .map(AcceptEncoding::from_header_value)
                .unwrap_or(AcceptEncoding::none());

        self.resolve_path(req.uri().path(), accept_encoding).await
    }

Trait Implementations

impl<O> Clone for Resolver<O>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.