pdk-classy 1.9.1-alpha.2

PDK Classy
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
122
123
124
125

// Copyright (c) 2026, Salesforce, Inc.,
// All rights reserved.
// For full license text, see the LICENSE.txt file

//! A wrapper to bundle the logic that will be part of the policy.

use std::marker::PhantomData;

use crate::proxy_wasm::traits::RootContext;

use crate::{
    entrypoint::Entrypoint,
    event::{Event, RequestHeaders, ResponseHeaders},
    middleware::{EventHandler, EventHandlerPush, EventHandlerStack},
};

#[derive(Default)]
/// A collection of event handlers and an entrypoint that will transform into the root context.
pub struct Plugin<E = (), T = ()> {
    event_handlers: EventHandlerStack,
    entrypoint: E,
    _types: PhantomData<T>,
}

impl EventHandlerPush<RequestHeaders> for Plugin {
    fn push<H>(&mut self, handler: H)
    where
        H: EventHandler<RequestHeaders> + 'static,
    {
        self.event_handlers.push(handler)
    }
}

impl EventHandlerPush<ResponseHeaders> for Plugin {
    fn push<H>(&mut self, handler: H)
    where
        H: EventHandler<ResponseHeaders> + 'static,
    {
        self.event_handlers.push(handler)
    }
}

impl Plugin {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn event_handler<H, S>(mut self, handler: H) -> Self
    where
        S: Event,
        H: EventHandler<S> + 'static,
        Self: EventHandlerPush<S>,
    {
        self.push(handler);
        self
    }

    pub fn entrypoint<C, T, E>(self, entrypoint: E) -> Plugin<E, (C, T)>
    where
        E: Entrypoint<C, T>,
    {
        Plugin {
            event_handlers: self.event_handlers,
            entrypoint,
            _types: PhantomData,
        }
    }
}

impl<E, C, T> Plugin<E, (C, T)>
where
    E: Entrypoint<C, T>,
{
    pub fn create_root_context(self, context_id: u32) -> Box<dyn RootContext> {
        self.entrypoint
            .create_root_context(self.event_handlers, context_id)
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        bootstrap::Launcher,
        client::HttpClient,
        event::{EventData, Exchange, RequestHeaders, ResponseHeaders},
        Configuration, Plugin,
    };

    #[test]
    fn test_configure() {
        Plugin::new()
            .entrypoint(|_: Launcher| async {})
            .create_root_context(1);
    }

    #[test]
    fn test_filter() {
        Plugin::new()
            .entrypoint(|_: Exchange<RequestHeaders>| async {})
            .create_root_context(1);
    }

    #[test]
    fn test_configure_with_dependencies() {
        Plugin::new()
            .entrypoint(|_: Launcher, _: Configuration| async {})
            .create_root_context(1);
    }

    #[test]
    fn test_filter_with_dependencies() {
        Plugin::new()
            .entrypoint(|_: Launcher, _: HttpClient| async {})
            .create_root_context(1);
    }

    #[test]
    fn test_configure_with_event_handlers() {
        Plugin::new()
            .event_handler(|_: &EventData<RequestHeaders>| Ok(()))
            .event_handler(|_: &EventData<ResponseHeaders>| Ok(()))
            .entrypoint(|_: Launcher| async {})
            .create_root_context(1);
    }
}