Struct 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 get_mut(&mut self) -> &mut S

Gets a mutable reference to the underlying service.

pub fn into_inner(self) -> S

Consumes self, returning the underlying service.

pub fn layer() -> CompressionLayer

Returns a new Layer that wraps services with a Compression middleware.

pub fn gzip(self, enable: bool) -> 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 br(self, enable: bool) -> 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 quality(self, quality: CompressionLevel) -> Compression<S, P>

Sets the compression quality.

pub fn no_gzip(self) -> Compression<S, P>

Disables the gzip encoding.

This method is available even if the gzip crate feature is disabled.

pub fn no_deflate(self) -> Compression<S, P>

Disables the Deflate encoding.

This method is available even if the deflate crate feature is disabled.

pub fn no_br(self) -> Compression<S, P>

Disables the Brotli encoding.

This method is available even if the br crate feature is disabled.

pub fn no_zstd(self) -> Compression<S, P>

Disables the Zstd encoding.

This method is available even if the zstd crate feature is disabled.

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 tower_http::compression::{
    Compression,
    predicate::{Predicate, NotForContentType, DefaultPredicate},
};
use tower::util::service_fn;

// Placeholder service_fn
let service = service_fn(|_: ()| async {
    Ok::<_, std::io::Error>(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 duplicate of the value.

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

Performs copy-assignment from source.

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

where S: Service<Request<ReqBody>, Response = Response<ResBody>>, ResBody: Body, P: Predicate,

type Response = Response<CompressionBody<ResBody>>

Responses given by the service.

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

Errors produced by the service.

type Future = ResponseFuture<<S as Service<Request<ReqBody>>>::Future, P>

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <Compression<S, P> as Service<Request<ReqBody>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<ReqBody>, ) -> <Compression<S, P> as Service<Request<ReqBody>>>::Future

Process the request and return the response asynchronously.

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

where S: Copy, P: Copy,