|
|
@@ -1,11 +1,6 @@
|
|
1
|
1
|
use hbb_common::{
|
|
2
|
|
- bytes::BytesMut,
|
|
3
|
|
- log,
|
|
4
|
|
- message_proto::*,
|
|
5
|
|
- protobuf::parse_from_bytes,
|
|
6
|
|
- tokio::{net::UdpSocket, stream::StreamExt},
|
|
7
|
|
- udp::FramedSocket,
|
|
8
|
|
- AddrMangle, ResultType,
|
|
|
2
|
+ bytes::BytesMut, log, message_proto::*, protobuf::parse_from_bytes, tokio::net::UdpSocket,
|
|
|
3
|
+ udp::FramedSocket, AddrMangle, ResultType,
|
|
9
|
4
|
};
|
|
10
|
5
|
use std::{collections::HashMap, net::SocketAddr};
|
|
11
|
6
|
|
|
|
@@ -86,7 +81,7 @@ impl RendezvousServer {
|
|
86
|
81
|
mod tests {
|
|
87
|
82
|
use super::*;
|
|
88
|
83
|
use hbb_common::tokio;
|
|
89
|
|
- use std::time::Duration;
|
|
|
84
|
+ use std::io::{Error, ErrorKind};
|
|
90
|
85
|
|
|
91
|
86
|
#[allow(unused_must_use)]
|
|
92
|
87
|
#[tokio::main]
|
|
|
@@ -100,74 +95,72 @@ mod tests {
|
|
100
|
95
|
let addr_server = format!("127.0.0.1:{}", port_server);
|
|
101
|
96
|
let f1 = RendezvousServer::start(&addr_server);
|
|
102
|
97
|
let addr_server = addr_server.parse().unwrap();
|
|
103
|
|
- let f2 = async {
|
|
104
|
|
- // B register it to server
|
|
105
|
|
- let socket_b = UdpSocket::bind("127.0.0.1:0").await.unwrap();
|
|
106
|
|
- let local_addr_b = socket_b.local_addr().unwrap();
|
|
107
|
|
- let mut socket_b = FramedSocket::new(socket_b);
|
|
108
|
|
- let mut msg_out = Message::new();
|
|
109
|
|
- msg_out.set_register_peer(RegisterPeer {
|
|
110
|
|
- hbb_addr: "123".to_string(),
|
|
111
|
|
- ..Default::default()
|
|
112
|
|
- });
|
|
113
|
|
- socket_b.send(&msg_out, addr_server).await;
|
|
114
|
|
-
|
|
115
|
|
- // A send punch request to server
|
|
116
|
|
- let socket_a = UdpSocket::bind("127.0.0.1:0").await.unwrap();
|
|
117
|
|
- let local_addr_a = socket_a.local_addr().unwrap();
|
|
118
|
|
- let mut socket_a = FramedSocket::new(socket_a);
|
|
119
|
|
- msg_out.set_punch_hole_request(PunchHoleRequest {
|
|
120
|
|
- hbb_addr: "123".to_string(),
|
|
|
98
|
+ let f2 = punch_hole(addr_server);
|
|
|
99
|
+ tokio::try_join!(f1, f2);
|
|
|
100
|
+ }
|
|
|
101
|
+
|
|
|
102
|
+ async fn punch_hole(addr_server: SocketAddr) -> ResultType<()> {
|
|
|
103
|
+ // B register it to server
|
|
|
104
|
+ let socket_b = UdpSocket::bind("127.0.0.1:0").await?;
|
|
|
105
|
+ let local_addr_b = socket_b.local_addr().unwrap();
|
|
|
106
|
+ let mut socket_b = FramedSocket::new(socket_b);
|
|
|
107
|
+ let mut msg_out = Message::new();
|
|
|
108
|
+ msg_out.set_register_peer(RegisterPeer {
|
|
|
109
|
+ hbb_addr: "123".to_string(),
|
|
|
110
|
+ ..Default::default()
|
|
|
111
|
+ });
|
|
|
112
|
+ socket_b.send(&msg_out, addr_server).await?;
|
|
|
113
|
+
|
|
|
114
|
+ // A send punch request to server
|
|
|
115
|
+ let socket_a = UdpSocket::bind("127.0.0.1:0").await?;
|
|
|
116
|
+ let local_addr_a = socket_a.local_addr().unwrap();
|
|
|
117
|
+ let mut socket_a = FramedSocket::new(socket_a);
|
|
|
118
|
+ msg_out.set_punch_hole_request(PunchHoleRequest {
|
|
|
119
|
+ hbb_addr: "123".to_string(),
|
|
|
120
|
+ ..Default::default()
|
|
|
121
|
+ });
|
|
|
122
|
+ socket_a.send(&msg_out, addr_server).await?;
|
|
|
123
|
+
|
|
|
124
|
+ println!(
|
|
|
125
|
+ "A {:?} request punch hole to B {:?} via server {:?}",
|
|
|
126
|
+ local_addr_a, local_addr_b, addr_server,
|
|
|
127
|
+ );
|
|
|
128
|
+
|
|
|
129
|
+ // on B side, responsed to A's punch request forwarded from server
|
|
|
130
|
+ if let Some(Ok((bytes, addr))) = socket_b.next_timeout(1000).await {
|
|
|
131
|
+ assert_eq!(addr_server, addr);
|
|
|
132
|
+ let msg_in = parse_from_bytes::<Message>(&bytes)?;
|
|
|
133
|
+ let remote_addr_a = AddrMangle::decode(&msg_in.get_punch_hole().socket_addr[..]);
|
|
|
134
|
+ assert_eq!(local_addr_a, remote_addr_a);
|
|
|
135
|
+
|
|
|
136
|
+ // B punch A
|
|
|
137
|
+ socket_b
|
|
|
138
|
+ .get_mut()
|
|
|
139
|
+ .send_to(&b"SYN"[..], &remote_addr_a)
|
|
|
140
|
+ .await?;
|
|
|
141
|
+
|
|
|
142
|
+ msg_out.set_punch_hole_sent(PunchHoleSent {
|
|
|
143
|
+ socket_addr: AddrMangle::encode(&remote_addr_a),
|
|
121
|
144
|
..Default::default()
|
|
122
|
145
|
});
|
|
123
|
|
- socket_a.send(&msg_out, addr_server).await;
|
|
124
|
|
-
|
|
125
|
|
- println!(
|
|
126
|
|
- "A {:?} request punch hole to B {:?} via server {:?}",
|
|
127
|
|
- local_addr_a, local_addr_b, addr_server,
|
|
128
|
|
- );
|
|
129
|
|
-
|
|
130
|
|
- // on B side, responsed to A's punch request forwarded from server
|
|
131
|
|
- if let Ok(Some(Ok((bytes, addr)))) =
|
|
132
|
|
- tokio::time::timeout(Duration::from_millis(1000), socket_b.next()).await
|
|
133
|
|
- {
|
|
134
|
|
- assert_eq!(addr_server, addr);
|
|
135
|
|
- let msg_in = parse_from_bytes::<Message>(&bytes).unwrap();
|
|
136
|
|
- let remote_addr_a = AddrMangle::decode(&msg_in.get_punch_hole().socket_addr[..]);
|
|
137
|
|
- assert_eq!(local_addr_a, remote_addr_a);
|
|
138
|
|
-
|
|
139
|
|
- // B punch A
|
|
140
|
|
- socket_b
|
|
141
|
|
- .get_mut()
|
|
142
|
|
- .send_to(&b"SYN"[..], &remote_addr_a)
|
|
143
|
|
- .await;
|
|
144
|
|
-
|
|
145
|
|
- msg_out.set_punch_hole_sent(PunchHoleSent {
|
|
146
|
|
- socket_addr: AddrMangle::encode(&remote_addr_a),
|
|
147
|
|
- ..Default::default()
|
|
148
|
|
- });
|
|
149
|
|
- socket_b.send(&msg_out, addr_server).await;
|
|
150
|
|
- }
|
|
|
146
|
+ socket_b.send(&msg_out, addr_server).await?;
|
|
|
147
|
+ } else {
|
|
|
148
|
+ panic!("failed");
|
|
|
149
|
+ }
|
|
151
|
150
|
|
|
152
|
|
- // on A side
|
|
153
|
|
- socket_a.next().await; // skip "SYN"
|
|
154
|
|
- if let Ok(Some(Ok((bytes, addr)))) =
|
|
155
|
|
- tokio::time::timeout(Duration::from_millis(1000), socket_a.next()).await
|
|
156
|
|
- {
|
|
157
|
|
- assert_eq!(addr_server, addr);
|
|
158
|
|
- let msg_in = parse_from_bytes::<Message>(&bytes).unwrap();
|
|
159
|
|
- let remote_addr_b =
|
|
160
|
|
- AddrMangle::decode(&msg_in.get_punch_hole_response().socket_addr[..]);
|
|
161
|
|
- assert_eq!(local_addr_b, remote_addr_b);
|
|
162
|
|
- }
|
|
|
151
|
+ // on A side
|
|
|
152
|
+ socket_a.next().await; // skip "SYN"
|
|
|
153
|
+ if let Some(Ok((bytes, addr))) = socket_a.next_timeout(1000).await {
|
|
|
154
|
+ assert_eq!(addr_server, addr);
|
|
|
155
|
+ let msg_in = parse_from_bytes::<Message>(&bytes)?;
|
|
|
156
|
+ let remote_addr_b =
|
|
|
157
|
+ AddrMangle::decode(&msg_in.get_punch_hole_response().socket_addr[..]);
|
|
|
158
|
+ assert_eq!(local_addr_b, remote_addr_b);
|
|
|
159
|
+ } else {
|
|
|
160
|
+ panic!("failed");
|
|
|
161
|
+ }
|
|
163
|
162
|
|
|
164
|
|
- if true {
|
|
165
|
|
- Err(Box::new(simple_error::SimpleError::new("done")))
|
|
166
|
|
- } else {
|
|
167
|
|
- Ok(())
|
|
168
|
|
- }
|
|
169
|
|
- };
|
|
170
|
|
- tokio::try_join!(f1, f2);
|
|
|
163
|
+ Err(Box::new(Error::new(ErrorKind::Other, "done")))
|
|
171
|
164
|
}
|
|
172
|
165
|
|
|
173
|
166
|
#[test]
|
open-trade