time

src/main.rs

@@ -3,7 +3,7 @@ use crate::data::Router as RouterData;
 use crate::protocol::{Hello, MessageType, Uplink};
 use crate::router::Router;
 use crate::server::Server;
-use crate::settings::{Settings, INTERVAL, LEARN};
+use crate::settings::{Settings, INTERVAL, WINDOW};
 use config::Config;
 use std::collections::BTreeMap;
 use std::fs;
@@ -85,10 +85,10 @@ async fn main() -> anyhow::Result<()> {
                     id: config.id,
                     action: if server.online {MessageType::Update} else {MessageType::Query},
                     version: server.version,
-                    peers: if now.duration_since(start) < LEARN { Default::default() } else { connections
+                    peers: if now.duration_since(start) < INTERVAL * WINDOW { Default::default() } else { connections
                         .iter()
                         .filter(|(_, to)| to.contains_key(&config.id))
-                        .map(|(from,_)|routers.get_mut(from).unwrap().update(now, start))
+                        .map(|(from,_)|routers.get_mut(from).unwrap().update(now))
                         .collect()},
                     via: Default::default(),
                     plan: Default::default()

src/router.rs

 use crate::data::Router as RouterData;
 use crate::protocol::{Hello, PeerQuality};
-use crate::settings::{Settings, INTERVAL};
+use crate::settings::{Settings, INTERVAL, WINDOW};
 use saturating_cast::SaturatingCast;
 use std::collections::BTreeMap;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
@@ -44,13 +44,15 @@ impl Router {
 
     pub fn on_message(&mut self, data: &Hello) {
         let delta = (data.time.wrapping_sub(self.remote_time) as i32 as f32 / INTERVAL.as_millis() as f32).round() as i32;
+        const WINDOW_MAX: i32 = WINDOW as i32;
+        const WINDOW_MIN: i32 = 1 - WINDOW_MAX;
         match delta {
-            -63..=-1 => {
+            WINDOW_MIN..0 => {
                 self.receive |= 1 << (-delta);
                 return;
             }
             0 => return,
-            1..=63 => {
+            1..WINDOW_MAX => {
                 self.receive = (self.receive << delta) | 1;
                 self.remote_time = data.time;
                 self.local_time = Instant::now();
@@ -71,21 +73,18 @@ impl Router {
         self.prev_delay = delay;
     }
 
-    pub(crate) fn update(&mut self, now: Instant, start: Instant) -> PeerQuality {
+    pub(crate) fn update(&mut self, now: Instant) -> PeerQuality {
         let reliability = self.receive.count_ones() as u8;
         if reliability > 0 {
-            let max = now.duration_since(start).div_duration_f32(INTERVAL) as u32;
-            let reliability = if max < 64 { (reliability as u32 * 64 / max) as u8 } else { reliability };
-
-            let duration = now.duration_since(self.local_time).div_duration_f32(INTERVAL) as u32;
-            if duration > 64 {
+            let duration = now.duration_since(self.local_time).div_duration_f32(INTERVAL) as u8;
+            if duration > WINDOW as u8 {
                 self.receive = 0;
                 Default::default()
             } else {
                 PeerQuality {
                     delay: self.delay.saturating_cast(),
                     jitter: self.jitter.saturating_cast(),
-                    reliability: reliability.saturating_sub((duration as u8).saturating_sub(1)),
+                    reliability: reliability.saturating_sub((duration).saturating_sub(1)),
                 }
             }
         } else {

src/settings.rs

@@ -43,7 +43,6 @@ impl Endpoint {
         Ok(SocketAddr::new(ip, self.port))
     }
 }
-
+pub const WINDOW: u32 = 64;
 pub const INTERVAL: Duration = Duration::from_secs(1);
-pub const LEARN: Duration = Duration::from_secs(10);
 pub const ROUTE_PROTOCOL: RouteProtocol = RouteProtocol::Other(252);