antenna-protocol 0.1.0

SansIO core driving the antenna P2P mesh protocol.
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

#[cfg(test)]
mod test {
    use crate::{
        HandshakeInput, HandshakeMode, HandshakeStrategy, Input, MeshNodeFSM, Output, Scheduled,
        test::drive_bootstrap_handshake,
    };

    #[test]
    fn relay_via_drop_cleans_up_orphan_handshakes() {
        let mut alice = MeshNodeFSM::new();
        let mut bob = MeshNodeFSM::new();
        let bob_id = bob.id().clone();
        drive_bootstrap_handshake::<()>(&mut alice, &mut bob);

        let charlie_id = MeshNodeFSM::new().id().clone();

        alice
            .process::<()>(Input::InitHandshake {
                with: charlie_id.clone(),
                mode: HandshakeMode::Relay(bob_id.clone()),
                strategy: HandshakeStrategy::Joiner,
            })
            .unwrap();

        let outs = alice
            .process::<()>(Input::Handshake {
                from: bob_id.clone(),
                event: HandshakeInput::ConnectionDropped,
            })
            .unwrap();

        assert!(!alice.is_connected(&bob_id), "bob should be removed");
        assert!(
            outs.iter()
                .any(|o| matches!(o, Output::PeerLost { peer } if peer == &bob_id)),
            "bob (was connected) should emit PeerLost"
        );
        assert!(
            outs.iter().any(|o| matches!(
                o,
                Output::ScheduleTimer { kind: Scheduled::ReconnectAttempt { peer }, .. }
                    if peer == &bob_id
            )),
            "bob's reconnect attempt should be scheduled"
        );
        assert!(
            !outs
                .iter()
                .any(|o| matches!(o, Output::PeerLost { peer } if peer == &charlie_id)),
            "charlie never reached Connected — must NOT emit PeerLost"
        );
        assert!(
            outs.iter().any(|o| matches!(
                o,
                Output::ScheduleTimer { kind: Scheduled::ReconnectAttempt { peer }, .. }
                    if peer == &charlie_id
            )),
            "charlie's orphan handshake should queue a reconnect attempt"
        );
    }

    #[test]
    fn relay_via_drop_leaves_unrelated_relays_alone() {
        let mut alice = MeshNodeFSM::new();
        let mut bob = MeshNodeFSM::new();
        let bob_id = bob.id().clone();
        drive_bootstrap_handshake::<()>(&mut alice, &mut bob);

        let other_relay_id = MeshNodeFSM::new().id().clone();
        let dave_id = MeshNodeFSM::new().id().clone();

        alice
            .process::<()>(Input::InitHandshake {
                with: dave_id.clone(),
                mode: HandshakeMode::Relay(other_relay_id),
                strategy: HandshakeStrategy::Joiner,
            })
            .unwrap();

        let outs = alice
            .process::<()>(Input::Handshake {
                from: bob_id,
                event: HandshakeInput::ConnectionDropped,
            })
            .unwrap();

        assert!(
            !outs.iter().any(|o| matches!(
                o,
                Output::ScheduleTimer { kind: Scheduled::ReconnectAttempt { peer }, .. }
                    if peer == &dave_id
            )),
            "dave's relay was via a different peer; must not be cleaned up"
        );
    }
}