Struct EnvironmentWatcher

Source

pub struct EnvironmentWatcher { /* private fields */ }

Expand description

The current state of the environment

Implementations§

Source §

impl EnvironmentWatcher

Source

pub fn new(interval: Duration) -> Self

Create a new instance to track the state Interval - how often we request data and update the state (if required)

Examples found in repository ?

examples/snapshot.rs (line 46)

30pub fn main() -> Result<(), Error> {
31    let sub_envs_key = vec!["test.bey".to_string(), "test.wow".to_string()];
32    fill_envs(sub_envs_key.clone(), TEST_VALUE);
33
34    let sub_envs = Subscribe::Envs(sub_envs_key.clone());
35
36    let sub_pattern_envs_key = vec![
37        "my.server.port".to_string(),
38        "my.server.host".to_string(),
39        "my.server.locale".to_string(),
40        "my.server.tls".to_string(),
41    ];
42    fill_envs(sub_pattern_envs_key.clone(), TEST_VALUE);
43
44    let sub_pattern_envs = Subscribe::PatternEnvs(vec!["^my.server.*".to_string()]);
45
46    let env_core = EnvironmentWatcher::new(Duration::from_secs(3));
47    sleep(Duration::from_secs(1));
48
49    let only_envs = env_core.subscribe_snapshot(sub_envs)?;
50
51    let envs_data = only_envs.data();
52    print_after();
53    println!("{:?}", &envs_data);
54    println!();
55
56    envs_data.iter().for_each(|kv| {
57        match &**kv.0 {
58            "test.bey" | "test.wow" => {
59                // All good.
60                assert_eq!(TEST_VALUE, &**kv.1);
61            }
62            _ => {
63                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
64                panic!("unknown k/v in pattern sub.");
65            }
66        }
67    });
68
69    let pattern_envs = env_core.subscribe_snapshot(sub_pattern_envs)?;
70
71    let pattern_data = pattern_envs.data();
72    println!("{:?}", &pattern_data);
73
74    pattern_data.iter().for_each(|kv| {
75        match &**kv.0 {
76            "my.server.port" | "my.server.host" | "my.server.locale" | "my.server.tls" => {
77                // All good.
78                assert_eq!(TEST_VALUE, &**kv.1);
79            }
80            _ => {
81                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
82                panic!("unknown k/v in pattern sub.");
83            }
84        }
85    });
86
87    fill_envs(sub_envs_key.clone(), TEST_BY_CHANGE_VALUE);
88    fill_envs(sub_pattern_envs_key.clone(), TEST_BY_CHANGE_VALUE);
89
90    sleep(Duration::from_secs(3));
91
92    print_before();
93    let envs_data = only_envs.data();
94    println!("{:?}", &envs_data);
95    println!();
96
97    envs_data.iter().for_each(|kv| {
98        match &**kv.0 {
99            "test.bey" | "test.wow" => {
100                // All good.
101                assert_eq!(TEST_BY_CHANGE_VALUE, &**kv.1);
102            }
103            _ => {
104                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
105                panic!("unknown k/v in pattern sub.");
106            }
107        }
108    });
109
110    let pattern_data = pattern_envs.data();
111    println!("{:?}", &pattern_data);
112
113    pattern_data.iter().for_each(|kv| {
114        match &**kv.0 {
115            "my.server.port" | "my.server.host" | "my.server.locale" | "my.server.tls" => {
116                // All good.
117                assert_eq!(TEST_BY_CHANGE_VALUE, &**kv.1);
118            }
119            _ => {
120                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
121                panic!("unknown k/v in pattern sub.");
122            }
123        }
124    });
125
126    Ok(())
127}

Source

pub fn size(&self) -> usize

Subscribers size. (only Subscribe)

Source

pub fn subscribe_snapshot( &self, subscribe: Subscribe, ) -> Result<EnvironmentData>

Subscribe to the keys and get a snapshot of the data

Examples found in repository ?

examples/snapshot.rs (line 49)

