atm0s_sdn_transport_vnet/
lib.rs

1mod connection;
2mod connector;
3mod earth;
4mod listener;
5mod transport;
6
7pub const VNET_PROTOCOL_ID: u8 = 1;
8pub use earth::VnetEarth;
9pub use transport::VnetTransport;
10
11#[cfg(test)]
12mod tests {
13    use crate::{VnetEarth, VnetTransport};
14    use atm0s_sdn_identity::{ConnDirection, NodeAddr, NodeId};
15    use atm0s_sdn_network::{
16        msg::TransportMsg,
17        transport::{ConnectionEvent, ConnectionStats, OutgoingConnectionError, Transport, TransportEvent},
18    };
19    use atm0s_sdn_router::RouteRule;
20    use serde::{Deserialize, Serialize};
21    use std::sync::Arc;
22
23    #[derive(PartialEq, Debug, Serialize, Deserialize)]
24    enum Msg {
25        Ping,
26        Pong,
27    }
28
29    fn build_msg(to_node: NodeId, msg: Msg) -> TransportMsg {
30        TransportMsg::build(0, 0, RouteRule::ToNode(to_node), 0, 0, &bincode::serialize(&msg).unwrap())
31    }
32
33    #[async_std::test]
34    async fn simple_network() {
35        let vnet = Arc::new(VnetEarth::default());
36
37        let mut tran1 = VnetTransport::new(vnet.clone(), NodeAddr::empty(1));
38        let mut tran2 = VnetTransport::new(vnet.clone(), NodeAddr::empty(2));
39
40        let connector1 = tran1.connector();
41        for conn in connector1.create_pending_outgoing(NodeAddr::empty(2)) {
42            connector1.continue_pending_outgoing(conn);
43        }
44
45        match tran2.recv().await.unwrap() {
46            TransportEvent::IncomingRequest(node, conn, acceptor) => {
47                assert_eq!(node, 1);
48                assert_eq!(conn.direction(), ConnDirection::Incoming);
49                acceptor.accept();
50            }
51            _ => {
52                panic!("Need IncomingRequest")
53            }
54        }
55
56        let (tran2_sender, mut tran2_recv) = match tran2.recv().await.unwrap() {
57            TransportEvent::Incoming(sender, recv) => {
58                assert_eq!(sender.remote_node_id(), 1);
59                assert_eq!(sender.remote_addr(), NodeAddr::empty(1));
60                assert_eq!(sender.conn_id().direction(), ConnDirection::Incoming);
61                (sender, recv)
62            }
63            _ => {
64                panic!("Need incoming")
65            }
66        };
67
68        let (tran1_sender, mut tran1_recv) = match tran1.recv().await.unwrap() {
69            TransportEvent::Outgoing(sender, recv, ..) => {
70                assert_eq!(sender.remote_node_id(), 2);
71                assert_eq!(sender.remote_addr(), NodeAddr::empty(2));
72                (sender, recv)
73            }
74            _ => {
75                panic!("Need outgoing")
76            }
77        };
78
79        let received_event = tran2_recv.poll().await.unwrap();
80        assert_eq!(
81            received_event,
82            ConnectionEvent::Stats(ConnectionStats {
83                rtt_ms: 1,
84                sending_kbps: 0,
85                send_est_kbps: 100000,
86                loss_percent: 0,
87                over_use: false,
88            })
89        );
90
91        let received_event = tran1_recv.poll().await.unwrap();
92        assert_eq!(
93            received_event,
94            ConnectionEvent::Stats(ConnectionStats {
95                rtt_ms: 1,
96                sending_kbps: 0,
97                send_est_kbps: 100000,
98                loss_percent: 0,
99                over_use: false,
100            })
101        );
102
103        tran1_sender.send(build_msg(1, Msg::Ping));
104        let received_event = tran2_recv.poll().await.unwrap();
105        assert_eq!(received_event, ConnectionEvent::Msg(build_msg(1, Msg::Ping)));
106
107        tran2_sender.send(build_msg(1, Msg::Ping));
108        let received_event = tran1_recv.poll().await.unwrap();
109        assert_eq!(received_event, ConnectionEvent::Msg(build_msg(1, Msg::Ping)));
110
111        tran1_sender.close();
112        assert_eq!(tran1_recv.poll().await, Err(()));
113        assert_eq!(tran2_recv.poll().await, Err(()));
114        assert_eq!(vnet.connections.read().len(), 0);
115    }
116
117    #[async_std::test]
118    async fn simple_network_connect_addr_not_found() {
119        let vnet = Arc::new(VnetEarth::default());
120
121        let mut tran1 = VnetTransport::new(vnet.clone(), NodeAddr::empty(1));
122        let connector1 = tran1.connector();
123        for conn in connector1.create_pending_outgoing(NodeAddr::empty(2)) {
124            connector1.continue_pending_outgoing(conn);
125        }
126
127        match tran1.recv().await.unwrap() {
128            TransportEvent::OutgoingError { err, node_id, .. } => {
129                assert_eq!(err, OutgoingConnectionError::DestinationNotFound);
130                assert_eq!(node_id, 2);
131            }
132            _ => {
133                panic!("Need OutgoingError")
134            }
135        };
136    }
137}
atm0s_sdn_transport_vnet/lib.rs

atm0s_sdn_transport_vnet/
lib.rs
