connection

src/connection.rs

+use serde_derive::Deserialize;
+
+#[derive(Deserialize)]
+pub(crate) struct Connection {
+    pub metric: u32,
+    pub protocol: Schema,
+}
+#[derive(Deserialize)]
+pub(crate) enum Schema {
+    IP,
+    UDP,
+    TCP,
+}

src/main.rs

+use crate::connection::Connection;
 use crate::data::Router as RouterData;
 use crate::protocol::{Change, Hello, Report};
 use crate::router::Router;
@@ -11,6 +12,7 @@ use std::time::SystemTime;
 use tokio::net::UdpSocket;
 use tokio::time;
 
+mod connection;
 mod data;
 mod gateway_group;
 mod protocol;
@@ -31,6 +33,10 @@ async fn main() -> anyhow::Result<()> {
         .iter()
         .map(|r| (r.id, Router::new(r, &config)))
         .collect();
+
+    let connections = serde_json::from_slice::<HashMap<u8, HashMap<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(
@@ -79,17 +85,19 @@ async fn main() -> anyhow::Result<()> {
                 // to clients
                 hello.time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?.as_millis() as u16;
                 let message = bincode::encode_to_vec(&hello, bincode::config::standard())?;
-                for peer in routers.values() {
-                    let _ = socket.send_to(message.as_slice(), peer.link_address);
+                for id in connections[&config.id].keys() {
+                    let router = &routers[id];
+                    let _ = socket.send_to(message.as_slice(), router.link_address);
                 }
 
                 // to server
                 let report = Report {
                     id: config.id,
                     ack: server.ack,
-                    peers: routers
-                        .values_mut()
-                        .map(|peer| peer.update(hello.time))
+                    peers: connections
+                        .iter()
+                        .filter(|(_, to)| to.contains_key(&config.id))
+                        .map(|(from,_)|routers.get_mut(from).unwrap().update(hello.time))
                         .collect(),
                 };
                 let message = bincode::encode_to_vec(&report, bincode::config::standard())?;