30pub fn main() -> Result<(), Error> {
31    let sub_envs_key = vec!["test.bey".to_string(), "test.wow".to_string()];
32    fill_envs(sub_envs_key.clone(), TEST_VALUE);
33
34    let sub_envs = Subscribe::Envs(sub_envs_key.clone());
35
36    let sub_pattern_envs_key = vec![
37        "my.server.port".to_string(),
38        "my.server.host".to_string(),
39        "my.server.locale".to_string(),
40        "my.server.tls".to_string(),
41    ];
42    fill_envs(sub_pattern_envs_key.clone(), TEST_VALUE);
43
44    let sub_pattern_envs = Subscribe::PatternEnvs(vec!["^my.server.*".to_string()]);
45
46    let env_core = EnvironmentWatcher::new(Duration::from_secs(3));
47    sleep(Duration::from_secs(1));
48
49    let only_envs = env_core.subscribe_snapshot(sub_envs)?;
50
51    let envs_data = only_envs.data();
52    print_after();
53    println!("{:?}", &envs_data);
54    println!();
55
56    envs_data.iter().for_each(|kv| {
57        match &**kv.0 {
58            "test.bey" | "test.wow" => {
59                // All good.
60                assert_eq!(TEST_VALUE, &**kv.1);
61            }
62            _ => {
63                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
64                panic!("unknown k/v in pattern sub.");
65            }
66        }
67    });
68
69    let pattern_envs = env_core.subscribe_snapshot(sub_pattern_envs)?;
70
71    let pattern_data = pattern_envs.data();
72    println!("{:?}", &pattern_data);
73
74    pattern_data.iter().for_each(|kv| {
75        match &**kv.0 {
76            "my.server.port" | "my.server.host" | "my.server.locale" | "my.server.tls" => {
77                // All good.
78                assert_eq!(TEST_VALUE, &**kv.1);
79            }
80            _ => {
81                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
82                panic!("unknown k/v in pattern sub.");
83            }
84        }
85    });
86
87    fill_envs(sub_envs_key.clone(), TEST_BY_CHANGE_VALUE);
88    fill_envs(sub_pattern_envs_key.clone(), TEST_BY_CHANGE_VALUE);
89
90    sleep(Duration::from_secs(3));
91
92    print_before();
93    let envs_data = only_envs.data();
94    println!("{:?}", &envs_data);
95    println!();
96
97    envs_data.iter().for_each(|kv| {
98        match &**kv.0 {
99            "test.bey" | "test.wow" => {
100                // All good.
101                assert_eq!(TEST_BY_CHANGE_VALUE, &**kv.1);
102            }
103            _ => {
104                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
105                panic!("unknown k/v in pattern sub.");
106            }
107        }
108    });
109
110    let pattern_data = pattern_envs.data();
111    println!("{:?}", &pattern_data);
112
113    pattern_data.iter().for_each(|kv| {
114        match &**kv.0 {
115            "my.server.port" | "my.server.host" | "my.server.locale" | "my.server.tls" => {
116                // All good.
117                assert_eq!(TEST_BY_CHANGE_VALUE, &**kv.1);
118            }
119            _ => {
120                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
121                panic!("unknown k/v in pattern sub.");
122            }
123        }
124    });
125
126    Ok(())
127}

We subscribe to the keys, if successful, we get a snapshot of the current data and a channel for updating this data

Examples found in repository ?

examples/change_handler.rs (line 43)

31pub fn main() -> Result<(), Error> {
32    let sub_envs_key = vec![
33        "server.port".to_string(),
34        "server.address".to_string(),
35        "server.tls".to_string(),
36    ];
37    fill_envs(sub_envs_key.clone(), TEST_VALUE);
38
39    let env_core = EnvironmentWatcher::default();
40    sleep(Duration::from_secs(1));
41
42    let sub_envs = Subscribe::Envs(sub_envs_key.clone());
43    let only_envs = env_core.subscribe(sub_envs)?;
44
45    print_after();
46
47    let mut data = only_envs.0;
48
49    println!("{:?}", &data);
50
51    let rec = only_envs.1;
52
53    let mut event_count = 0;
54    loop {
55        // Change env state.
56        if event_count == 0 {
57            set_var("server.port", "2013");
58        } else if event_count == 1 {
59            set_var("server.address", "localhost");
60        } else if event_count == 2 {
61            remove_var("server.tls");
62        }
63
64        let event = rec.recv().unwrap();
65
66        match event {
67            ChangeState::Edit(k, v) => {
68                match &*k {
69                    "server.port" => {
70                        assert_eq!("2013", &*v);
71                        data.insert(k, v);
72                        restart_server(&data);
73                    }
74                    "server.address" => {
75                        assert_eq!("localhost", &*v);
76                        data.insert(k, v);
77                        restart_server(&data);
78                    }
79                    _ => {
80                        // ignore
81                    }
82                }
83            }
84            ChangeState::Delete(k) => {
85                assert_eq!("server.tls", &*k);
86                data.remove(&k);
87                restart_server(&data);
88            }
89        }
90
91        event_count = event_count + 1;
92
93        if event_count >= 3 {
94            break;
95        }
96    }
97
98    Ok(())
99}

Source

pub fn run(&self)

In a separate thread, we process state changes at intervals. If the values change, we will notify the subscribers who have subscribed to these values.