shaku 0.6.2

Compile Time Dependency Injection for Rust
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
128
129
130
131
132
133
134
135
136
137
138

#![allow(clippy::disallowed_names, clippy::mutex_atomic)]
#![cfg(feature = "thread_safe")]

use rand::Rng;
use shaku::{module, Component, HasComponent, Interface};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

trait Foo: Interface {
    fn get_value(&self) -> usize;
    fn set_value(&self, _: usize);
}

#[derive(Component)]
#[shaku(interface = Foo)]
struct FooImpl {
    #[shaku(default = AtomicUsize::new(FOO_DEFAULT_VALUE))]
    value: AtomicUsize,
}

impl Foo for FooImpl {
    fn get_value(&self) -> usize {
        self.value.load(Ordering::SeqCst)
    }

    fn set_value(&self, val: usize) {
        self.value.store(val, Ordering::SeqCst)
    }
}

module! {
    FooModule {
        components = [FooImpl],
        providers = []
    }
}

const FOO_DEFAULT_VALUE: usize = 17;
const NB_THREADS: usize = 10;
const MAX_SLEEP_TIME: u64 = 2000;

/// Call resolve_ref from multiple threads and verify the value is correct
#[test]
fn simple_multithreaded_resolve_ref() {
    // Build module
    let module = FooModule::builder().build();
    let shared_module = Arc::new(module);

    // Launch a few threads where each will try to resolve `Foo`
    let mut handles = Vec::new();
    for i in 0..NB_THREADS {
        let shared_module = Arc::clone(&shared_module);

        handles.push(
            thread::Builder::new()
                .name(format!("reader #{}", &i))
                .spawn(move || {
                    // Inject some randomness in the test
                    let sleep_ms = rand::thread_rng().gen_range(0..MAX_SLEEP_TIME);
                    thread::sleep(Duration::from_millis(sleep_ms));

                    let foo: &dyn Foo = shared_module.resolve_ref();
                    assert_eq!(foo.get_value(), FOO_DEFAULT_VALUE);
                })
                .unwrap(),
        );
    }

    // Wait until all the threads are done
    for handle in handles {
        handle.join().unwrap();
    }
}

/// Read and write the value from multiple threads, verifying the value on each read
#[test]
fn simple_multithreaded_resolve_ref_n_mut() {
    // Build module
    let module = FooModule::builder().build();
    let shared_module = Arc::new(module);
    let latest_data: Arc<Mutex<usize>> = Arc::new(Mutex::new(FOO_DEFAULT_VALUE));

    // Launch a few threads where each will try to resolve `Foo`
    let mut handles = Vec::new();
    for i in 0..NB_THREADS {
        let (shared_module, latest_data) = (shared_module.clone(), latest_data.clone());

        handles.push(
            thread::Builder::new()
                .name(format!("reader #{}", &i))
                .spawn(move || {
                    // Inject some randomness in the test
                    let handle = thread::current();
                    let sleep_ms = rand::thread_rng().gen_range(0..MAX_SLEEP_TIME);
                    thread::sleep(Duration::from_millis(sleep_ms));

                    // Resolve the module
                    let use_mut = rand::thread_rng().gen_bool(0.5);
                    if use_mut {
                        // Set a new value
                        let foo: &dyn Foo = shared_module.resolve_ref();
                        let new_value: usize = rand::thread_rng().gen_range(0..256);
                        foo.set_value(new_value);
                        assert_eq!(foo.get_value(), new_value);

                        let mut latest_data_lock = latest_data.lock().unwrap();
                        *latest_data_lock = new_value;

                        println!(
                            "In thread {:?} > resolve ok > value changed to {}",
                            &handle.name().unwrap(),
                            new_value
                        );
                    } else {
                        // Read the data and check against the expected value
                        let foo: &dyn Foo = shared_module.resolve_ref();
                        let latest_data_lock = latest_data.lock().unwrap();
                        let data = *latest_data_lock;

                        println!(
                            "In thread {:?} > resolve ok > value should be {}",
                            &handle.name().unwrap(),
                            data
                        );
                        assert_eq!(foo.get_value(), data);
                    }
                })
                .unwrap(),
        );
    }

    // Wait until all the threads are done
    for handle in handles {
        handle.join().unwrap();
    }
}