atm0s_sdn_key_value/
lib.rs

1pub static KEY_VALUE_SERVICE_ID: u8 = 4;
2pub type KeyId = u64;
3pub type SubKeyId = u64;
4pub type ReqId = u64;
5pub type KeyVersion = u64;
6pub type KeySource = NodeId;
7pub type ValueType = Vec<u8>;
8
9mod behavior;
10mod handler;
11mod msg;
12mod storage;
13
14use std::sync::Arc;
15
16use atm0s_sdn_identity::NodeId;
17use atm0s_sdn_utils::awaker::Awaker;
18pub use behavior::KeyValueBehavior;
19pub use behavior::KeyValueSdk;
20#[cfg(test)]
21use mockall::automock;
22pub use msg::{KeyValueBehaviorEvent, KeyValueHandlerEvent, KeyValueMsg, KeyValueSdkEvent};
23
24#[cfg_attr(test, automock)]
25pub trait ExternalControl: Send + Sync {
26    fn set_awaker(&self, awaker: Arc<dyn Awaker>);
27    fn on_event(&self, event: KeyValueSdkEvent);
28    fn pop_action(&self) -> Option<KeyValueSdkEvent>;
29}
30
31#[cfg(test)]
32mod tests {
33    // use std::{sync::Arc, time::Duration, vec};
34
35    // use atm0s_sdn_router::ForceLocalRouter;
36    // use atm0s_sdn_network::mock::MockTransport;
37    // use atm0s_sdn_network::{
38    //     convert_enum,
39    //     plane::{NetworkPlane, NetworkPlaneConfig},
40    // };
41    // use atm0s_sdn_utils::{option_handle::OptionUtils, SystemTimer};
42
43    // use crate::{KeyValueBehavior, KeyValueBehaviorEvent, KeyValueHandlerEvent, KeyValueMsg};
44
45    // #[derive(convert_enum::From, convert_enum::TryInto, PartialEq, Debug)]
46    // enum ImplNetworkMsg {
47    //     KeyValue(KeyValueMsg),
48    // }
49
50    // #[derive(convert_enum::From, convert_enum::TryInto)]
51    // enum ImplBehaviorEvent {
52    //     KeyValue(KeyValueBehaviorEvent),
53    // }
54
55    // #[derive(convert_enum::From, convert_enum::TryInto)]
56    // enum ImplHandlerEvent {
57    //     KeyValue(KeyValueHandlerEvent),
58    // }
59
60    // /// Testing local storage
61    // #[async_std::test]
62    // async fn local_node() {
63    //     let (mock, _faker, _output) = MockTransport::new();
64    //     let transport = Box::new(mock);
65    //     let timer = Arc::new(SystemTimer());
66
67    //     let (behavior, sdk) = KeyValueBehavior::new(0, timer.clone(), 1000);
68
69    //     let mut plane = NetworkPlane::<ImplBehaviorEvent, ImplHandlerEvent>::new(NetworkPlaneConfig {
70    //         local_node_id: 0,
71    //         tick_ms: 100,
72    //         behavior: vec![Box::new(behavior)],
73    //         transport,
74    //         timer,
75    //         router: Arc::new(ForceLocalRouter()),
76    //     });
77
78    //     let join = async_std::task::spawn(async move {
79    //         plane.started();
80    //         while let Ok(_) = plane.recv().await {}
81    //         plane.stopped();
82    //     });
83
84    //     async_std::task::sleep(Duration::from_millis(1000)).await;
85    //     sdk.set(111, vec![111], None);
86    //     let saved_value = sdk.get(111, 1000).await.expect("Should get success").expect("Should some");
87    //     assert_eq!(saved_value.0, vec![111]);
88
89    //     join.cancel().await.print_none("Should cancel join");
90    // }
91
92    // /// Testing local storage
93    // #[async_std::test]
94    // async fn local_node_hashmap() {
95    //     let (mock, _faker, _output) = MockTransport::new();
96    //     let transport = Box::new(mock);
97    //     let timer = Arc::new(SystemTimer());
98
99    //     let (behavior, sdk) = KeyValueBehavior::new(0, timer.clone(), 1000);
100
101    //     let mut plane = NetworkPlane::<ImplBehaviorEvent, ImplHandlerEvent>::new(NetworkPlaneConfig {
102    //         local_node_id: 0,
103    //         tick_ms: 100,
104    //         behavior: vec![Box::new(behavior)],
105    //         transport,
106    //         timer,
107    //         router: Arc::new(ForceLocalRouter()),
108    //     });
109
110    //     let join = async_std::task::spawn(async move {
111    //         plane.started();
112    //         while let Ok(_) = plane.recv().await {}
113    //         plane.stopped();
114    //     });
115
116    //     async_std::task::sleep(Duration::from_millis(1000)).await;
117    //     sdk.hset(111, 222, vec![111], None);
118    //     let saved_value = sdk.hget(111, 1000).await.expect("Should get success").expect("Should some");
119    //     assert_eq!(saved_value.into_iter().map(|(sub, val, _, src)| (sub, val, src)).collect::<Vec<_>>(), vec![(222, vec![111], 0)]);
120
121    //     join.cancel().await.print_none("Should cancel join");
122    // }
123}