praxis-proxy-filter 0.5.4

Filter pipeline engine and built-in filters for Praxis
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 Praxis Contributors

//! Test-only filters for pipeline capability validation.

use async_trait::async_trait;
use praxis_core::config::{Condition, FailureMode};

use super::filter::PipelineFilter;
use crate::{
    FilterAction, FilterError,
    any_filter::AnyFilter,
    filter::{HttpFilter, HttpFilterContext},
};

pub(in crate::pipeline) fn selector_filter(name: &'static str, clusters: &[&str]) -> PipelineFilter {
    capability_filter(CapabilityFilter {
        load_balancer_clusters: vec![],
        name,
        selected_clusters: clusters.iter().map(|cluster| (*cluster).to_owned()).collect(),
        selects_cluster: true,
    })
}

pub(in crate::pipeline) fn lb_filter(clusters: &[&str]) -> PipelineFilter {
    capability_filter(CapabilityFilter {
        load_balancer_clusters: clusters.iter().map(|cluster| (*cluster).to_owned()).collect(),
        name: "load_balancer",
        selected_clusters: vec![],
        selects_cluster: false,
    })
}

pub(in crate::pipeline) fn noop_filter(name: &'static str) -> PipelineFilter {
    capability_filter(CapabilityFilter {
        load_balancer_clusters: vec![],
        name,
        selected_clusters: vec![],
        selects_cluster: false,
    })
}

pub(in crate::pipeline) fn noop_filter_with_conditions(
    name: &'static str,
    conditions: Vec<Condition>,
) -> PipelineFilter {
    let mut filter = noop_filter(name);
    filter.conditions = conditions;
    filter
}

fn capability_filter(filter: CapabilityFilter) -> PipelineFilter {
    PipelineFilter {
        filter_id: 0,
        branches: vec![],
        conditions: vec![],
        failure_mode: FailureMode::default(),
        filter: AnyFilter::Http(Box::new(filter)),
        name: None,
        response_conditions: vec![],
    }
}

struct CapabilityFilter {
    load_balancer_clusters: Vec<String>,
    name: &'static str,
    selected_clusters: Vec<String>,
    selects_cluster: bool,
}

#[async_trait]
impl HttpFilter for CapabilityFilter {
    fn name(&self) -> &'static str {
        self.name
    }

    fn selects_cluster(&self) -> bool {
        self.selects_cluster
    }

    fn selected_clusters(&self) -> Vec<String> {
        self.selected_clusters.clone()
    }

    fn load_balancer_clusters(&self) -> Vec<String> {
        self.load_balancer_clusters.clone()
    }

    async fn on_request(&self, _ctx: &mut HttpFilterContext<'_>) -> Result<FilterAction, FilterError> {
        Ok(FilterAction::Continue)
    }
}

pub(in crate::pipeline) fn streaming_capable_filter() -> PipelineFilter {
    PipelineFilter {
        filter_id: 0,
        branches: vec![],
        conditions: vec![],
        failure_mode: FailureMode::default(),
        filter: AnyFilter::Http(Box::new(StreamingCapableFilter)),
        name: None,
        response_conditions: vec![],
    }
}

struct StreamingCapableFilter;

#[async_trait]
impl HttpFilter for StreamingCapableFilter {
    fn name(&self) -> &'static str {
        "streaming_capable"
    }

    fn may_select_streaming_subrequest_response(&self) -> bool {
        true
    }

    async fn on_request(&self, _ctx: &mut HttpFilterContext<'_>) -> Result<FilterAction, FilterError> {
        Ok(FilterAction::Continue)
    }
}