cors

Cargo.lock

@@ -635,6 +635,7 @@ dependencies = [
  "serde",
  "serde_json",
  "tokio",
+ "tower-http",
 ]
 
 [[package]]
@@ -906,6 +907,20 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tower-http"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "http",
+ "pin-project-lite",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "tower-layer"
 version = "0.3.3"

Cargo.toml

@@ -13,3 +13,4 @@ tokio = { version = "1.48", features = ["full"] }
 anyhow = "1.0.100"
 axum = { version = "0.8.7", features = ["macros"] }
 bincode = "2.0.1"
+tower-http = { version = "0.6.8", features = ["cors"] }

src/api.rs

-use axum::{routing::get, Json};
+use axum::{Json, routing::get};
 use serde::Serialize;
 use std::collections::BTreeMap;
 use std::sync::Arc;
@@ -6,6 +6,7 @@ use tokio::sync::RwLock;
 
 use crate::data::{ConnectionData, RouterData};
 use crate::router::Router;
+use tower_http::cors::CorsLayer;
 
 #[derive(Serialize, Clone)]
 pub struct Info {
@@ -17,4 +18,5 @@ pub fn create_app(routers: Arc<Vec<RouterData>>, connections: Arc<BTreeMap<u8, B
     axum::Router::new()
         .route("/info", get(|| async move { Json(Info { routers, connections }) }))
         .route("/metrics", get(|| async move { Json(routers2.read().await.clone()) }))
+        .layer(CorsLayer::permissive())
 }

src/main.rs

@@ -2,10 +2,11 @@ use crate::api::create_app;
 use crate::data::RouterData;
 use crate::protocol::{Change, Report};
 use crate::router::Router;
-use crate::settings::{Settings, INTERVAL, TIMEOUT};
-use anyhow::Result;
+use crate::settings::{INTERVAL, Settings, TIMEOUT};
 use ::config::Config;
+use anyhow::Result;
 use config::Environment;
+use serde::Serialize;
 use std::collections::BTreeMap;
 use std::sync::Arc;
 use tokio::net::UdpSocket;
@@ -21,7 +22,7 @@ mod quality;
 mod router;
 mod settings;
 
-#[derive(Default)]
+#[derive(Default, Serialize)]
 pub struct UpdatingState {
     router_id: u8,
     change: Change,
@@ -73,16 +74,16 @@ 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())
-                {
+                if let Ok((report, _)) = bincode::decode_from_slice::<Report, _>(&buf[..len], bincode::config::standard()) {
+                    println!("{}", serde_json::to_string(&report)?);
                     let mut routers = routers.write().await;
-                     if let Some(router) = routers.get_mut(&report.id) {
+                    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)?);
                             let len = bincode::encode_into_slice(change, &mut buf, bincode::config::standard())?;
                             let _ = socket.send_to(&buf[..len], addr).await;
                         }
-                     }
+                    }
                 }
             }
 
@@ -107,6 +108,7 @@ async fn main() -> Result<()> {
                     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)?);
                         let len = bincode::encode_into_slice(&updating.change, &mut buf, bincode::config::standard())?;
                         let _ = socket.send_to(&buf[..len], router.addr.unwrap()).await;
                     }

src/protocol.rs

 use bincode::{Decode, Encode};
+use serde::Serialize;
 use std::collections::BTreeMap;
 
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Serialize)]
 pub struct Report {
     pub id: u8,
     pub ack: u8,
@@ -9,14 +10,14 @@ pub struct Report {
     pub peers: Vec<PeerQuality>,
 }
 
-#[derive(Encode, Decode, Copy, Clone, serde::Serialize)]
+#[derive(Encode, Decode, Copy, Clone, Serialize)]
 pub struct PeerQuality {
     pub delay: i16,
     pub reliability: u8,
     pub jitter: u8,
 }
 
-#[derive(Encode, Decode, Default)]
+#[derive(Encode, Decode, Default, Serialize)]
 pub struct Change {
     pub seq: u8,
     pub rst: bool,

src/router.rs

@@ -133,7 +133,7 @@ impl Router {
             let current = candidate.iter().find(|(v, _)| v.id == *self.via.get(&to.id).expect(""));
             let (best_router, best_metric) = candidate.iter().min_by_key(|(_, m)| m).unwrap();
 
-            if current.is_none_or(|(current_router, current_metric)| current_router != best_router && best_metric + THROTTLE < *current_metric) {
+            if current.is_none_or(|(current_router, current_metric)| current_router != best_router && *best_metric != i32::MAX && *best_metric + THROTTLE < *current_metric) {
                 changed_via.insert(to.id, best_router.id);
                 metric.insert(to.id, *best_metric);
             }