refactored

Cargo.lock

@@ -170,7 +170,6 @@ name = "hbbs"
 version = "0.1.0"
 dependencies = [
  "hbb_common 0.1.0",
- "simple-error 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -405,11 +404,6 @@ dependencies = [
  "libc 0.2.67 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
-[[package]]
-name = "simple-error"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
 [[package]]
 name = "slab"
 version = "0.4.2"
@@ -599,7 +593,6 @@ dependencies = [
 "checksum regex 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "322cf97724bea3ee221b78fe25ac9c46114ebb51747ad5babd51a2fc6a8235a8"
 "checksum regex-syntax 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)" = "1132f845907680735a84409c3bebc64d1364a5683ffbce899550cd09d5eaefc1"
 "checksum signal-hook-registry 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "94f478ede9f64724c5d173d7bb56099ec3e2d9fc2774aac65d34b8b890405f41"
-"checksum simple-error 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "339844c9af2d844b9230bb28e8f819a7790cbf20a29b5cbd2b59916a03a1ef51"
 "checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
 "checksum socket2 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)" = "e8b74de517221a2cb01a53349cf54182acdc31a074727d3079068448c0676d85"
 "checksum syn 1.0.16 (registry+https://github.com/rust-lang/crates.io-index)" = "123bd9499cfb380418d509322d7a6d52e5315f064fe4b3ad18a53d6b92c07859"

Cargo.toml

@@ -7,7 +7,6 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-simple-error = "0.2"
 hbb_common = { path = "libs/hbb_common" }
 
 [workspace]

src/rendezvous_server.rs

@@ -1,11 +1,6 @@
 use hbb_common::{
-    bytes::BytesMut,
+    bytes::BytesMut, log, message_proto::*, protobuf::parse_from_bytes, tokio::net::UdpSocket,
-    log,
+    udp::FramedSocket, AddrMangle, ResultType,
-    message_proto::*,
-    protobuf::parse_from_bytes,
-    tokio::{net::UdpSocket, stream::StreamExt},
-    udp::FramedSocket,
-    AddrMangle, ResultType,
 };
 use std::{collections::HashMap, net::SocketAddr};
 
@@ -86,7 +81,7 @@ impl RendezvousServer {
 mod tests {
     use super::*;
     use hbb_common::tokio;
-    use std::time::Duration;
+    use std::io::{Error, ErrorKind};
 
     #[allow(unused_must_use)]
     #[tokio::main]
@@ -100,9 +95,13 @@ mod tests {
         let addr_server = format!("127.0.0.1:{}", port_server);
         let f1 = RendezvousServer::start(&addr_server);
         let addr_server = addr_server.parse().unwrap();
-        let f2 = async {
+        let f2 = punch_hole(addr_server);
+        tokio::try_join!(f1, f2);
+    }
+
+    async fn punch_hole(addr_server: SocketAddr) -> ResultType<()> {
         // B register it to server
-            let socket_b = UdpSocket::bind("127.0.0.1:0").await.unwrap();
+        let socket_b = UdpSocket::bind("127.0.0.1:0").await?;
         let local_addr_b = socket_b.local_addr().unwrap();
         let mut socket_b = FramedSocket::new(socket_b);
         let mut msg_out = Message::new();
@@ -110,17 +109,17 @@ mod tests {
             hbb_addr: "123".to_string(),
             ..Default::default()
         });
-            socket_b.send(&msg_out, addr_server).await;
+        socket_b.send(&msg_out, addr_server).await?;
 
         // A send punch request to server
-            let socket_a = UdpSocket::bind("127.0.0.1:0").await.unwrap();
+        let socket_a = UdpSocket::bind("127.0.0.1:0").await?;
         let local_addr_a = socket_a.local_addr().unwrap();
         let mut socket_a = FramedSocket::new(socket_a);
         msg_out.set_punch_hole_request(PunchHoleRequest {
             hbb_addr: "123".to_string(),
             ..Default::default()
         });
-            socket_a.send(&msg_out, addr_server).await;
+        socket_a.send(&msg_out, addr_server).await?;
 
         println!(
             "A {:?} request punch hole to B {:?} via server {:?}",
@@ -128,11 +127,9 @@ mod tests {
         );
 
         // on B side, responsed to A's punch request forwarded from server
-            if let Ok(Some(Ok((bytes, addr)))) =
+        if let Some(Ok((bytes, addr))) = socket_b.next_timeout(1000).await {
-                tokio::time::timeout(Duration::from_millis(1000), socket_b.next()).await
-            {
             assert_eq!(addr_server, addr);
-                let msg_in = parse_from_bytes::<Message>(&bytes).unwrap();
+            let msg_in = parse_from_bytes::<Message>(&bytes)?;
             let remote_addr_a = AddrMangle::decode(&msg_in.get_punch_hole().socket_addr[..]);
             assert_eq!(local_addr_a, remote_addr_a);
 
@@ -140,34 +137,30 @@ mod tests {
             socket_b
                 .get_mut()
                 .send_to(&b"SYN"[..], &remote_addr_a)
-                    .await;
+                .await?;
 
             msg_out.set_punch_hole_sent(PunchHoleSent {
                 socket_addr: AddrMangle::encode(&remote_addr_a),
                 ..Default::default()
             });
-                socket_b.send(&msg_out, addr_server).await;
+            socket_b.send(&msg_out, addr_server).await?;
+        } else {
+            panic!("failed");
         }
 
         // on A side
         socket_a.next().await; // skip "SYN"
-            if let Ok(Some(Ok((bytes, addr)))) =
+        if let Some(Ok((bytes, addr))) = socket_a.next_timeout(1000).await {
-                tokio::time::timeout(Duration::from_millis(1000), socket_a.next()).await
-            {
             assert_eq!(addr_server, addr);
-                let msg_in = parse_from_bytes::<Message>(&bytes).unwrap();
+            let msg_in = parse_from_bytes::<Message>(&bytes)?;
             let remote_addr_b =
                 AddrMangle::decode(&msg_in.get_punch_hole_response().socket_addr[..]);
             assert_eq!(local_addr_b, remote_addr_b);
+        } else {
+            panic!("failed");
         }
 
-            if true {
+        Err(Box::new(Error::new(ErrorKind::Other, "done")))
-                Err(Box::new(simple_error::SimpleError::new("done")))
-            } else {
-                Ok(())
-            }
-        };
-        tokio::try_join!(f1, f2);
     }
 
     #[test]