Struct rama::http::layer::compression::Compression

pub struct Compression<S, P = DefaultPredicate> { /* private fields */ }

Compress response bodies of the underlying service.

This uses the Accept-Encoding header to pick an appropriate encoding and adds the Content-Encoding header to responses.

See the module docs for more details.

Implementations

impl<S> Compression<S>

pub fn new(service: S) -> Compression<S>

Creates a new Compression wrapping the service.

impl<S, P> Compression<S, P>

pub fn get_ref(&self) -> &S

Gets a reference to the underlying service.

pub fn into_inner(self) -> S

Consumes self, returning the underlying service.

pub fn gzip(self, enable: bool) -> Compression<S, P>

Sets whether to enable the gzip encoding.

pub fn set_gzip(&mut self, enable: bool) -> &mut Compression<S, P>

Sets whether to enable the gzip encoding.

pub fn deflate(self, enable: bool) -> Compression<S, P>

Sets whether to enable the Deflate encoding.

pub fn set_deflate(&mut self, enable: bool) -> &mut Compression<S, P>

Sets whether to enable the Deflate encoding.

pub fn br(self, enable: bool) -> Compression<S, P>

Sets whether to enable the Brotli encoding.

pub fn set_br(&mut self, enable: bool) -> &mut Compression<S, P>

Sets whether to enable the Brotli encoding.

pub fn zstd(self, enable: bool) -> Compression<S, P>

Sets whether to enable the Zstd encoding.

pub fn set_zstd(&mut self, enable: bool) -> &mut Compression<S, P>

Sets whether to enable the Zstd encoding.

pub fn quality(self, quality: CompressionLevel) -> Compression<S, P>

Sets the compression quality.

pub fn set_quality( &mut self, quality: CompressionLevel, ) -> &mut Compression<S, P>

Sets the compression quality.

pub fn compress_when<C>(self, predicate: C) -> Compression<S, C>

where C: Predicate,

Replace the current compression predicate.

Predicates are used to determine whether a response should be compressed or not.

The default predicate is DefaultPredicate. See its documentation for more details on which responses it wont compress.

Changing the compression predicate

use rama_http::layer::compression::{
    Compression,
    predicate::{Predicate, NotForContentType, DefaultPredicate},
};
use rama_core::service::service_fn;

// Placeholder service_fn
let service = service_fn(|_: ()| async {
    Ok::<_, std::io::Error>(rama_http::Response::new(()))
});

// build our custom compression predicate
// its recommended to still include `DefaultPredicate` as part of
// custom predicates
let predicate = DefaultPredicate::new()
    // don't compress responses who's `content-type` starts with `application/json`
    .and(NotForContentType::new("application/json"));

let service = Compression::new(service).compress_when(predicate);

See predicate for more utilities for building compression predicates.

Responses that are already compressed (ie have a content-encoding header) will never be recompressed, regardless what they predicate says.

Trait Implementations

impl<S, P> Clone for Compression<S, P>

where S: Clone, P: Clone,

fn clone(&self) -> Compression<S, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, P> Debug for Compression<S, P>

where S: Debug, P: Debug,

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

Formats the value using the given formatter.

impl<ReqBody, ResBody, S, P, State> Service<State, Request<ReqBody>> for Compression<S, P>

where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static, State: Send + Sync + 'static,

type Response = Response<CompressionBody<ResBody>>

The type of response returned by the service.

type Error = <S as Service<State, Request<ReqBody>>>::Error

The type of error returned by the service.

async fn serve( &self, ctx: Context<State>, req: Request<ReqBody>, ) -> Result<<Compression<S, P> as Service<State, Request<ReqBody>>>::Response, <Compression<S, P> as Service<State, Request<ReqBody>>>::Error>

Serve a response or error for the given request, using the given context.

fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error>

Box this service to allow for dynamic dispatch.