Struct rocket::fs::Options

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

A bitset representing configurable options for FileServer.

The valid options are:

• Options::None - Return only present, visible files.
• Options::DotFiles - In addition to visible files, return dotfiles.
• Options::Index - Render index.html pages for directory requests.
• Options::IndexFile - Allow serving a single file as the index.
• Options::Missing - Don’t fail if the path to serve is missing.
• Options::NormalizeDirs - Redirect directories without a trailing slash to ones with a trailing slash.

Options structures can be ord together to select two or more options. For instance, to request that both dot files and index pages be returned, use Options::DotFiles | Options::Index.

Implementations

impl Options

pub const None: Options = _

All options disabled.

Note that this is different than Options::default(), which enables options.

pub const Index: Options = _

Respond to requests for a directory with the index.html file in that directory, if it exists.

When enabled, FileServer will respond to requests for a directory /foo or /foo/ with the file at ${root}/foo/index.html if it exists. When disabled, requests to directories will always forward.

Enabled by default.

pub const DotFiles: Options = _

Allow serving dotfiles.

When enabled, FileServer will respond to requests for files or directories beginning with .. When disabled, any dotfiles will be treated as missing.

Disabled by default.

pub const NormalizeDirs: Options = _

Normalizes directory requests by redirecting requests to directory paths without a trailing slash to ones with a trailing slash.

Enabled by default.

When enabled, the FileServer handler will respond to requests for a directory without a trailing / with a permanent redirect (308) to the same path with a trailing /. This ensures relative URLs within any document served from that directory will be interpreted relative to that directory rather than its parent.

Example

Given the following directory structure…

static/
└── foo/
    ├── cat.jpeg
    └── index.html

And the following server:

rocket.mount("/", FileServer::from("static"))

…requests to example.com/foo will be redirected to example.com/foo/. If index.html references cat.jpeg as a relative URL, the browser will resolve the URL to example.com/foo/cat.jpeg, which in-turn Rocket will match to /static/foo/cat.jpg.

Without this option, requests to example.com/foo would not be redirected. index.html would be rendered, and the relative link to cat.jpeg would be resolved by the browser as example.com/cat.jpeg. Rocket would thus try to find /static/cat.jpeg, which does not exist.

pub const IndexFile: Options = _

Allow serving a file instead of a directory.

By default, FileServer will error on construction if the path to serve does not point to a directory. When this option is enabled, if a path to a file is provided, FileServer will serve the file as the root of the mount path.

Example

If the file tree looks like:

static/
└── cat.jpeg

Then cat.jpeg can be served at /cat with:

use rocket::fs::{FileServer, Options};

#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/cat", FileServer::new("static/cat.jpeg", Options::IndexFile))
}

pub const Missing: Options = _

Don’t fail if the file or directory to serve is missing.

By default, FileServer will error if the path to serve is missing to prevent inevitable 404 errors. This option overrides that.

pub fn contains(self, other: Options) -> bool

Returns true if self is a superset of other. In other words, returns true if all of the options in other are also in self.

Example

use rocket::fs::Options;

let index_request = Options::Index | Options::DotFiles;
assert!(index_request.contains(Options::Index));
assert!(index_request.contains(Options::DotFiles));

let index_only = Options::Index;
assert!(index_only.contains(Options::Index));
assert!(!index_only.contains(Options::DotFiles));

let dot_only = Options::DotFiles;
assert!(dot_only.contains(Options::DotFiles));
assert!(!dot_only.contains(Options::Index));

Trait Implementations

impl BitOr<Options> for Options

type Output = Options

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl Clone for Options

fn clone(&self) -> Options

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Options

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

Formats the value using the given formatter.

impl Default for Options

The default set of options: Options::Index | Options:NormalizeDirs.

fn default() -> Self

Returns the “default value” for a type.

impl Copy for Options