Struct ResponseCompression 

pub struct ResponseCompression(/* private fields */);

HTTP response compression module

Methods from Deref<Target = ResponseCompressionCtx>

pub fn is_enabled(&self) -> bool

Whether the encoder is enabled. The enablement will change according to the request and response filter by this ctx.

pub fn get_info(&self) -> Option<(&'static str, usize, usize, Duration)>

Return the stat of this ctx: algorithm name, in bytes, out bytes, time took for the compression

pub fn adjust_level(&mut self, new_level: u32)

Adjust the compression level for all compression algorithms.

Panic

This function will panic if it has already started encoding the response body.

pub fn adjust_algorithm_level(&mut self, algorithm: Algorithm, new_level: u32)

Adjust the compression level for a specific algorithm.

Panic

This function will panic if it has already started encoding the response body.

pub fn adjust_decompression(&mut self, enabled: bool)

Adjust the decompression flag for all compression algorithms.

Panic

This function will panic if it has already started encoding the response body.

pub fn adjust_algorithm_decompression( &mut self, algorithm: Algorithm, enabled: bool, )

Adjust the decompression flag for a specific algorithm.

Panic

This function will panic if it has already started encoding the response body.

pub fn adjust_preserve_etag(&mut self, enabled: bool)

Adjust preserve etag setting.

Panic

This function will panic if it has already started encoding the response body.

pub fn adjust_algorithm_preserve_etag( &mut self, algorithm: Algorithm, enabled: bool, )

Adjust preserve etag setting for a specific algorithm.

Panic

This function will panic if it has already started encoding the response body.

pub fn request_filter(&mut self, req: &RequestHeader)

Feed the request header into this ctx.

pub fn response_header_filter(&mut self, resp: &mut ResponseHeader, end: bool)

Feed the response header into this ctx

pub fn response_body_filter( &mut self, data: Option<&Bytes>, end: bool, ) -> Option<Bytes>

Stream the response body chunks into this ctx. The return value will be the compressed data.

Return None if compression is not enabled.

pub fn response_filter(&mut self, t: &mut HttpTask)

Feed the response into this ctx. This filter will mutate the response accordingly if encoding is needed.

Trait Implementations

impl Deref for ResponseCompression

type Target = ResponseCompressionCtx

The resulting type after dereferencing.

fn deref(&self) -> &<ResponseCompression as Deref>::Target

Dereferences the value.

impl DerefMut for ResponseCompression

fn deref_mut(&mut self) -> &mut <ResponseCompression as Deref>::Target

Mutably dereferences the value.

impl HttpModule for ResponseCompression

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

fn request_header_filter<'life0, 'life1, 'async_trait>( &'life0 mut self, req: &'life1 mut RequestHeader, ) -> Pin<Box<dyn Future<Output = Result<(), Box<Error>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, ResponseCompression: 'async_trait,

fn response_header_filter<'life0, 'life1, 'async_trait>( &'life0 mut self, resp: &'life1 mut ResponseHeader, end_of_stream: bool, ) -> Pin<Box<dyn Future<Output = Result<(), Box<Error>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, ResponseCompression: 'async_trait,

fn response_body_filter( &mut self, body: &mut Option<Bytes>, end_of_stream: bool, ) -> Result<(), Box<Error>>

fn response_done_filter(&mut self) -> Result<Option<Bytes>, Box<Error>>

fn request_body_filter<'life0, 'life1, 'async_trait>( &'life0 mut self, _body: &'life1 mut Option<Bytes>, _end_of_stream: bool, ) -> Pin<Box<dyn Future<Output = Result<(), Box<Error>>> + Send + 'async_trait>>

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

fn response_trailer_filter( &mut self, _trailers: &mut Option<Box<HeaderMap>>, ) -> Result<Option<Bytes>, Box<Error>>