Enum BodyMode 

#[non_exhaustive]
pub enum BodyMode {
    Stream,
    StreamBuffer {
        max_bytes: Option<usize>,
    },
    SizeLimit {
        max_bytes: usize,
    },
}

Controls how body chunks are delivered to a filter.

use praxis_filter::BodyMode;

let mode = BodyMode::default();
assert!(matches!(mode, BodyMode::Stream));

let buffered = BodyMode::StreamBuffer {
    max_bytes: Some(1024),
};
assert!(matches!(
    buffered,
    BodyMode::StreamBuffer {
        max_bytes: Some(1024)
    }
));

let stream_buf = BodyMode::StreamBuffer { max_bytes: None };
assert!(matches!(
    stream_buf,
    BodyMode::StreamBuffer { max_bytes: None }
));

let limited = BodyMode::StreamBuffer {
    max_bytes: Some(1024),
};
assert!(matches!(
    limited,
    BodyMode::StreamBuffer {
        max_bytes: Some(1024)
    }
));

let size_limited = BodyMode::SizeLimit { max_bytes: 2048 };
assert!(matches!(
    size_limited,
    BodyMode::SizeLimit { max_bytes: 2048 }
));

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Stream

Deliver chunks as they arrive. Low latency, low memory.

use praxis_filter::BodyMode;

let mode = BodyMode::Stream;
assert_eq!(mode, BodyMode::default());

StreamBuffer

Deliver chunks incrementally (like Stream) but accumulate them and defer upstream forwarding until a filter returns FilterAction::Release or end-of-stream is reached.

When max_bytes is Some, requests exceeding the limit receive 413. When None and no global body size ceiling is configured, body buffering is unbounded; a warning is emitted at pipeline build time in that case.

use praxis_filter::BodyMode;

let unlimited = BodyMode::StreamBuffer { max_bytes: None };
assert!(matches!(
    unlimited,
    BodyMode::StreamBuffer { max_bytes: None }
));

let limited = BodyMode::StreamBuffer {
    max_bytes: Some(4096),
};
assert!(matches!(
    limited,
    BodyMode::StreamBuffer {
        max_bytes: Some(4096)
    }
));

Fields

max_bytes: Option<usize>

Optional maximum body size in bytes. None means unbounded buffering (a warning is emitted at build time).

SizeLimit

Stream chunks through without buffering, but enforce a byte ceiling. Returns 413 if the running byte count exceeds max_bytes.

Used by apply_body_limits when no filter needs body access but a global size limit is configured.

use praxis_filter::BodyMode;

let mode = BodyMode::SizeLimit { max_bytes: 4096 };
assert!(matches!(mode, BodyMode::SizeLimit { max_bytes: 4096 }));

Fields

max_bytes: usize

Maximum body size in bytes.

Trait Implementations

impl Clone for BodyMode

fn clone(&self) -> BodyMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BodyMode

impl Debug for BodyMode

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

Formats the value using the given formatter.

impl Default for BodyMode

fn default() -> BodyMode

Returns the “default value” for a type.

impl Eq for BodyMode

impl PartialEq for BodyMode

fn eq(&self, other: &BodyMode) -> 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 StructuralPartialEq for BodyMode