Struct ResponseCompressionCtx 

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

The response compression object. Currently support gzip compression and brotli decompression.

To use it, the caller should create a ResponseCompressionCtx per HTTP session. The caller should call the corresponding filters for the request header, response header and response body. If the algorithms are supported, the output response body will be encoded. The response header will be adjusted accordingly as well. If the algorithm is not supported or no encoding is needed, the response is untouched.

If configured and if the request’s accept-encoding header contains the algorithm supported and the incoming response doesn’t have that encoding, the filter will compress the response. If configured and supported, and if the incoming response’s content-encoding isn’t one of the request’s accept-encoding supported algorithm, the ctx will decompress the response.

Currently supported algorithms and actions

• Brotli decompression: if the response is br compressed, this ctx can decompress it
• Gzip compression: if the response is uncompressed, this ctx can compress it with gzip

Implementations

impl ResponseCompressionCtx

pub fn new( compression_level: u32, decompress_enable: bool, preserve_etag: bool, ) -> Self

Create a new ResponseCompressionCtx with the expected compression level. 0 will disable the compression. The compression level is applied across all algorithms. The decompress_enable flag will tell the ctx to decompress if needed. The preserve_etag flag indicates whether the ctx should avoid modifying the etag, which will otherwise be weakened if the flag is false and (de)compression is applied.

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.