fix

src/data.rs

@@ -13,5 +13,14 @@ pub struct RouterData {
 
 #[derive(Serialize, Deserialize, Clone)]
 pub struct ConnectionData {
+    pub protocol: Schema,
     pub metric: u32,
 }
+
+#[derive(Serialize, Deserialize, Default, PartialEq, Clone, Copy)]
+pub enum Schema {
+    #[default]
+    IP,
+    UDP,
+    TCP,
+}

src/main.rs

@@ -75,13 +75,14 @@ async fn main() -> Result<()> {
             result = socket.recv_from(&mut buf) => {
                 let (len, addr) = result?;
                 if let Ok((report, _)) = bincode::decode_from_slice::<Report, _>(&buf[..len], bincode::config::standard()) {
-                    println!("{}", serde_json::to_string(&report)?);
+                    // println!("{}", serde_json::to_string(&report)?);
                     let mut routers = routers.write().await;
                     if let Some(router) = routers.get_mut(&report.id) {
                         if let Some(change) = router.on_message(report, addr, &mut updating) {
-                            println!("r{} {}", router.id, serde_json::to_string(&change)?);
+                            println!("2.{} {}", router.id, serde_json::to_string(&change)?);
                             let len = bincode::encode_into_slice(change, &mut buf, bincode::config::standard())?;
                             let _ = socket.send_to(&buf[..len], addr).await;
+                            router.seq += 1;
                         }
                     }
                 }
@@ -92,26 +93,34 @@ async fn main() -> Result<()> {
                 if updating.router_id != 0 {
                     let router = routers.get_mut(&updating.router_id).expect("updating router_id should exist");
                     if now.duration_since(router.time) < TIMEOUT {
+                        println!("3.{}", serde_json::to_string(&updating)?);
                         let len = bincode::encode_into_slice(&updating.change, &mut buf, bincode::config::standard())?;
                         let _ = socket.send_to(&buf[..len], router.addr.unwrap()).await;
                     } else {
+                        println!("1");
                         router.offline();
                         router.finish(&mut updating);
                     }
                 }
                 if updating.router_id == 0 {
                     for router in routers.values_mut() {
-                        if now.duration_since(router.time) > TIMEOUT {
+                        if router.addr != None && now.duration_since(router.time) > TIMEOUT {
+                            println!("2");
                             router.offline();
                         }
                     }
                     if let Some((router, change)) = routers.values().find_map(|r|r.update(&routers, &connections).map(|change|(r,change))) {
                         updating.router_id = router.id;
                         updating.change = change;
-                        println!("{}", serde_json::to_string(&updating)?);
+                        println!("1.{}", serde_json::to_string(&updating)?);
                         let len = bincode::encode_into_slice(&updating.change, &mut buf, bincode::config::standard())?;
                         let _ = socket.send_to(&buf[..len], router.addr.unwrap()).await;
                     }
+
+                    if updating.router_id != 0 {
+                        let router = routers.get_mut(&updating.router_id).unwrap();
+                        router.seq += 1;
+                    }
                 }
             }
         }

src/router.rs

@@ -62,12 +62,16 @@ impl Router {
     }
 
     pub fn offline(&mut self) {
+        println!("router {} offline", self.id);
         self.addr = None;
         for peer in self.peers.values_mut() {
             peer.reliability = 0;
         }
     }
     pub fn online(&mut self, addr: SocketAddr) {
+        if self.addr == None {
+            println!("router {} online", self.id);
+        }
         self.addr = Some(addr);
         self.time = Instant::now();
     }
@@ -79,12 +83,18 @@ impl Router {
         // self.addr exist + no syn + peer + 正确的 ack 号 => 客户端汇报测量信息
         // self.addr exist + no syn + no peer + 正确的 ack 号 => 确认指令，解除 updating
 
-        match (self.addr != None, data.syn, data.peers.len() != 0, data.ack == self.seq.wrapping_add(1)) {
+        match (self.addr != None, data.syn, data.peers.len() != 0, data.ack == self.seq) {
             (false, true, false, true) => {
                 self.online(addr);
                 None
             }
-            (false, _, _, _) | (_, true, true, _) => {
+            (false, _, _, _) | (true, true, true, _) => {
+                if self.addr == None {
+                    println!("3.0");
+                } else {
+                    println!("3.1");
+                }
+
                 self.offline();
                 self.finish(updating);
                 Some(Change {
@@ -103,10 +113,22 @@ impl Router {
             }
             (true, false, false, true) => {
                 self.online(addr);
+                self.via.append(&mut updating.change.via);
                 self.finish(updating);
                 None
             }
-            _ => None,
+            _ => {
+                println!(
+                    "???, {}, {}, {}, {}, {} != {}",
+                    self.addr != None,
+                    data.syn,
+                    data.peers.len() != 0,
+                    data.ack == self.seq.wrapping_add(1),
+                    data.ack,
+                    self.seq
+                );
+                None
+            }
         }
     }