rings-core 0.1.0

Chord DHT implementation with ICE
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#[cfg(test)]
pub mod test {
    use rings_core::dht::{Chord, Did};
    use rings_core::channels::Channel as CbChannel;
    use rings_core::ecc::SecretKey;
    use rings_core::err::Result;
    use rings_core::session::SessionManager;
    use rings_core::swarm::Swarm;
    use rings_core::swarm::TransportManager;
    use rings_core::transports::Transport;
    use rings_core::types::channel::Channel;
    use rings_core::types::channel::Event;
    use rings_core::types::ice_transport::IceServer;
    use rings_core::types::ice_transport::IceTransport;
    use rings_core::types::ice_transport::IceTransportCallback;
    use rings_core::types::ice_transport::IceTrickleScheme;
    use std::str::FromStr;
    use std::sync::Arc;

    use wasm_bindgen_test::wasm_bindgen_test_configure;
    use wasm_bindgen_test::*;
    use web_sys::RtcIceConnectionState;
    use web_sys::RtcSdpType;

    wasm_bindgen_test_configure!(run_in_browser);

    fn new_chord(did: Did) -> Chord {
        Chord::new(did)
    }

    fn new_swarm(key: &SecretKey) -> Swarm {
        let stun = "stun://stun.l.google.com:19302";
        let session = SessionManager::new_with_seckey(key).unwrap();
        Swarm::new(stun, key.address(), session)
    }

    async fn prepare_transport(channel: Option<Arc<CbChannel<Event>>>) -> Result<Transport> {
        let ch = match channel {
            Some(c) => Arc::clone(&c),
            None => Arc::new(<CbChannel<Event> as Channel<Event>>::new(1)),
        };
        let mut trans = Transport::new(ch.sender());
        let stun = IceServer::from_str("stun://stun.l.google.com:19302").unwrap();
        trans.start(&stun).await.unwrap();
        trans.apply_callback().await.unwrap();
        Ok(trans)
    }

    pub async fn establish_connection(
        transport1: &Transport,
        transport2: &Transport,
    ) -> Result<()> {
        // Generate key pairs for signing and verification
        let key1 = SecretKey::random();
        let key2 = SecretKey::random();

        let session1 = SessionManager::new_with_seckey(&key1).unwrap();
        let session2 = SessionManager::new_with_seckey(&key2).unwrap();

        // Peer 1 try to connect peer 2
        let handshake_info1 = transport1
            .get_handshake_info(session1, RtcSdpType::Offer)
            .await
            .unwrap();

        assert_eq!(
            transport1.ice_connection_state().await,
            Some(RtcIceConnectionState::New)
        );

        assert_eq!(
            transport2.ice_connection_state().await,
            Some(RtcIceConnectionState::New)
        );

        // Peer 2 got offer then register
        let addr1 = transport2.register_remote_info(handshake_info1).await?;

        assert_eq!(addr1, key1.address());
        assert_eq!(
            transport1.ice_connection_state().await,
            Some(RtcIceConnectionState::New)
        );
        assert_eq!(
            transport2.ice_connection_state().await,
            Some(RtcIceConnectionState::New)
        );

        // Peer 2 create answer
        let handshake_info2 = transport2
            .get_handshake_info(session2, RtcSdpType::Answer)
            .await
            .unwrap();

        assert_eq!(
            transport1.ice_connection_state().await,
            Some(RtcIceConnectionState::New)
        );
        assert_eq!(
            transport2.ice_connection_state().await,
            Some(RtcIceConnectionState::Checking)
        );

        // Peer 1 got answer then register
        let addr2 = transport1
            .register_remote_info(handshake_info2)
            .await
            .unwrap();
        // assert_eq!(
        //     transport1.ice_connection_state().await,
        //     Some(RtcIceConnectionState::Checking)
        // );

        assert_eq!(addr2, key2.address());
        // let promise_1 = transport1.connect_success_promise().await.unwrap();
        // let promise_2 = transport2.connect_success_promise().await.unwrap();
        // promise_1.await.unwrap();
        // promise_2.await.unwrap();
        // assert_eq!(
        //     transport1.ice_connection_state().await,
        //     Some(RtcIceConnectionState::Connected)
        // );
        // assert_eq!(
        //     transport2.ice_connection_state().await,
        //     Some(RtcIceConnectionState::Connected)
        // );
        Ok(())
    }
}