learn

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, TIMEOUT};
+use crate::settings::{Settings, INTERVAL, LEARN};
 use config::Config;
 use std::collections::BTreeMap;
 use std::fs;
@@ -85,7 +85,7 @@ 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) < TIMEOUT { Default::default() } else { connections
+                    peers: if now.duration_since(start) < LEARN { Default::default() } else { connections
                         .iter()
                         .filter(|(_, to)| to.contains_key(&config.id))
                         .map(|(from,_)|routers.get_mut(from).unwrap().update(now, start))

src/router.rs

 use crate::data::Router as RouterData;
 use crate::protocol::{Hello, PeerQuality};
-use crate::settings::{Settings, INTERVAL, TIMEOUT};
+use crate::settings::{Settings, INTERVAL};
 use saturating_cast::SaturatingCast;
 use std::collections::BTreeMap;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
@@ -75,15 +75,15 @@ impl Router {
             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);
-            if duration > TIMEOUT {
+            let duration = now.duration_since(self.local_time).div_duration_f32(INTERVAL) as u32;
+            if duration > 64 {
                 self.receive = 0;
                 Default::default()
             } else {
                 PeerQuality {
                     delay: self.delay.saturating_cast(),
                     jitter: self.jitter.saturating_cast(),
-                    reliability: reliability.saturating_sub((duration.div_duration_f32(INTERVAL) as u8).saturating_sub(1)),
+                    reliability: reliability.saturating_sub((duration as u8).saturating_sub(1)),
                 }
             }
         } else {

src/settings.rs

-use hickory_resolver::Resolver;
 use hickory_resolver::name_server::GenericConnector;
 use hickory_resolver::proto::runtime::TokioRuntimeProvider;
+use hickory_resolver::Resolver;
 use netlink_packet_route::route::RouteProtocol;
 use serde::Deserialize;
 use std::net::SocketAddr;
@@ -11,11 +11,6 @@ pub struct Settings {
     pub id: u8,
     pub server: Endpoint,
     pub bind: SocketAddr,
-    // pub TIMEOUT: u32,
-    // pub history: usize,
-    // pub INTERVAL: u64,
-    // pub table: u16,
-    // pub proto: u16,
 }
 
 #[derive(Deserialize)]
@@ -34,9 +29,7 @@ impl TryFrom<String> for Endpoint {
             return Err(format!("Invalid endpoint format: {}", value));
         }
 
-        let port = parts[0]
-            .parse::<u16>()
-            .map_err(|e| format!("Invalid port: {}", e))?;
+        let port = parts[0].parse::<u16>().map_err(|e| format!("Invalid port: {}", e))?;
         let host = parts[1].to_string();
 
         Ok(Endpoint { host, port })
@@ -44,19 +37,13 @@ impl TryFrom<String> for Endpoint {
 }
 
 impl Endpoint {
-    pub async fn to_socket_addrs(
-        &self,
-        resolver: &Resolver<GenericConnector<TokioRuntimeProvider>>,
-    ) -> anyhow::Result<SocketAddr> {
+    pub async fn to_socket_addrs(&self, resolver: &Resolver<GenericConnector<TokioRuntimeProvider>>) -> anyhow::Result<SocketAddr> {
         let lookup = resolver.lookup_ip(&self.host).await?;
-        let ip = lookup
-            .into_iter()
-            .next()
-            .ok_or_else(|| anyhow::anyhow!("No IP address found for host"))?;
+        let ip = lookup.into_iter().next().ok_or_else(|| anyhow::anyhow!("No IP address found for host"))?;
         Ok(SocketAddr::new(ip, self.port))
     }
 }
 
 pub const INTERVAL: Duration = Duration::from_secs(1);
-pub const TIMEOUT: Duration = Duration::from_secs(60);
+pub const LEARN: Duration = Duration::from_secs(10);
 pub const ROUTE_PROTOCOL: RouteProtocol = RouteProtocol::Other(252);