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

#[cfg(doctest)]
mod readme;

mod builder;

use std::net::IpAddr;

pub use builder::Builder;

mod config;
use config::Config;

mod dns;
use dns::Dns;
pub use dns::{ToIpAddr, ToSocketAddrs};

mod envelope;
use envelope::Envelope;

mod error;
pub use error::Result;

mod host;
pub use host::elapsed;
use host::Host;

pub mod net;

mod role;
use role::Role;

mod rt;
use rt::Rt;

mod sim;
pub use sim::Sim;

mod top;
use top::Topology;

mod world;
use world::World;

const TRACING_TARGET: &str = "turmoil";

/// Lookup an ip address by host name.
///
/// Must be called from within a Turmoil simulation.
pub fn lookup(addr: impl ToIpAddr) -> IpAddr {
    World::current(|world| world.lookup(addr))
}

/// Hold messages two hosts, until [`release`] is called.
///
/// Must be called from within a Turmoil simulation.
pub fn hold(a: impl ToIpAddr, b: impl ToIpAddr) {
    World::current(|world| {
        let a = world.lookup(a);
        let b = world.lookup(b);

        world.hold(a, b);
    })
}

/// The opposite of [`hold`]. All held messages are immediately delivered.
///
/// Must be called from within a Turmoil simulation.
pub fn release(a: impl ToIpAddr, b: impl ToIpAddr) {
    World::current(|world| {
        let a = world.lookup(a);
        let b = world.lookup(b);

        world.release(a, b);
    })
}

/// Partition two hosts, resulting in all messages sent between them to be
/// dropped.
///
/// Must be called from within a Turmoil simulation.
pub fn partition(a: impl ToIpAddr, b: impl ToIpAddr) {
    World::current(|world| {
        let a = world.lookup(a);
        let b = world.lookup(b);

        world.partition(a, b);
    })
}

/// Repair the connection between two hosts, resulting in messages to be
/// delivered.
///
/// Must be called from within a Turmoil simulation.
pub fn repair(a: impl ToIpAddr, b: impl ToIpAddr) {
    World::current(|world| {
        let a = world.lookup(a);
        let b = world.lookup(b);

        world.repair(a, b);
    })
}