fix

src/main.rs

@@ -23,23 +23,15 @@ use hickory_resolver::Resolver;
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     tracing_subscriber::fmt::init();
-    let config: Settings = Config::builder()
-        .add_source(config::Environment::default())
-        .build()?
-        .try_deserialize()?;
-    let routers_data =
-        serde_json::from_slice::<Vec<RouterData>>(&fs::read("import/data/Router.json")?)?;
-    let mut routers: BTreeMap<u8, Router> = routers_data
-        .iter()
-        .map(|r| (r.id, Router::new(r, &config)))
-        .collect();
-    let connections = serde_json::from_slice::<BTreeMap<u8, BTreeMap<u8, Connection>>>(&fs::read(
-        "import/connections.json",
-    )?)?;
+    let config: Settings = Config::builder().add_source(config::Environment::default()).build()?.try_deserialize()?;
+    let routers_data = serde_json::from_slice::<Vec<RouterData>>(&fs::read("import/data/Router.json")?)?;
+    let mut routers: BTreeMap<u8, Router> = routers_data.iter().map(|r| (r.id, Router::new(r, &config))).collect();
+    let connections = serde_json::from_slice::<BTreeMap<u8, BTreeMap<u8, Connection>>>(&fs::read("import/connections.json")?)?;
     // let groups: Vec<GatewayGroup> = serde_json::from_slice(&fs::read("import/GatewayGroup.json")?)?;
 
     let mut server = Server::new(
-        // &routers,
+        config.id,
+        &routers,
         // groups
         //     .iter()
         //     .map(|g| (g.id, g.routers(&groups, &routers_data)))
@@ -69,7 +61,7 @@ async fn main() -> anyhow::Result<()> {
                     peer.on_message(&hello);
                 } else if addr.port() == config.server.port
                     && let Ok((downlink, _)) = bincode::decode_from_slice(&buf[..len], bincode::config::standard())
-                    && let Some(uplink) = server.on_message(&downlink, &routers_data, &connections[&config.id], &config).await
+                    && let Some(uplink) = server.on_message(downlink, &routers_data, &connections[&config.id], &config).await
                 {
                     let len = bincode::encode_into_slice(uplink, &mut buf, bincode::config::standard())?;
                     let _ = socket.send_to(&buf[..len], addr).await;

src/server.rs

 use crate::protocol::{Downlink, MessageType, Uplink};
+use crate::router::Router;
 use crate::settings::Settings;
 use crate::{connection::Connection, data};
-use netlink_sys::{Socket, TokioSocket, protocols::NETLINK_ROUTE};
+use netlink_sys::{protocols::NETLINK_ROUTE, Socket, TokioSocket};
 use std::collections::BTreeMap;
 use std::os::unix::io::{AsRawFd, FromRawFd};
 
@@ -14,7 +15,7 @@ pub struct Server {
 }
 
 impl Server {
-    pub fn new() -> Self {
+    pub fn new(id: u8, routers: &BTreeMap<u8, Router>) -> Self {
         let socket = std::mem::ManuallyDrop::new(Socket::new(NETLINK_ROUTE).unwrap());
         socket.set_netlink_get_strict_chk(true).unwrap();
         let socket = unsafe { TokioSocket::from_raw_fd(socket.as_raw_fd()) };
@@ -23,7 +24,7 @@ impl Server {
         Server {
             online: false,
             version: rand::random(),
-            via: Default::default(),
+            via: routers.keys().filter(|&&i| i != id).map(|&i| (i, i)).collect(),
             plan: Default::default(),
             handle,
         }
@@ -31,17 +32,13 @@ impl Server {
 
     pub async fn on_message(
         &mut self,
-        message: &Downlink,
+        mut message: Downlink,
         routers: &Vec<data::Router>,
         connections: &BTreeMap<u8, Connection>,
         config: &Settings, // routers: &mut HashMap<u8, Router>,
                            // self_peer: &Hello,
     ) -> Option<Uplink> {
-        tracing::info!(
-            "server message {:?}, version = {}",
-            message,
-            message.version
-        );
+        tracing::info!("server message {:?}, version = {}", message, message.version);
         if message.ack != self.version {
             return None;
         }
@@ -51,7 +48,8 @@ impl Server {
             (false, MessageType::Full) => {
                 self.reset(routers, connections, config).await;
                 self.online = true;
-                // TODO: apply via and plan
+                self.via.append(&mut message.via);
+                self.plan.append(&mut message.plan);
                 Some(Uplink {
                     id: config.id,
                     action: MessageType::Update,
@@ -69,25 +67,23 @@ impl Server {
                 via: self.via.clone(),
                 plan: self.plan.clone(),
             }),
-            (true, MessageType::Update) => Some(Uplink {
-                id: config.id,
-                action: MessageType::Update,
-                version: self.version,
-                peers: Default::default(),
-                via: Default::default(),
-                plan: Default::default(),
-                // TODO: apply via and plan
-            }),
+            (true, MessageType::Update) => {
+                self.via.append(&mut message.via);
+                self.plan.append(&mut message.plan);
+                Some(Uplink {
+                    id: config.id,
+                    action: MessageType::Update,
+                    version: self.version,
+                    peers: Default::default(),
+                    via: Default::default(),
+                    plan: Default::default(),
+                })
+            }
             _ => None,
         }
     }
 
-    pub async fn reset(
-        &self,
-        routers: &Vec<data::Router>,
-        connections: &BTreeMap<u8, Connection>,
-        config: &Settings,
-    ) {
+    pub async fn reset(&self, routers: &Vec<data::Router>, connections: &BTreeMap<u8, Connection>, config: &Settings) {
         println!("reset");
         // let mut routes = self.handle.route().get(RouteMessageBuilder::<Ipv4Addr>::new().protocol(ROUTE_PROTOCOL).build()).execute();
         // while let Some(route) = routes.try_next().await.unwrap() {