env-watcher 0.1.0

A simple library for viewing environment variables with a subscription to change any variables.
Documentation 
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

use env_watcher::{EnvironmentWatcher, Error, Subscribe};
use std::thread::sleep;
use std::time::Duration;

static TEST_VALUE: &'static str = "ONLY_TEST";
static TEST_BY_CHANGE_VALUE: &'static str = "ONLY_TEST_CHANGE";

fn fill_envs(envs: Vec<String>, val: &'static str) {
    envs.iter().for_each(|k| {
        std::env::set_var(k, &val);
    });
}

fn print_after() {
    println!();
    println!("###################################################");
    println!("############## SUB KEYS AFTER CHANGE ##############");
    println!("###################################################");
    println!();
}

fn print_before() {
    println!();
    println!("####################################################");
    println!("############## SUB KEYS BEFORE CHANGE ##############");
    println!("####################################################");
    println!();
}

pub fn main() -> Result<(), Error> {
    let sub_envs_key = vec!["test.bey".to_string(), "test.wow".to_string()];
    fill_envs(sub_envs_key.clone(), TEST_VALUE);

    let sub_envs = Subscribe::Envs(sub_envs_key.clone());

    let sub_pattern_envs_key = vec![
        "my.server.port".to_string(),
        "my.server.host".to_string(),
        "my.server.locale".to_string(),
        "my.server.tls".to_string(),
    ];
    fill_envs(sub_pattern_envs_key.clone(), TEST_VALUE);

    let sub_pattern_envs = Subscribe::PatternEnvs(vec!["^my.server.*".to_string()]);

    let env_core = EnvironmentWatcher::new(Duration::from_secs(3));
    sleep(Duration::from_secs(1));

    let only_envs = env_core.subscribe_snapshot(sub_envs)?;

    let envs_data = only_envs.data();
    print_after();
    println!("{:?}", &envs_data);
    println!();

    envs_data.iter().for_each(|kv| {
        match &**kv.0 {
            "test.bey" | "test.wow" => {
                // All good.
                assert_eq!(TEST_VALUE, &**kv.1);
            }
            _ => {
                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
                panic!("unknown k/v in pattern sub.");
            }
        }
    });

    let pattern_envs = env_core.subscribe_snapshot(sub_pattern_envs)?;

    let pattern_data = pattern_envs.data();
    println!("{:?}", &pattern_data);

    pattern_data.iter().for_each(|kv| {
        match &**kv.0 {
            "my.server.port" | "my.server.host" | "my.server.locale" | "my.server.tls" => {
                // All good.
                assert_eq!(TEST_VALUE, &**kv.1);
            }
            _ => {
                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
                panic!("unknown k/v in pattern sub.");
            }
        }
    });

    fill_envs(sub_envs_key.clone(), TEST_BY_CHANGE_VALUE);
    fill_envs(sub_pattern_envs_key.clone(), TEST_BY_CHANGE_VALUE);

    sleep(Duration::from_secs(3));

    print_before();
    let envs_data = only_envs.data();
    println!("{:?}", &envs_data);
    println!();

    envs_data.iter().for_each(|kv| {
        match &**kv.0 {
            "test.bey" | "test.wow" => {
                // All good.
                assert_eq!(TEST_BY_CHANGE_VALUE, &**kv.1);
            }
            _ => {
                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
                panic!("unknown k/v in pattern sub.");
            }
        }
    });

    let pattern_data = pattern_envs.data();
    println!("{:?}", &pattern_data);

    pattern_data.iter().for_each(|kv| {
        match &**kv.0 {
            "my.server.port" | "my.server.host" | "my.server.locale" | "my.server.tls" => {
                // All good.
                assert_eq!(TEST_BY_CHANGE_VALUE, &**kv.1);
            }
            _ => {
                println!("Find unknown key with value. {}, {}", &**kv.0, &**kv.1);
                panic!("unknown k/v in pattern sub.");
            }
        }
    });

    Ok(())
}