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
use proxy_wasm::types::{Action, PeerType};
use super::{Filter, Ops};
use crate::host::services::clients::http as http_client;
pub struct FilterContext<'a, F>
where
F: Filter,
{
filter: F,
logger_ops: &'a dyn Ops,
http_client_ops: &'a dyn http_client::ResponseOps,
}
impl<'a, F> proxy_wasm::traits::StreamContext for FilterContext<'a, F>
where
F: Filter,
{
fn on_new_connection(&mut self) -> Action {
self.filter.on_new_connection().unwrap()
}
fn on_downstream_data(&mut self, data_size: usize, end_of_stream: bool) -> Action {
self.filter
.on_downstream_data(
data_size,
end_of_stream,
self.logger_ops.as_downstream_data_ops(),
)
.unwrap()
}
fn on_downstream_close(&mut self, peer_type: PeerType) {
self.filter.on_downstream_close(peer_type).unwrap()
}
fn on_upstream_data(&mut self, data_size: usize, end_of_stream: bool) -> Action {
self.filter
.on_upstream_data(
data_size,
end_of_stream,
self.logger_ops.as_upstream_data_ops(),
)
.unwrap()
}
fn on_upstream_close(&mut self, peer_type: PeerType) {
self.filter.on_upstream_close(peer_type).unwrap()
}
fn on_log(&mut self) {
self.filter.on_connection_complete().unwrap()
}
}
impl<'a, F> proxy_wasm::traits::Context for FilterContext<'a, F>
where
F: Filter,
{
fn on_http_call_response(
&mut self,
token_id: u32,
num_headers: usize,
body_size: usize,
num_trailers: usize,
) {
self.filter
.on_http_call_response(
http_client::RequestHandle::from(token_id),
num_headers,
body_size,
num_trailers,
self.logger_ops,
self.http_client_ops,
)
.unwrap()
}
}
impl<'a, F> FilterContext<'a, F>
where
F: Filter,
{
pub fn new(
filter: F,
logger_ops: &'a dyn Ops,
http_client_ops: &'a dyn http_client::ResponseOps,
) -> FilterContext<'a, F> {
FilterContext {
filter,
logger_ops,
http_client_ops,
}
}
pub fn with_default_ops(filter: F) -> FilterContext<'a, F> {
FilterContext::new(filter, &super::ops::Host, &http_client::ops::Host)
}
}