chore: print relay and p2p status

Author: ICKelin

src/client/main.rs

@@ -1,8 +1,9 @@
 use clap::Parser;
 use std::sync::Arc;
-
+use std::time::Duration;
+use tokio::time::interval;
 use crate::client::{Args, DEFAULT_MTU, P2P_UDP_PORT};
-use crate::client::relay::{ClientHandler, new_relay_handler};
+use crate::client::relay::{RelayHandler, new_relay_handler};
 use crate::client::peer::{PeerHandler};
 use crate::client::prettylog::{log_startup_banner};
 use crate::codec::frame::{DataFrame, Frame, HandshakeReplyFrame};
@@ -93,10 +94,11 @@ fn init_device(device_config: &HandshakeReplyFrame) -> crate::Result<DeviceHandl
 }
 
 async fn run_event_loop(
-    client_handler: &mut ClientHandler,
+    client_handler: &mut RelayHandler,
     peer_handler: &mut Option<PeerHandler>,
     dev: &mut DeviceHandler,
 ) {
+    let mut exporter_ticker = interval(Duration::from_secs(30));
     loop {
         // Build select branches based on whether P2P is enabled
         if let Some(peer_handler) = peer_handler {
@@ -163,6 +165,9 @@ async fn run_event_loop(
                         }
                     }
                 }
+                _ = exporter_ticker.tick() => {
+                    get_status(client_handler, Some(peer_handler)).await;
+                }
             }
         } else {
             // P2P disabled: relay only
@@ -186,7 +191,66 @@ async fn run_event_loop(
                         }
                     }
                 }
+                _ = exporter_ticker.tick() => {
+                    get_status(client_handler, None).await;
+                }
             }
         }
     }
 }
+
+async fn get_status(relay: &RelayHandler, peer: Option<&PeerHandler>) {
+    println!("\n╔══════════════════════════════════════════════════════════════════════╗");
+    println!("║                        CONNECTION STATUS                             ║");
+    println!("╚══════════════════════════════════════════════════════════════════════╝");
+    
+    // Relay Status
+    let relay_status = relay.get_status();
+    println!("\n📡 Relay Connection (TCP)");
+    println!("   ├─ RX Frames:  {} (Errors: {})", relay_status.rx_frame, relay_status.rx_error);
+    println!("   └─ TX Frames:  {} (Errors: {})", relay_status.tx_frame, relay_status.tx_error);
+    
+    // P2P Status
+    if let Some(peer_handler) = peer {
+        let peer_status = peer_handler.get_status().await;
+        
+        if peer_status.is_empty() {
+            println!("\n🔗 P2P Connections (UDP)");
+            println!("   └─ No peers configured");
+        } else {
+            println!("\n🔗 P2P Connections (UDP): {} peers", peer_status.len());
+            
+            for (idx, status) in peer_status.iter().enumerate() {
+                let is_last = idx == peer_status.len() - 1;
+                let prefix = if is_last { "└─" } else { "├─" };
+                
+                // Format connection state
+                let state = match (&status.addr, &status.last_active) {
+                    (None, _) => "❌ Unknown Address".to_string(),
+                    (Some(_), None) => "⏳ Connecting...".to_string(),
+                    (Some(_), Some(last)) => {
+                        let elapsed = last.elapsed().as_secs();
+                        if elapsed < 15 {
+                            format!("✅ Active ({}s ago)", elapsed)
+                        } else {
+                            format!("⚠️  Inactive ({}s ago)", elapsed)
+                        }
+                    }
+                };
+                
+                // Format address
+                let addr_str = status.addr
+                    .map(|a| format!("{}", a))
+                    .unwrap_or_else(|| "N/A".to_string());
+                
+                println!("   {} Peer: {}", prefix, status.identity);
+                println!("   {}    Address: {}", if is_last { " " } else { "│" }, addr_str);
+                println!("   {}    Status:  {}", if is_last { " " } else { "│" }, state);
+            }
+        }
+    } else {
+        println!("\n🔗 P2P Mode: Disabled");
+    }
+    
+    println!();
+}

src/client/peer.rs

@@ -165,6 +165,40 @@ struct PeerMeta {
     last_active: Option<Instant>,
 }
 
