Crate hyper_staticfile

source ·
Expand description

Static file-serving for Hyper 1.0.

This library exports a high-level interface Static for simple file-serving, and lower-level interfaces for more control over responses.

§Basic usage

The Static type is essentially a struct containing some settings, and a serve method to handle the request. It follows the builder pattern, and also implements the hyper::Service trait. It can be used as:

// Instance of `Static` containing configuration. Can be cheaply cloned.
let static_ = hyper_staticfile::Static::new("my/doc/root/");

// A dummy request, but normally obtained from Hyper.
let request = http::Request::get("/foo/bar.txt")

// Serve the request. Returns a future for a `hyper::Response`.
let response_future = static_.serve(request);

Typically, you’d store the Static instance somewhere, such as in your own hyper::Service implementation.

§Advanced usage

The Static type is a simple wrapper for Resolver and ResponseBuilder. You can achieve the same by doing something similar to the following:

use std::path::Path;

async fn main() {
    // Create a resolver. This can be cheaply cloned.
    let resolver = hyper_staticfile::Resolver::new("my/doc/root/");

    // A dummy request, but normally obtained from Hyper.
    let request = http::Request::get("/foo/bar.txt")

    // First, resolve the request. Returns a future for a `ResolveResult`.
    let result = resolver.resolve_request(&request).await.unwrap();

    // Then, build a response based on the result.
    // The `ResponseBuilder` is typically a short-lived, per-request instance.
    let response = hyper_staticfile::ResponseBuilder::new()

The resolve_request method tries to find the file in the document root, and returns a future for the ResolveResult enum, which determines what kind of response should be sent. The ResponseBuilder is then used to create a default response. It holds some settings, and can be constructed using the builder pattern.

It’s useful to sit between these two steps to implement custom 404 pages, for example. Your custom logic can override specific cases of ResolveResult, and fall back to the default behavior using ResponseBuilder if necessary.


  • Lower level utilities.
  • Types to implement a custom (virtual) filesystem to serve files from.


  • Flags for which encodings to resolve.
  • All of the parsed request parameters used in resolving a file.
  • Struct containing all the required data to serve a file.
  • Resolves request paths to files.
  • Utility to build the default response for a resolve result.
  • High-level interface for serving static files.


  • Hyper Body implementation for the various types of streams used in static serving.
  • Type of response encoding.
  • The result of Resolver methods.

Type Aliases§

  • Future returned by a rewrite function. See Resolver::set_rewrite.