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 is_header_phase(&self) -> bool

Whether this ctx is in the response header phase.

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 set_dictionary( &mut self, dictionary_bytes: Bytes, dictionary_hash: [u8; 32], )

Set the dictionary for RFC 9842 dictionary compression.

Panic

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

pub fn has_dictionary(&self) -> bool

Check if a dictionary has been set.

pub fn clear_dictionary(&mut self)

Clear any previously set dictionary.

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 will_decompress(&self, resp: &ResponseHeader) -> bool

Whether Self::response_header_filter would decompress the body of this response.

This ctx replaces the response body in place, so a filter that runs before it cannot tell from the response header alone what the body will look like by the time it reaches downstream. This predicate answers that question ahead of time. For example, a caller framing a byte range against the response body needs to know whether the body it is measuring is about to be swapped for its decompressed form, which invalidates both the offsets and the length it computed.

This assumes the response has a body: unlike Self::response_header_filter it takes no end flag, and a response without a body is never decompressed. Informational (1xx) responses are not final, so they are reported as not decompressed; ask again with the final response header.

Returns false once this ctx has left the header phase, because by then the decision has already been made. This is a read-only query, so unlike the adjust_* methods it never panics and is safe to call in any phase.

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) -> &Self::Target

Dereferences the value.

impl DerefMut for ResponseCompression

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl HttpModule for ResponseCompression

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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<()>> + Send + 'async_trait>>

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

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

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

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<()>> + Send + 'async_trait>>

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

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