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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
use serde::{Serialize, de::DeserializeOwned};
use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::sync::Arc;
use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance};
use tokio::{net::TcpStream, sync::Mutex};
pub trait Action<Args, Return>
where
Args: Serialize + DeserializeOwned + Send,
Return: Serialize + DeserializeOwned + Send,
{
fn action_name() -> &'static str;
fn is_remote_action() -> bool;
fn process(
context: ActionContext,
args: Args,
) -> impl std::future::Future<Output = Result<Return, TcpTargetError>> + Send;
}
#[derive(Default)]
pub struct ActionContext {
/// Whether the action is executed locally or remotely
local: bool,
/// The name of the action being executed
action_name: String,
/// The JSON-serialized arguments for the action
action_args_json: String,
/// The connection instance in the current context,
instance: Option<Arc<Mutex<ConnectionInstance>>>,
/// Generic data storage for arbitrary types
data: HashMap<TypeId, Arc<dyn Any + Send + Sync>>,
}
impl ActionContext {
/// Generate local context
pub fn local() -> Self {
ActionContext {
local: true,
..Default::default()
}
}
/// Generate remote context
pub fn remote() -> Self {
ActionContext {
local: false,
..Default::default()
}
}
/// Build connection instance from TcpStream
pub fn build_instance(mut self, stream: TcpStream) -> Self {
self.instance = Some(Arc::new(Mutex::new(ConnectionInstance::from(stream))));
self
}
/// Insert connection instance into context
pub fn insert_instance(mut self, instance: ConnectionInstance) -> Self {
self.instance = Some(Arc::new(Mutex::new(instance)));
self
}
/// Pop connection instance from context
pub fn pop_instance(&mut self) -> Option<Arc<Mutex<ConnectionInstance>>> {
self.instance.take()
}
}
impl ActionContext {
/// Whether the action is executed locally
pub fn is_local(&self) -> bool {
self.local
}
/// Whether the action is executed remotely
pub fn is_remote(&self) -> bool {
!self.local
}
/// Get the connection instance in the current context
pub fn instance(&self) -> &Option<Arc<Mutex<ConnectionInstance>>> {
&self.instance
}
/// Get a mutable reference to the connection instance in the current context
pub fn instance_mut(&mut self) -> &mut Option<Arc<Mutex<ConnectionInstance>>> {
&mut self.instance
}
/// Get the action name from the context
pub fn action_name(&self) -> &str {
&self.action_name
}
/// Get the action arguments from the context
pub fn action_args_json(&self) -> &String {
&self.action_args_json
}
/// Set the action name in the context
pub fn set_action_name(mut self, action_name: String) -> Self {
self.action_name = action_name;
self
}
/// Set the action arguments in the context
pub fn set_action_args(mut self, action_args: String) -> Self {
self.action_args_json = action_args;
self
}
/// Insert arbitrary data in the context
pub fn insert<T: Any + Send + Sync>(mut self, value: T) -> Self {
self.data.insert(TypeId::of::<T>(), Arc::new(value));
self
}
/// Insert arbitrary data as Arc in the context
pub fn insert_arc<T: Any + Send + Sync>(mut self, value: Arc<T>) -> Self {
self.data.insert(TypeId::of::<T>(), value);
self
}
/// Get arbitrary data from the context
pub fn get<T: Any + Send + Sync>(&self) -> Option<&T> {
self.data
.get(&TypeId::of::<T>())
.and_then(|arc| arc.downcast_ref::<T>())
}
/// Get arbitrary data as Arc from the context
pub fn get_arc<T: Any + Send + Sync>(&self) -> Option<Arc<T>> {
self.data
.get(&TypeId::of::<T>())
.and_then(|arc| Arc::clone(arc).downcast::<T>().ok())
}
/// Remove and return arbitrary data from the context
pub fn remove<T: Any + Send + Sync>(&mut self) -> Option<Arc<T>> {
self.data
.remove(&TypeId::of::<T>())
.and_then(|arc| arc.downcast::<T>().ok())
}
/// Check if the context contains data of a specific type
pub fn contains<T: Any + Send + Sync>(&self) -> bool {
self.data.contains_key(&TypeId::of::<T>())
}
/// Take ownership of the context and extract data of a specific type
pub fn take<T: Any + Send + Sync>(mut self) -> (Self, Option<Arc<T>>) {
let value = self
.data
.remove(&TypeId::of::<T>())
.and_then(|arc| arc.downcast::<T>().ok());
(self, value)
}
}
|
