tower-fault 0.0.5

Tower layers for fault injection
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

use rand::Rng;
use std::{ops, time::Duration};

/// Trait that returns a random latency.
pub trait Distribution<R> {
    /// Returns a random latency.
    fn sample(&self, req: &R) -> Duration;
}

macro_rules! impl_distribution_fixed {
    ($t:ty, $ret:tt) => {
        impl<R> Distribution<R> for $t {
            fn sample(&self, _req: &R) -> Duration {
                #[allow(clippy::redundant_closure_call)]
                $ret(*self)
            }
        }
    };
}
impl_distribution_fixed! { f64, (|value| Duration::from_secs_f64(value / 1000.0)) }
impl_distribution_fixed! { u64, (Duration::from_millis) }
impl_distribution_fixed! { Duration, (|value| value) }

macro_rules! impl_distribution_range {
    ($t:ty, $ret:tt) => {
        impl<R> Distribution<R> for ops::Range<$t> {
            fn sample(&self, _req: &R) -> Duration {
                let mut rng = rand::thread_rng();
                let value = rng.gen_range(self.clone());
                #[allow(clippy::redundant_closure_call)]
                $ret(value)
            }
        }

        impl<R> Distribution<R> for ops::RangeInclusive<$t> {
            fn sample(&self, _req: &R) -> Duration {
                let mut rng = rand::thread_rng();
                let value = rng.gen_range(self.clone());
                #[allow(clippy::redundant_closure_call)]
                $ret(value)
            }
        }
    };
}
impl_distribution_range! { f64, (|value| Duration::from_secs_f64(value / 1000.0)) }
impl_distribution_range! { u64, (Duration::from_millis) }
impl_distribution_range! { Duration, (|value| value) }

impl<F, R> Distribution<R> for F
where
    F: Fn(&R) -> Duration,
{
    fn sample(&self, req: &R) -> Duration {
        self(req)
    }
}