Enum ToxicKind

pub enum ToxicKind {
    Noop,
    Latency {
        latency: u64,
        jitter: u64,
    },
    Timeout {
        timeout: u64,
    },
    Bandwidth {
        rate: u64,
    },
    SlowClose {
        delay: u64,
    },
    Slicer {
        average_size: u64,
        size_variation: u64,
        delay: u64,
    },
    LimitData {
        bytes: u64,
    },
}

Toxic kind and toxic-specific attributes

Variants

Noop

Passes all data through without any toxic effects

Latency

Passes data through with the a delay of latency +/- jitter added

Fields

latency: u64

Latency to be added, in milliseconds

jitter: u64

Jitter to be added to the latency, also in milliseconds

Timeout

Stops any data from flowing through, and will close the connection after a timeout

Fields

timeout: u64

in milliseconds

Bandwidth

Passes data through at a limited rate

Fields

rate: u64

in KB/S

SlowClose

Stops the TCP connection from closing until after a delay

Fields

delay: u64

in milliseconds

Slicer

Slices data into multiple smaller packets

Fields

average_size: u64

Average number of bytes to slice at

size_variation: u64

+/- bytes to vary sliced amounts. Must be less than the average size

delay: u64

Microseconds to delay each packet.

LimitData

Adds a limit of bytes transferred to the proxy session

Fields

bytes: u64

the limit

Trait Implementations

impl Clone for ToxicKind

fn clone(&self) -> ToxicKind

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ToxicKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ToxicKind

fn deserialize<__D>( __deserializer: __D, ) -> Result<ToxicKind, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ToxicKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for ToxicKind

fn eq(&self, other: &ToxicKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ToxicKind

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ToxicKind

impl StructuralPartialEq for ToxicKind