+/// Peer connection status information
+///
+/// Provides a snapshot of a peer's current connection state including
+/// its identity, resolved address, and last activity timestamp.
+///
+/// # Usage
+/// Used by `PeerHandler::get_status()` to report the health and connectivity
+/// state of all configured P2P peers. Useful for monitoring, debugging,
+/// and displaying connection status to users.
+///
+/// # Fields
+/// * `identity` - Unique identifier of the peer
+/// * `addr` - Resolved socket address for P2P communication (None if unknown)
+/// * `last_active` - Timestamp of last received packet (None if never connected)
+#[derive(Debug)]
+pub struct PeerStatus {
+    /// Unique identifier of the peer
+    pub identity: String,
+    
+    /// Resolved socket address ([ipv6]:port or [ipv4]:port)
+    ///
+    /// - `None`: Address not yet known (peer behind NAT, waiting for first packet)
+    /// - `Some(addr)`: Known address, either from configuration or learned dynamically
+    pub addr: Option<SocketAddr>,
+    
+    /// Timestamp of last received packet from this peer
+    ///
+    /// - `None`: No packets received yet (connection not established)
+    /// - `Some(instant)`: Last successful communication time
+    ///
+    /// Connection is considered active if `Instant::now() - last_active < 15s`
+    pub last_active: Option<Instant>,
+}
+
 /// Peer connection manager for P2P communication
 ///
 /// Manages a collection of peer connections and handles:
@@ -483,12 +517,11 @@ impl PeerHandler {
                 .await
                 .ok_or("recv from peers channel closed")?;
 
-            self.update_peer_active(remote).await;
             let (frame, _) = Parser::unmarshal(&buf, self.block.as_ref())?;
 
             match frame {
                 Frame::KeepAlive(ka) => {
-                    tracing::debug!("Received keepalive from peer {} at {}", ka.identity, remote);
+                    tracing::info!("Received keepalive from peer {} at {}", ka.identity, remote);
 
                     // Update peer address and last_active based on keepalive identity
                     // This enables address learning for peers behind NAT
@@ -505,10 +538,12 @@ impl PeerHandler {
                         peer.remote_addr = Some(remote);
                         peer.last_active = Some(Instant::now());
                     }
-                    
-                    continue; // Skip keepalive, receive next frame
+
+                    // Dont need to reply
+                    continue;
                 }
                 _ => {
+                    self.update_peer_active(remote).await;
                     return Ok(frame);
                 }
             }
@@ -540,7 +575,6 @@ impl PeerHandler {
             let peers = self.peers.read().await;
             let peer = self.find_peer_by_ip_locked(&peers, dest_ip)
                 .ok_or("No peer found for destination")?;
-            
             (peer.identity.clone(), peer.remote_addr, peer.last_active)
         };
 
@@ -662,4 +696,18 @@ impl PeerHandler {
             }
         }
     }
+
+    pub async fn get_status(&self) -> Vec<PeerStatus> {
+        let guard = self.peers.read().await;
+        let mut result: Vec<PeerStatus> = Vec::new();
+        for peer in guard.values() {
+            let status = PeerStatus {
+                identity: peer.identity.clone(),
+                addr: peer.remote_addr,
+                last_active: peer.last_active,
+            };
+            result.push(status);
+        }
+        result
+    }
 }

src/client/prettylog.rs

@@ -21,11 +21,11 @@ pub fn log_handshake_success(config: &HandshakeReplyFrame) {
     println!("Gateway: {}", config.gateway);
     println!("IPv6: {}", config.ipv6);
     println!("Peer nodes: {}", config.others.len());
-
     if !config.others.is_empty() {
         for (idx, peer) in config.others.iter().enumerate() {
             println!("  [{}] Identity: {}", idx + 1, peer.identity);
             println!("      Private IP: {}", peer.private_ip);
+            println!("      IPv6: {}", peer.ipv6);
             println!("      CIDR ranges: {}", peer.ciders.join(", "));
         }
     }

src/client/relay.rs

@@ -170,21 +170,43 @@ impl RelayClient {
     }
 }
 
