core engine rewrite and client side changes

client/src/tun/device.rs

@@ -6,9 +6,11 @@ use std::{
         Arc, LazyLock, Mutex,
         atomic::{AtomicBool, Ordering},
     },
+    time::Instant as StdInstant, // Добавлено для расчёта скорости
 };
 
 use bytes::BytesMut;
+use netrunner_logger::info; // Предполагается, что у тебя есть этот логгер
 use smoltcp::{
     phy::{self, Device, DeviceCapabilities},
     time::Instant,
@@ -18,6 +20,17 @@ use tokio::sync::mpsc;
 const TOKEN_BUFFER_LIST_MAX_SIZE: usize = 64;
 static TOKEN_BUFFER_LIST: LazyLock<Mutex<Vec<BytesMut>>> = LazyLock::new(|| Mutex::new(Vec::new()));
 
+// Структура, которую мы будем возвращать пользователю
+#[derive(Debug, Clone, Copy)]
+pub struct TrafficStats {
+    pub rx_bytes: u64,
+    pub tx_bytes: u64,
+    pub rx_packets: u64,
+    pub tx_packets: u64,
+    pub rx_speed_mb_s: f64,
+    pub tx_speed_mb_s: f64,
+}
+
 pub struct TokenBuffer {
     buffer: BytesMut,
 }
@@ -65,6 +78,22 @@ pub struct VirtTunDevice {
     rx_queue: mpsc::UnboundedReceiver<TokenBuffer>,
     tx_queue: mpsc::UnboundedSender<TokenBuffer>,
     rx_avail: Arc<AtomicBool>,
+
+    // === Статистика трафика ===
+    rx_bytes: u64,
+    tx_bytes: u64,
+    rx_packets: u64,
+    tx_packets: u64,
+
+    // Внутренние переменные для расчёта скорости
+    last_speed_calc: StdInstant,
+    last_rx_bytes: u64,
+    last_tx_bytes: u64,
+    cached_rx_speed: f64,
+    cached_tx_speed: f64,
+
+    // Для периодического логирования
+    last_log_time: StdInstant,
 }
 
 impl VirtTunDevice {
@@ -80,11 +109,26 @@ impl VirtTunDevice {
         let (from_smoltcp_tx, from_smoltcp_rx) = mpsc::unbounded_channel();
         let rx_avail = Arc::new(AtomicBool::new(false));
 
+        let now = StdInstant::now();
+
         let device = Self {
             capabilities,
             rx_queue: to_smoltcp_rx,
             tx_queue: from_smoltcp_tx,
             rx_avail: rx_avail.clone(),
+
+            rx_bytes: 0,
+            tx_bytes: 0,
+            rx_packets: 0,
+            tx_packets: 0,
+
+            last_speed_calc: now,
+            last_rx_bytes: 0,
+            last_tx_bytes: 0,
+            cached_rx_speed: 0.0,
+            cached_tx_speed: 0.0,
+
+            last_log_time: now,
         };
 
         (device, to_smoltcp_tx, from_smoltcp_rx, rx_avail)
@@ -94,6 +138,54 @@ impl VirtTunDevice {
     pub fn mark_rx_available(&self) {
         self.rx_avail.store(true, Ordering::Release);
     }
+
+    pub fn get_stats(&mut self) -> TrafficStats {
+        let now = StdInstant::now();
+        let elapsed_speed = now.duration_since(self.last_speed_calc).as_secs_f64();
+
+        if elapsed_speed >= 1.0 {
+            let rx_diff = self.rx_bytes.saturating_sub(self.last_rx_bytes);
+            let tx_diff = self.tx_bytes.saturating_sub(self.last_tx_bytes);
+
+            // Переводим в МегаБайты в секунду (MB/s)
+            self.cached_rx_speed = (rx_diff as f64 / 1_048_576.0) / elapsed_speed;
+            self.cached_tx_speed = (tx_diff as f64 / 1_048_576.0) / elapsed_speed;
+
+            self.last_rx_bytes = self.rx_bytes;
+            self.last_tx_bytes = self.tx_bytes;
+            self.last_speed_calc = now;
+        }
+
+        TrafficStats {
+            rx_bytes: self.rx_bytes,
+            tx_bytes: self.tx_bytes,
+            rx_packets: self.rx_packets,
+            tx_packets: self.tx_packets,
+            rx_speed_mb_s: self.cached_rx_speed,
+            tx_speed_mb_s: self.cached_tx_speed,
+        }
+    }
+
+    /// Внутренний метод проверки таймера для вывода логов
+    fn check_and_log_stats(&mut self) {
+        let now = StdInstant::now();
+        // Логируем каждые 5 секунд
+        if now.duration_since(self.last_log_time).as_secs() >= 5 {
+            let stats = self.get_stats(); // Заодно обновляем скорости
+
+            info!(
+                "TunDevice Traffic: RX: {:.2} MB ({} pkts) | TX: {:.2} MB ({} pkts) | Speed: ↓{:.2} MB/s, ↑{:.2} MB/s",
+                stats.rx_bytes as f64 / 1_048_576.0,
+                stats.rx_packets,
+                stats.tx_bytes as f64 / 1_048_576.0,
+                stats.tx_packets,
+                stats.rx_speed_mb_s,
+                stats.tx_speed_mb_s
+            );
+
+            self.last_log_time = now;
+        }
+    }
 }
 
 impl Device for VirtTunDevice {
@@ -101,7 +193,15 @@ impl Device for VirtTunDevice {
     type TxToken<'a> = VirtTxToken<'a>;
 
     fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+        // Проверяем, не пора ли записать стату в лог. receive() вызывается очень часто,
+        // поэтому это отличное место для heartbeat таймера.
+        self.check_and_log_stats();
+
         if let Ok(buffer) = self.rx_queue.try_recv() {
+            // Учет входящего трафика (DOWNLOAD)
+            self.rx_bytes += buffer.len() as u64;
+            self.rx_packets += 1;
+
             let rx = Self::RxToken {
                 buffer,
                 phantom_device: PhantomData,
@@ -147,8 +247,15 @@ impl phy::TxToken for VirtTxToken<'_> {
         unsafe {
             buffer.set_len(len);
         }
+
         let result = f(&mut buffer);
+
+        // Учет исходящего трафика (UPLOAD)
+        self.0.tx_bytes += len as u64;
+        self.0.tx_packets += 1;
+
         let _ = self.0.tx_queue.send(buffer);
+
         result
     }
 }