chokepoint 0.5.1

Generic stream transformer to simulate traffic / network congestion
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

use bytes::{
    Bytes,
    BytesMut,
};
use rand::Rng;

/// A trait for payloads that can be used with the TrafficShaper.
pub trait ChokeItem: Unpin + Sized + 'static {
    fn byte_len(&self) -> usize;

    fn corrupt(&mut self);

    fn duplicate(&mut self) -> Option<Self> {
        None
    }
}

impl ChokeItem for Bytes {
    fn byte_len(&self) -> usize {
        Bytes::len(self)
    }

    fn corrupt(&mut self) {
        let index = rand::rng().random_range(0..self.len());
        let mut packet_modified = BytesMut::from(self.to_owned());
        packet_modified[index] ^= 0xFF; // Corrupt one byte
        *self = packet_modified.freeze();
    }

    fn duplicate(&mut self) -> Option<Self> {
        Some(self.clone())
    }
}

impl<T, E> ChokeItem for Result<T, E>
where
    T: ChokeItem,
    E: Unpin + Send + Sync + 'static,
{
    fn byte_len(&self) -> usize {
        self.as_ref().map_or(0, |payload| payload.byte_len())
    }

    fn corrupt(&mut self) {
        if let Ok(payload) = self {
            payload.corrupt();
        }
    }

    fn duplicate(&mut self) -> Option<Self> {
        self.as_mut().ok().and_then(|payload| payload.duplicate().map(Ok))
    }
}

impl<T> ChokeItem for Option<T>
where
    T: ChokeItem,
{
    fn byte_len(&self) -> usize {
        self.as_ref().map_or(0, |payload| payload.byte_len())
    }

    fn corrupt(&mut self) {
        if let Some(payload) = self {
            payload.corrupt();
        }
    }

    fn duplicate(&mut self) -> Option<Self> {
        self.as_mut().and_then(|payload| payload.duplicate().map(Some))
    }
}