core engine rewrite and client side changes

core/src/proxy/connection/muxer.rs

@@ -1,10 +1,9 @@
 use crate::protocol::codec::frame::FrameType;
 use bytes::Bytes;
-use dashmap::DashMap; // Добавь в Cargo.toml: dashmap = "6.0"
+use dashmap::DashMap;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Arc;
-use tokio::sync::mpsc::error::SendError;
-use tokio::sync::mpsc::Sender;
+use tokio::sync::mpsc::{error::SendError, Sender};
 
 pub struct IdGenerator {
     counter: AtomicU32,
@@ -31,15 +30,21 @@ pub struct MuxMessage {
 
 #[derive(Clone)]
 pub struct Muxer {
-    to_network: Sender<MuxMessage>,
+    control_tx: Sender<MuxMessage>,
+    data_tx: Sender<MuxMessage>,
     streams: Arc<DashMap<u32, Sender<Bytes>>>,
     id_gen: Arc<IdGenerator>,
 }
 
 impl Muxer {
-    pub fn new(to_network: Sender<MuxMessage>, is_client: bool) -> Self {
+    pub fn new(
+        control_tx: Sender<MuxMessage>,
+        data_tx: Sender<MuxMessage>,
+        is_client: bool,
+    ) -> Self {
         Self {
-            to_network,
+            control_tx,
+            data_tx,
             streams: Arc::new(DashMap::new()),
             id_gen: Arc::new(IdGenerator::new(is_client)),
         }
@@ -49,30 +54,19 @@ impl Muxer {
         self.id_gen.next()
     }
 
+    // Обычные данные летят в канал с низким приоритетом
     pub async fn send_to_netwrok(&self, message: MuxMessage) -> Result<(), SendError<MuxMessage>> {
-        self.to_network.send(message).await
-    }
-
-    pub fn register_stream(&self, stream_id: u32, tx: Sender<Bytes>) {
-        self.streams.insert(stream_id, tx);
-        netrunner_logger::debug!(
-            stream_id,
-            total_active = self.streams.len(),
-            "MUXER: [REGISTER] Stream added"
-        );
-    }
-
-    pub fn remove_stream(&self, stream_id: u32) {
-        self.streams.remove(&stream_id);
+        self.data_tx.send(message).await
     }
 
+    // Управляющие фреймы летят в VIP-канал
     pub async fn send_control(
         &self,
         stream_id: u32,
         f_type: FrameType,
         data: Bytes,
     ) -> Result<(), String> {
-        self.to_network
+        self.control_tx
             .send(MuxMessage {
                 stream_id,
                 frame_type: f_type,
@@ -82,32 +76,31 @@ impl Muxer {
             .map_err(|e| e.to_string())
     }
 
+    pub fn register_stream(&self, stream_id: u32, tx: Sender<Bytes>) {
+        self.streams.insert(stream_id, tx);
+    }
+
+    pub fn remove_stream(&self, stream_id: u32) {
+        self.streams.remove(&stream_id);
+    }
+
     pub async fn dispatch_to_local(&self, stream_id: u32, data: Bytes) {
-        // DashMap позволяет получить доступ к элементу без явного RwLock
         let tx = self.streams.get(&stream_id).map(|r| r.value().clone());
 
         if let Some(tx) = tx {
-            if data.is_empty() {
-                netrunner_logger::debug!(stream_id, "MUXER: [EOF] Forwarding EOF to local handler");
-            } else {
-                netrunner_logger::trace!(
-                    stream_id,
-                    len = data.len(),
-                    "MUXER: [DISPATCH] Sending data"
-                );
-            }
-
             if let Err(_e) = tx.send(data).await {
-                netrunner_logger::debug!(
+                netrunner_logger::warn!(
                     stream_id,
-                    "MUXER: [WARN] Local channel closed, dropping packet"
+                    "MUXER: [INBOUND_ERR] Local channel closed, dropping packet"
                 );
                 self.remove_stream(stream_id);
             }
         } else {
+            // Уменьшил уровень лога до TRACE, потому что это штатная ситуация при больших буферах!
             netrunner_logger::trace!(
                 stream_id,
-                "MUXER: [IGNORE] Packet for already closed stream"
+                len = data.len(),
+                "MUXER: [IGNORE] Received data for already closed stream (draining pipe)"
             );
         }
     }