Struct CachedCompression 

pub struct CachedCompression {
    pub cached_paths: Vec<String>,
    pub cached_path_prefixes: Vec<String>,
    pub cached_path_suffixes: Vec<String>,
    pub excluded_path_prefixes: Vec<String>,
    pub level: Option<Level>,
}

Compresses all responses with Brotli or Gzip compression. Caches compressed response bodies in memory for selected file types/path suffixes, useful for compressing large compiled JS/CSS files, OTF font packs, etc. Note that all cached files are held in memory indefinitely.

Compression is done in the same manner as the Compression fairing.

Usage

Attach the compression fairing to your Rocket application:

use rocket_async_compression::CachedCompression;

rocket::build()
    // ...
    .attach(CachedCompression {
        cached_paths: vec![
            "".to_owned(),
            "/".to_owned(),
            "/about".to_owned(),
            "/people".to_owned(),
            "/posts".to_owned(),
            "/events".to_owned(),
            "/groups".to_owned(),
        ],
        cached_path_prefixes: vec!["/user/".to_owned(), "/g/".to_owned(), "/p/".to_owned()],
        cached_path_suffixes: vec![".otf".to_owned(), "main.dart.js".to_owned()],
        ..Default::default()
    })
    // ...

Fields

cached_paths: Vec<String>

cached_path_prefixes: Vec<String>

cached_path_suffixes: Vec<String>

excluded_path_prefixes: Vec<String>

level: Option<Level>

Implementations

impl CachedCompression

pub fn exact_path_fairing(cached_paths: Vec<String>) -> CachedCompression

Caches only the specific paths provided.

pub fn path_suffix_fairing( cached_path_suffixes: Vec<String>, ) -> CachedCompression

Caches all paths with the provided suffixes.

Examples found in repository

examples/cached-compression/main.rs (line 14)

async fn rocket() -> _ {
    rocket::build()
        .mount(
            "/",
            FileServer::from(relative!("examples/cached-compression/static")),
        )
        .attach(CachedCompression::path_suffix_fairing(CachedCompression::static_paths(vec![".txt"])))
}

pub fn path_prefix_fairing( cached_path_prefixes: Vec<String>, ) -> CachedCompression

Caches all paths with the provided suffixes.

pub fn excluded_path_prefix_fairing( excluded_path_prefixes: Vec<String>, ) -> CachedCompression

Caches compressed responses for all paths except those with the excluded prefixes.

pub fn static_paths(paths: Vec<&str>) -> Vec<String>

Caches Vec<&str> to Vec<String>.

Examples found in repository

examples/cached-compression/main.rs (line 14)

async fn rocket() -> _ {
    rocket::build()
        .mount(
            "/",
            FileServer::from(relative!("examples/cached-compression/static")),
        )
        .attach(CachedCompression::path_suffix_fairing(CachedCompression::static_paths(vec![".txt"])))
}

Trait Implementations

impl Default for CachedCompression

fn default() -> CachedCompression

Returns the “default value” for a type.

impl Fairing for CachedCompression

fn info(&self) -> Info

Returns an Info structure containing the name and Kind of this fairing. The name can be any arbitrary string. Kind must be an ord set of Kind variants.

fn on_response<'r, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, request: &'r Request<'life1>, response: &'life2 mut Response<'r>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The response callback.

fn on_ignite<'life0, 'async_trait>( &'life0 self, rocket: Rocket<Build>, ) -> Pin<Box<dyn Future<Output = Result<Rocket<Build>, Rocket<Build>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

The ignite callback. Returns Ok if ignition should proceed and Err if ignition and launch should be aborted.

fn on_liftoff<'life0, 'life1, 'async_trait>( &'life0 self, _rocket: &'life1 Rocket<Orbit>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

The liftoff callback.

fn on_request<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _req: &'life1 mut Request<'life2>, _data: &'life3 mut Data<'life4>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: 'async_trait,

The request callback.

fn on_shutdown<'life0, 'life1, 'async_trait>( &'life0 self, _rocket: &'life1 Rocket<Orbit>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

The shutdown callback.