Struct rocket::fs::FileServer[][src]

pub struct FileServer { /* fields omitted */ }
Expand description

Custom handler for serving static files.

This handler makes it simple to serve static files from a directory on the local file system. To use it, construct a FileServer using either FileServer::from() or FileServer::new() then simply mount the handler at a desired path. When mounted, the handler will generate route(s) that serve the desired static files. If a requested file is not found, the routes forward the incoming request. The default rank of the generated routes is 10. To customize route ranking, use the FileServer::rank() method.

Options

The handler’s functionality can be customized by passing an Options to FileServer::new().

Example

To serve files from the /static directory on the local file system at the /public path, allowing index.html files to be used to respond to requests for a directory (the default), you might write the following:

use rocket::fs::FileServer;

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/public", FileServer::from("/static"))
}

With this, requests for files at /public/<path..> will be handled by returning the contents of /static/<path..>. Requests for directories at /public/<directory> will be handled by returning the contents of /static/<directory>/index.html.

Relative Paths

In the example above, /static is an absolute path. If your static files are stored relative to your crate and your project is managed by Rocket, use the relative! macro to obtain a path that is relative to your crate’s root. For example, to serve files in the static subdirectory of your crate at /, you might write:

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

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", FileServer::from(relative!("static")))
}

Implementations

impl FileServer[src]

pub fn from<P: AsRef<Path>>(path: P) -> Self[src]

Constructs a new FileServer that serves files from the file system path. By default, Options::Index is set, and the generated routes have a rank of 10. To serve static files with other options, use FileServer::new(). To choose a different rank for generated routes, use FileServer::rank().

Panics

Panics if path does not exist or is not a directory.

Example

Serve the static files in the /www/public local directory on path /static.

use rocket::fs::FileServer;

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/static", FileServer::from("/www/public"))
}

Exactly as before, but set the rank for generated routes to 30.

use rocket::fs::FileServer;

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/static", FileServer::from("/www/public").rank(30))
}

pub fn new<P: AsRef<Path>>(path: P, options: Options) -> Self[src]

Constructs a new FileServer that serves files from the file system path with options enabled. By default, the handler’s routes have a rank of 10. To choose a different rank, use FileServer::rank().

Panics

Panics if path does not exist or is not a directory.

Example

Serve the static files in the /www/public local directory on path /static without serving index files or dot files. Additionally, serve the same files on /pub with a route rank of -1 while also serving index files and dot files.

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

#[launch]
fn rocket() -> _ {
    let options = Options::Index | Options::DotFiles;
    rocket::build()
        .mount("/static", FileServer::from("/www/public"))
        .mount("/pub", FileServer::new("/www/public", options).rank(-1))
}

pub fn rank(self, rank: isize) -> Self[src]

Sets the rank for generated routes to rank.

Example

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

// A `FileServer` created with `from()` with routes of rank `3`.
FileServer::from("/public").rank(3);

// A `FileServer` created with `new()` with routes of rank `-15`.
FileServer::new("/public", Options::Index).rank(-15);

Trait Implementations

impl Clone for FileServer[src]

fn clone(&self) -> FileServer[src]

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl Debug for FileServer[src]

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

Formats the value using the given formatter. Read more

impl Handler for FileServer[src]

fn handle<'r, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    req: &'r Request<'life1>,
    data: Data<'r>
) -> Pin<Box<dyn Future<Output = Outcome<'r>> + Send + 'async_trait>> where
    'r: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 
[src]

Called by Rocket when a Request with its associated Data should be handled by this handler. Read more

impl Into<Vec<Route, Global>> for FileServer[src]

fn into(self) -> Vec<Route>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
[src]

Performs the conversion.

Auto Trait Implementations

impl RefUnwindSafe for FileServer

impl Send for FileServer

impl Sync for FileServer

impl Unpin for FileServer

impl UnwindSafe for FileServer

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T> Instrument for T[src]

fn instrument(self, span: Span) -> Instrumented<Self>[src]

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>[src]

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> IntoCollection<T> for T

pub fn into_collection<A>(self) -> SmallVec<A> where
    A: Array<Item = T>, 

Converts self into a collection.

pub fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
    F: FnMut(T) -> U,
    A: Array<Item = U>, 

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T[src]

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)[src]

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

pub fn vzip(self) -> V