Struct tower_http::compression::Compression

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

Available on crate features compression-br or compression-deflate or compression-gzip only.

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, DefaultPredicate>

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

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) -> Self

Available on crate feature compression-gzip only.

Sets whether to enable the gzip encoding.

pub fn deflate(self, enable: bool) -> Self

Available on crate feature compression-deflate only.

Sets whether to enable the Deflate encoding.

pub fn br(self, enable: bool) -> Self

Available on crate feature compression-br only.

Sets whether to enable the Brotli encoding.

pub fn no_gzip(self) -> Self

Disables the gzip encoding.

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

pub fn no_deflate(self) -> Self

Disables the Deflate encoding.

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

pub fn no_br(self) -> Self

Disables the Brotli encoding.

This method is available even if the br 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: Clone, P: Clone> Clone for Compression<S, P>

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<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<(), Self::Error>>

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

fn call(&mut self, req: Request<ReqBody>) -> Self::Future

Process the request and return the response asynchronously.

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