lan discovery almost done

Signed-off-by: fufesou <shuanglongchen@yeah.net>

libs/hbb_common/protos/discovery.proto

@@ -4,9 +4,10 @@ package discovery;
 import "base_proto.proto";
 
 message Discovery {
-  base.PeerInfo peer = 1;
+  string id = 1;
+  base.PeerInfo peer = 2;
   /// response port for current listening port(udp for now)
-  int32 port = 2;
+  int32 port = 3;
 }
 
 message DiscoveryBack {

libs/socket_cs/examples/discovery.rs

@@ -14,6 +14,7 @@ async fn lan_discover(port: u16, port_back: u16) {
         ..Default::default()
     };
     let client = DiscoveryClient::create(DiscoveryProto {
+        id: "client id".to_owned(),
         peer: protobuf::MessageField::from_option(Some(peer)),
         port: port_back as i32,
         ..Default::default()

libs/socket_cs/src/discovery.rs

@@ -32,7 +32,7 @@ impl DiscoveryClient {
         log::trace!("succeeded to bind {} for discovery client", addr);
 
         socket.set_broadcast(true)?;
-        log::info!("Broadcast mode set to ON");
+        log::trace!("Broadcast mode set to ON");
 
         let send_data = make_send_data(CMD_DISCOVERY, &info)?;
         Ok(Self { socket, send_data })
@@ -47,6 +47,7 @@ impl DiscoveryClient {
 
 pub struct HandlerDiscovery {
     get_allow: Option<fn() -> bool>,
+    id: String,
     send_data: Vec<u8>,
 }
 
@@ -55,6 +56,7 @@ impl HandlerDiscovery {
         let send_data = make_send_data(CMD_DISCOVERY_BACK, &self_info).unwrap();
         Self {
             get_allow,
+            id: self_info.id,
             send_data,
         }
     }
@@ -63,11 +65,13 @@ impl HandlerDiscovery {
 #[async_trait]
 impl crate::Handler<UdpRequest> for HandlerDiscovery {
     async fn call(&self, request: UdpRequest) -> ResultType<()> {
-        log::trace!("received discover query from {}", request.addr);
-
         let discovery = DiscoveryProto::parse_from_bytes(&request.data)?;
+        if discovery.id == self.id {
+            return Ok(());
+        }
+
         let peer = discovery.peer.as_ref().take().unwrap();
-        log::debug!(
+        log::trace!(
             "received discovery query from {} {}",
             peer.username,
             peer.hostname
@@ -75,12 +79,12 @@ impl crate::Handler<UdpRequest> for HandlerDiscovery {
 
         let allowed = self.get_allow.map_or(false, |f| f());
         if !allowed {
-            log::info!(
-                "received discovery query from {} {} {}, but discovery is not allowed",
-                request.addr,
-                peer.hostname,
-                peer.username
-            );
+            // log::info!(
+            //     "received discovery query from {} {} {}, but discovery is not allowed",
+            //     request.addr,
+            //     peer.hostname,
+            //     peer.username
+            // );
             return Ok(());
         }
 
@@ -89,7 +93,7 @@ impl crate::Handler<UdpRequest> for HandlerDiscovery {
 
         let mut peer_addr = request.addr;
         peer_addr.set_port(discovery.port as u16);
-        log::debug!("send self peer info to {}", peer_addr);
+        log::trace!("send self peer info to {}", peer_addr);
 
         let send_len = self.send_data.len();
         let mut cur_len = 0usize;

libs/socket_cs/src/udp.rs

@@ -64,7 +64,6 @@ impl Server {
                         break;
                     }
                     n = server.next() => {
-                        log::info!("received message");
                         let handlers = handlers.clone();
                         let rt = rt.clone();
                         match n {
@@ -76,24 +75,24 @@ impl Server {
                                             match handlers.get(&cmd) {
                                                 Some(h) => {
                                                     let request = UdpRequest {data: data[p+1..].to_vec(), addr};
-                                                    if let Err(e) = h.call(request).await {
-                                                        log::error!("handle {:?} failed, {}", cmd, e);
+                                                    if let Err(_e) = h.call(request).await {
+                                                        // log::error!("handle {:?} failed, {}", cmd, e);
                                                     }
                                                 }
                                                 None => {
-                                                    log::warn!("no handler for {:?}", &cmd);
+                                                    // log::warn!("no handler for {:?}", &cmd);
                                                 }
                                             }
                                         });
                                     }
                                     None => {
-                                        log::error!("failed to parse command token");
+                                        // log::error!("failed to parse command token");
                                     }
                                 }
 
                             }
-                            Some(Err(e)) => {
-                                log::error!("recv error: {}", e)
+                            Some(Err(_e)) => {
+                                // log::error!("recv error: {}", e)
                             }
                             None => {
                                 log::error!("should never reach here");
@@ -139,11 +138,12 @@ impl UdpHandlers {
     /// ```rust
     /// extern crate socket_cs;
     /// use socket_cs::{ResultType, udp::{UdpHandlers, UdpRequest}};
+    /// use async_trait::async_trait;
     ///
     /// struct SimpleHandler;
     ///
     /// #[async_trait]
-    /// impl crate::Handler<UdpRequest> for SimpleHandler {
+    /// impl socket_cs::Handler<UdpRequest> for SimpleHandler {
     ///     async fn call(&self, _: UdpRequest) -> ResultType<()> {
     ///         Ok(())
     ///     }