antenna-protocol 0.1.1

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
97

use crate::{
    HandshakeInput, HandshakeMode, HandshakeOutput, HandshakeStrategy, Input, MeshNodeFSM, Output,
    UserMsgPayload,
};

pub(crate) fn drive_bootstrap_handshake<Msg: UserMsgPayload>(
    host: &mut MeshNodeFSM,
    joiner: &mut MeshNodeFSM,
) -> (Vec<Output<Msg>>, Vec<Output<Msg>>) {
    let host_id = host.id().clone();
    let joiner_id = joiner.id().clone();

    let out = host.process::<Msg>(Input::InitOpenOffer).unwrap();
    assert!(out.iter().any(|o| matches!(o, Output::InitOpenOffer)));

    let out = host
        .process::<Msg>(Input::OpenOfferCreated("offer".into()))
        .unwrap();

    let offer_payload = out
        .into_iter()
        .find_map(|o| match o {
            Output::OfferReady(p) => Some(p),
            _ => None,
        })
        .unwrap();

    joiner
        .process::<Msg>(Input::InitHandshake {
            with: host_id.clone(),
            mode: HandshakeMode::Bootstrap,
            strategy: HandshakeStrategy::Joiner,
        })
        .unwrap();

    let out = joiner
        .process::<Msg>(Input::Handshake {
            from: host_id.clone(),
            event: HandshakeInput::Offer(offer_payload),
        })
        .unwrap();
    assert!(out.iter().any(|o| matches!(
        o,
        Output::Handshake {
            event: HandshakeOutput::RequestSDPAnswer(_),
            ..
        }
    )));

    let out = joiner
        .process::<Msg>(Input::Handshake {
            from: host_id.clone(),
            event: HandshakeInput::AnswerCreated("answer".into()),
        })
        .unwrap();

    let answer_payload = out
        .into_iter()
        .find_map(|o| match o {
            Output::AnswerReady(p) => Some(p),
            _ => None,
        })
        .unwrap();

    let out = host
        .process::<Msg>(Input::Handshake {
            from: joiner_id.clone(),
            event: HandshakeInput::Answer(answer_payload),
        })
        .unwrap();
    assert!(out.iter().any(|o| matches!(
        o,
        Output::Handshake {
            event: HandshakeOutput::AcceptSDPAnswer(_),
            ..
        }
    )));

    let joiner_dc_out = joiner
        .process::<Msg>(Input::Handshake {
            from: host_id.clone(),
            event: HandshakeInput::DataChannelOpen,
        })
        .unwrap();

    let host_dc_out = host
        .process::<Msg>(Input::Handshake {
            from: joiner_id.clone(),
            event: HandshakeInput::DataChannelOpen,
        })
        .unwrap();

    assert!(host.is_connected(&joiner_id));
    assert!(joiner.is_connected(&host_id));

    (host_dc_out, joiner_dc_out)
}