-pub struct ClientHandler {
+#[derive(Clone)]
+#[derive(Debug)]
+pub struct RelayStatus {
+    pub rx_error: u64,
+    pub rx_frame: u64,
+    pub tx_frame: u64,
+    pub tx_error: u64,
+}
+
+impl Default for RelayStatus {
+    fn default() -> Self {
+        Self{
+            rx_error: 0,
+            tx_error: 0,
+            rx_frame: 0,
+            tx_frame: 0,
+        }
+    }
+}
+
+pub struct RelayHandler {
     outbound_tx: Option<mpsc::Sender<Frame>>,
     inbound_rx: mpsc::Receiver<Frame>,
     inbound_tx: mpsc::Sender<Frame>,
     block: Arc<Box<dyn Block>>,
+    metrics: RelayStatus,
 }
 
-impl ClientHandler {
-    pub fn new(block: Arc<Box<dyn Block>>) -> ClientHandler {
+impl RelayHandler {
+    pub fn new(block: Arc<Box<dyn Block>>) -> RelayHandler {
         let (inbound_tx, inbound_rx) = mpsc::channel(10);
-        ClientHandler {
+        RelayHandler {
             outbound_tx: None,
             inbound_rx,
             inbound_tx,
             block,
+            metrics: Default::default(),
         }
     }
 
@@ -231,28 +253,44 @@ impl ClientHandler {
     }
 
     pub async fn send_frame(&mut self, frame: Frame) -> crate::Result<()> {
+        self.metrics.tx_frame += 1;
         let outbound_tx = match self.outbound_tx.clone() {
             Some(tx) => tx,
-            None => {return Err("relay connection disconnect".into())}
+            None => {
+                self.metrics.tx_error += 1;
+                return Err("relay connection disconnect".into())}
         };
 
         let result = outbound_tx.send(frame).await;
         match result {
             Ok(()) => Ok(()),
-            Err(e) => Err(format!("device=> server fail {:?}", e).into()),
+            Err(e) => {
+                self.metrics.tx_error += 1;
+                Err(format!("device=> server fail {:?}", e).into())
+            },
         }
     }
 
     pub async fn recv_frame(&mut self) -> crate::Result<Frame> {
         let result = self.inbound_rx.recv().await;
         match result {
-            Some(frame) => Ok(frame),
-            None => Err("server => device fail for closed channel".into()),
+            Some(frame) => {
+                self.metrics.rx_frame += 1;
+                Ok(frame)
+            },
+            None => {
+                self.metrics.rx_error += 1;
+                Err("server => device fail for closed channel".into())
+            },
         }
     }
+
+    pub fn get_status(&self) -> RelayStatus {
+        self.metrics.clone()
+    }
 }
 
-pub async fn new_relay_handler(args: &Args, block: Arc<Box<dyn Block>>)->crate::Result<(ClientHandler, HandshakeReplyFrame)> {
+pub async fn new_relay_handler(args: &Args, block: Arc<Box<dyn Block>>)->crate::Result<(RelayHandler, HandshakeReplyFrame)> {
     let ipv6 = utils::get_ipv6().unwrap_or("".to_string());
     let client_config = RelayClientConfig {
         server_addr: args.server.clone(),
@@ -264,7 +302,7 @@ pub async fn new_relay_handler(args: &Args, block: Arc<Box<dyn Block>>)->crate::
         port: P2P_UDP_PORT,
     };
 
-    let mut handler = ClientHandler::new(block);
+    let mut handler = RelayHandler::new(block);
     let (config_ready_tx, mut config_ready_rx) = mpsc::channel(CONFIG_CHANNEL_SIZE);
     handler.run_client(client_config, config_ready_tx);
 

src/utils/device.rs

@@ -67,7 +67,7 @@ impl Device {
                 }
                 packet = self.outbound_rx.recv() => {
                     if let Some(packet) = packet {
-                        tracing::info!("server => device {} bytes", packet.len());
+                        tracing::debug!("server => device {} bytes", packet.len());
                         let result = dev.write(packet.as_slice()).await;
                         if let Err(e) = result {
                             tracing::error!("write device fail: {:?}", e);
@@ -129,7 +129,7 @@ impl DeviceHandler {
                 return Err("device handler send none".into());
             }
         };
-        tracing::info!("device => server outbound tx len: {}", packet.len());
+        tracing::debug!("device => server outbound tx len: {}", packet.len());
         let result = outbound_tx.send(packet).await;
         match result {
             Ok(_) => Ok(()),

src/utils/mod.rs

@@ -30,7 +30,6 @@ pub fn get_ipv6() -> Option<String> {
 
     for api in &apis {
         if let Ok(ipv6) = fetch_ipv6_from_url(api) {
-            tracing::info!("Retrieved public IPv6 from {}: {}", api, ipv6);
             return Some(ipv6);
         }
     }