cardinal_plugins/
request_context.rs

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