cardinal_plugins/
request_context.rs

1use crate::plugin_executor::CardinalPluginExecutor;
2use crate::runner::PluginRunner;
3use crate::REQ_UTC_TIME;
4use cardinal_base::context::CardinalContext;
5use cardinal_base::destinations::container::DestinationWrapper;
6use cardinal_wasm_plugins::{ExecutionContext, SharedExecutionContext};
7use chrono::Utc;
8use parking_lot::RwLock;
9use std::collections::HashMap;
10use std::sync::Arc;
11use std::time::Instant;
12
13pub struct RequestContext {
14    pub cardinal_context: Arc<CardinalContext>,
15    pub backend: Arc<DestinationWrapper>,
16    pub plugin_runner: Arc<PluginRunner>,
17    pub response_headers: Option<HashMap<String, String>>,
18    pub shared_ctx: SharedExecutionContext,
19}
20
21impl RequestContext {
22    pub fn new(
23        context: Arc<CardinalContext>,
24        backend: Arc<DestinationWrapper>,
25        execution_context: ExecutionContext,
26        plugin_executor: Arc<dyn CardinalPluginExecutor>,
27    ) -> Self {
28        let runner = PluginRunner::new(context.clone(), plugin_executor);
29        Self {
30            cardinal_context: context,
31            backend,
32            plugin_runner: Arc::new(runner),
33            response_headers: None,
34            shared_ctx: Arc::new(RwLock::new(execution_context)),
35        }
36    }
37
38    pub fn persistent_vars(&self) -> Arc<RwLock<HashMap<String, String>>> {
39        self.shared_ctx.read().persistent_vars().clone()
40    }
41
42    pub fn shared_context(&self) -> SharedExecutionContext {
43        self.shared_ctx.clone()
44    }
45}
46
47pub struct RequestContextBase {
48    pub resolved_request: Option<RequestContext>,
49    pub metadata: HashMap<String, String>,
50    pub req_instant: Instant,
51}
52
53impl Default for RequestContextBase {
54    fn default() -> Self {
55        Self::new()
56    }
57}
58
59impl RequestContextBase {
60    pub fn new() -> Self {
61        Self {
62            resolved_request: None,
63            metadata: Self::init_metadata(),
64            req_instant: Instant::now(),
65        }
66    }
67
68    pub fn set(&mut self, key: &str, value: &str) {
69        self.metadata.insert(key.to_string(), value.to_string());
70    }
71
72    pub fn set_resolved_request(&mut self, resolved_request: RequestContext) {
73        self.resolved_request = Some(resolved_request);
74    }
75
76    pub fn req_unsafe(&self) -> &RequestContext {
77        self.resolved_request.as_ref().unwrap()
78    }
79
80    pub fn req_unsafe_mut(&mut self) -> &mut RequestContext {
81        self.resolved_request.as_mut().unwrap()
82    }
83
84    fn init_metadata() -> HashMap<String, String> {
85        HashMap::from([(REQ_UTC_TIME.to_string(), Utc::now().to_rfc3339())])
86    }
87}