Struct FilterPipeline 

pub struct FilterPipeline { /* private fields */ }

An ordered list of filters executed on every request.

use praxis_filter::{FilterPipeline, FilterRegistry};

let registry = FilterRegistry::with_builtins();
let pipeline = FilterPipeline::build(&mut [], &registry).unwrap();
assert!(pipeline.is_empty());

Implementations

impl FilterPipeline

pub fn build( entries: &mut [FilterEntry], registry: &FilterRegistry, ) -> Result<Self, FilterError>

Build a pipeline by instantiating each filter entry via the registry.

Conditions are moved out of entries via mem::take to avoid cloning. After this call, each entry’s condition vecs are empty.

Errors

Returns FilterError if any filter fails to instantiate.

pub fn build_with_chains( entries: &mut [FilterEntry], registry: &FilterRegistry, chains: &HashMap<&str, &[FilterEntry]>, ) -> Result<Self, FilterError>

Build a pipeline with branch chain resolution.

Like build, but also resolves branch_chains on each filter entry into runtime ResolvedBranch types using the provided chain lookup table.

Errors

Returns FilterError if any filter fails to instantiate or any branch chain reference is unresolvable.

pub fn ordering_errors( &self, entries: &[FilterEntry], allow_open_security: bool, ) -> Vec<String>

Validate the pipeline for structural misconfigurations that would cause runtime failures (502s, unreachable filters, cluster mismatches).

use praxis_filter::{FailureMode, FilterEntry, FilterPipeline, FilterRegistry};

let registry = FilterRegistry::with_builtins();
let mut entries = vec![FilterEntry {
    branch_chains: None,
    filter_type: "load_balancer".into(),
    config: serde_yaml::from_str("clusters: []").unwrap(),
    conditions: vec![],
    name: None,
    response_conditions: vec![],
    failure_mode: FailureMode::default(),
}];
let pipeline = FilterPipeline::build(&mut entries, &registry).unwrap();
let errors = pipeline.ordering_errors(&entries, false);
assert!(
    errors
        .iter()
        .any(|e| e.contains("without a preceding router"))
);

pub fn ordering_warnings(&self) -> Vec<String>

Check for non-fatal ordering advisories.

Currently detects: all routers conditional with no fallback.

use praxis_filter::{FailureMode, FilterEntry, FilterPipeline, FilterRegistry};

let registry = FilterRegistry::with_builtins();
let mut entries = vec![FilterEntry {
    branch_chains: None,
    filter_type: "router".into(),
    config: serde_yaml::from_str("routes: []").unwrap(),
    conditions: vec![praxis_core::config::Condition::When(
        praxis_core::config::ConditionMatch {
            path: None,
            path_prefix: Some("/api".to_owned()),
            methods: None,
            headers: None,
        },
    )],
    name: None,
    response_conditions: vec![],
    failure_mode: FailureMode::default(),
}];
let pipeline = FilterPipeline::build(&mut entries, &registry).unwrap();
let warnings = pipeline.ordering_warnings();
assert!(
    warnings
        .iter()
        .any(|w| w.contains("all router filters are conditional"))
);

impl FilterPipeline

pub async fn execute_http_request( &self, ctx: &mut HttpFilterContext<'_>, ) -> Result<FilterAction, FilterError>

Run all HTTP request filters in order.

Tracks which filter indices actually executed so the response phase can skip filters that were bypassed (e.g. by SkipTo).

Errors

Returns FilterError if any filter fails.

pub async fn execute_http_response( &self, ctx: &mut HttpFilterContext<'_>, ) -> Result<FilterAction, FilterError>

Run all HTTP response filters in reverse order.

Skips filters that did not execute during the request phase (tracked by executed_filter_indices).

Errors

Returns FilterError if any filter fails.

pub async fn execute_http_request_body( &self, ctx: &mut HttpFilterContext<'_>, body: &mut Option<Bytes>, end_of_stream: bool, ) -> Result<FilterAction, FilterError>

Run all HTTP request body filters in order.

Filters that previously returned BodyDone are skipped.

Errors

Returns FilterError if any body filter fails.

pub fn execute_http_response_body( &self, ctx: &mut HttpFilterContext<'_>, body: &mut Option<Bytes>, end_of_stream: bool, ) -> Result<FilterAction, FilterError>

Run all HTTP response body filters in reverse order.

Filters that previously returned BodyDone are skipped.

Errors

Returns FilterError if any body filter fails.

impl FilterPipeline

pub async fn execute_tcp_connect( &self, ctx: &mut TcpFilterContext<'_>, ) -> Result<FilterAction, FilterError>

Run all TCP connect filters in order.

TCP filters do not participate in branch chain evaluation currently. TCP pipelines execute filters sequentially without conditional branching or rejoin logic.

Errors

Returns FilterError if any filter rejects or fails.

pub async fn execute_tcp_disconnect( &self, ctx: &mut TcpFilterContext<'_>, ) -> Result<(), FilterError>

Run all TCP disconnect filters in reverse order.

Errors

Returns FilterError if any filter fails.

impl FilterPipeline

pub fn apply_body_limits( &mut self, max_request: Option<usize>, max_response: Option<usize>, allow_unbounded: bool, ) -> Result<(), FilterError>

Apply global body size ceilings.

When no filter requires body access (mode is Stream), uses SizeLimit to enforce the ceiling without buffering. When a filter already requested StreamBuffer, the ceiling tightens the existing limit.

Errors

Returns FilterError if a StreamBuffer has no byte limit and allow_unbounded is false.

pub fn body_capabilities(&self) -> &BodyCapabilities

Pre-computed body processing capabilities for this pipeline.

pub fn needs_body_filters(&self) -> bool

Whether any filter in the pipeline needs body access.

pub fn len(&self) -> usize

Number of filters in the pipeline.

pub fn is_empty(&self) -> bool

Whether the pipeline has no filters.

pub fn compression_config(&self) -> Option<&CompressionConfig>

Compression configuration, if a compression filter is present.

pub fn set_health_registry(&mut self, registry: HealthRegistry)

Set the shared HealthRegistry for this pipeline.

pub fn health_registry(&self) -> Option<&HealthRegistry>

The shared health registry, if set.

pub fn id_generator(&self) -> &IdGenerator

The shared request ID generator.

pub fn set_id_generator(&mut self, generator: Arc<IdGenerator>)

Override the IdGenerator for this pipeline.

pub fn kv_stores(&self) -> Option<&KvStoreRegistry>

The shared KV store registry, if set.

pub fn set_kv_stores(&mut self, stores: KvStoreRegistry)

Set the shared KvStoreRegistry for this pipeline.

pub fn add_pipeline_extension(&mut self, ext: Box<dyn PipelineExtension>)

Register an external pipeline extension.

Extensions are called once per request via prepare_extensions to inject pipeline-scoped resources into the per-request RequestExtensions container.

pub fn prepare_extensions(&self, extensions: &mut RequestExtensions)

Inject pipeline-level resources into per-request extensions.

Called by the protocol adapter when building each request’s filter context. Delegates to each registered PipelineExtension.

pub fn time_source(&self) -> &dyn TimeSource

The wall-clock time source.

pub fn set_time_source(&mut self, source: Arc<dyn TimeSource>)

Override the TimeSource for this pipeline.

pub fn apply_insecure_options(&self, options: &InsecureOptions)

Apply InsecureOptions to all filters in the pipeline.

Delegates to each filter’s apply_insecure_options method. Filters that support insecure overrides (e.g. CSRF log-only mode) handle the relevant flags; others ignore the call.