witmproxy 0.0.2-alpha

A WASM-in-the-middle proxy
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

use anyhow::{Result, bail};
use cel_cxx::Activation;
use wasmtime::Store;

use crate::wasm::{
    Host,
    bindgen::{
        Event as WasmEvent,
        witmproxy::plugin::capabilities::{CapabilityKind, EventKind},
    },
};

pub mod connect;
pub mod content;
pub mod request;
pub mod response;
pub mod timer;

/// Trait representing an event that can be handled by the plugin system
pub trait Event: Send {
    /// Returns the [CapabilityKind] required to handle events of this type
    fn capability(&self) -> CapabilityKind;

    /// Returns the [EventKind] associated with this event type
    fn kind(&self) -> EventKind {
        match self.capability() {
            CapabilityKind::HandleEvent(kind) => kind,
            _ => panic!("Event capability must be of HandleEvent kind"),
        }
    }

    /// Converts into Event by consuming the event and storing it in the provided Store
    fn into_event_data(self: Box<Self>, store: &mut Store<Host>) -> Result<WasmEvent>;

    /// Register event-specific variables and functions with the CEL environment
    fn register_cel_env<'a>(env: cel_cxx::EnvBuilder<'a>) -> Result<cel_cxx::EnvBuilder<'a>>
    where
        Self: Sized;

    /// Bind all event-specific variables for the CEL activation
    fn bind_cel_activation<'a>(&'a self, a: Activation<'a>) -> Option<Activation<'a>>;
}

macro_rules! ensure_matches {
    ($expr:expr, $pat:pat $(if $guard:expr)? $(,)?) => {
        match $expr {
            $pat $(if $guard)? => Ok(()),
            _ => Err(anyhow::anyhow!(
                "pattern did not match, expected to find one of: {}",
                stringify!($pat)
            )),
        }
    };
}

impl EventKind {
    /// Validates that the received Event is a valid output variant for this EventKind
    pub fn validate_output(&self, event_data: &WasmEvent) -> Result<()> {
        match self {
            EventKind::Request => {
                ensure_matches!(event_data, WasmEvent::Request(_) | WasmEvent::Response(_))
            }
            EventKind::Response => ensure_matches!(event_data, WasmEvent::Response(_)),
            EventKind::Connect => {
                bail!("Connect events do not return Event (no guest handling)")
            }
            EventKind::InboundContent => ensure_matches!(event_data, WasmEvent::InboundContent(_)),
            EventKind::Timer => ensure_matches!(event_data, WasmEvent::Timer(_)),
        }
    }
}

impl std::fmt::Display for EventKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            EventKind::Request => write!(f, "request"),
            EventKind::Response => write!(f, "response"),
            EventKind::Connect => write!(f, "connect"),
            EventKind::InboundContent => write!(f, "inbound_content"),
            EventKind::Timer => write!(f, "timer"),
        }
    }
}