Struct StackConfig 

#[non_exhaustive]
pub struct StackConfig {
    pub timeout: Option<Duration>,
    pub max_request_body_wire_bytes: Option<usize>,
    pub max_request_body_decoded_bytes: Option<usize>,
    pub load_shed: bool,
    pub compression: Option<CompressionOptions>,
    pub decompression: bool,
}

Tower stack configuration shared by [build_stack] and [build_client_stack].

Each field is consumed by a dedicated apply_* factory in this module (see [build_stack]’s body). Factories are no-ops when their field is None/false, so toggling a field off produces a service whose runtime shape is identical to the layer never having been built.

Composition uses the axum-style boxed-per-layer pattern: every apply_* takes a [ServeService] and returns a [ServeService], performing its own boxed_clone(). This re-erases the inner Service::Future after each layer, so layer addition is decoupled from the type-soup of Either<L::Service, S> and impl Layer<…> return-position bound erasure (see Slice B (#184) carry-forward in Slice C (#185)).

Slice D (#186): made public so the pure-Rust crate::http::client::fetch_request can take &StackConfig directly. #[non_exhaustive] so adapters constructing literal StackConfig values (StackConfig { timeout, decompression, ..default() }) opt in explicitly and future fields don’t break them.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

timeout: Option<Duration>

Per-request timeout. None ⇒ no TimeoutLayer is applied.

max_request_body_wire_bytes: Option<usize>

Maximum wire request body size before the server rejects with 413.

This limit is applied before decompression, i.e. it counts compressed bytes as they arrive from the QUIC stream. It is an effective guard against network-level DoS (high-bandwidth senders), but it does not protect against a compression bomb (a small compressed body that decompresses to many GB). Use Self::max_request_body_decoded_bytes for that.

max_request_body_decoded_bytes: Option<usize>

Maximum decoded request body size before the server rejects with 413.

This limit is applied after decompression. It is the primary guard against compression bombs: a zstd payload that is tiny on the wire but expands to GB in memory is rejected once the decoded byte count crosses this threshold. The default at the super::serve entry point is 16 MiB (matching the documented behaviour that the old single-limit field max_request_body_bytes had always promised but never delivered).

load_shed: bool

true ⇒ wrap with LoadShedLayer so saturated capacity returns 503 immediately rather than blocking the caller.

compression: Option<CompressionOptions>

Operator’s compression configuration. None disables response compression on the server side; ignored by [build_client_stack] (clients do not yet compress request bodies).

decompression: bool

true ⇒ apply RequestDecompressionLayer (server) / DecompressionLayer (client). Defaults to true — every server today accepts compressed requests, every client accepts compressed responses.

Implementations

impl StackConfig

pub fn with_timeout(self, timeout: Option<Duration>) -> Self

Set Self::timeout using the builder pattern.

Convenience constructor for external callers — #[non_exhaustive] blocks struct-literal construction outside this crate, so use StackConfig::default().with_timeout(...).

pub fn with_decompression(self, decompression: bool) -> Self

Set Self::decompression using the builder pattern.

Trait Implementations

impl Clone for StackConfig

fn clone(&self) -> StackConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StackConfig

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

Formats the value using the given formatter.

impl Default for StackConfig

fn default() -> Self

Returns the “default value” for a type.