Struct Compression 

pub struct Compression {
    pub algorithms: Vec<CompressionAlgorithm>,
    pub level: Option<u8>,
    pub min_size: u64,
    pub content_types: Vec<String>,
    pub excluded_content_types: Vec<String>,
}

Route-scoped response compression policy (DW-027, feature analysis 4.13).

Semantics (frozen; negotiation and encoding live in dataplane::compression):

• algorithms is the PREFERENCE order: the first entry the request’s Accept-Encoding accepts wins. q=0 entries in Accept-Encoding are treated as refusal.
• level is clamped per algorithm at encode time (gzip 0-9, brotli 0-11, zstd 0-22; validation bounds the field to 0-22). Absent: the algorithm’s library default.
• min_size skips compression of responses whose size is known and below it — a declared Content-Length or the exact size of the gateway’s own respond/redirect bodies. Responses of UNKNOWN length (streaming) are always candidates.
• content_types (when non-empty) restricts compression to responses whose Content-Type starts with one of the entries; entries are lowercase prefix matches (e.g. text/). excluded_content_types is checked after the include list and wins (the way to express “compress everything text/ except text/event-stream”).
• Responses carrying an existing Content-Encoding, 1xx/204/304 statuses, zero-length bodies, and 101 upgrade responses are never compressed. Vary: Accept-Encoding is merged into every response on a compression-configured route that is not already encoded — compressed or not — so caches key correctly.
• The compressed body streams chunk-by-chunk with a flush per chunk (streaming/SSE-friendly, at a small compression-ratio cost); the gateway never buffers the whole body to compress it. The frame codec’s internal buffer is bounded by the chunk size.

Fields

algorithms: Vec<CompressionAlgorithm>

Enabled algorithms in preference order (default gzip, brotli, zstd). Must be non-empty and duplicate-free (validation).

level: Option<u8>

Compression level; clamped per algorithm (gzip <= 9, brotli <= 11, zstd <= 22). Absent: library default per algorithm.

min_size: u64

Minimum response size (bytes) to compress, applied whenever the size is known: a declared Content-Length or the body’s exact size (the gateway’s own respond/redirect bodies, which carry no Content-Length). Below it the response passes through (still carrying Vary: Accept-Encoding). Default 1024. Responses of unknown length (streaming) are always candidates.

content_types: Vec<String>

Content-Type prefix include list (lowercase, e.g. text/, application/json); empty = every content type is a candidate.

excluded_content_types: Vec<String>

Content-Type prefix exclude list, checked after content_types; a match passes the response through uncompressed.

Trait Implementations

impl Clone for Compression

fn clone(&self) -> Compression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Compression

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Compression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Compression

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Compression

fn eq(&self, other: &Compression) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Compression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Compression