slim-bindings 0.6.1__tar.gz → 0.6.3__tar.gz

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slim-bindings
-Version: 0.6.1
+Version: 0.6.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/datapath/src/message_processing.rs

@@ -262,30 +262,36 @@ impl MessageProcessor {
             .await
     }
 
-    pub fn disconnect(&self, conn: u64) -> Result<(), DataPathError> {
-        match self.forwarder().get_connection(conn) {
+    pub fn disconnect(&self, conn: u64) -> Result<ClientConfig, DataPathError> {
+        let connection = match self.forwarder().get_connection(conn) {
+            Some(c) => c,
             None => {
                 error!("error handling disconnect: connection unknown");
                 return Err(DataPathError::DisconnectionError(
                     "connection not found".to_string(),
                 ));
             }
-            Some(c) => {
-                match c.cancellation_token() {
-                    None => {
-                        error!("error handling disconnect: missing cancellation token");
-                    }
-                    Some(t) => {
-                        // here token cancel will stop the receiving loop on
-                        // conn and this will cause the delition of the state
-                        // for this connection
-                        t.cancel();
-                    }
-                }
+        };
+
+        let token = match connection.cancellation_token() {
+            Some(t) => t,
+            None => {
+                error!("error handling disconnect: missing cancellation token");
+                return Err(DataPathError::DisconnectionError(
+                    "missing cancellation token".to_string(),
+                ));
             }
-        }
+        };
+
+        // Cancel receiving loop; this triggers deletion of connection state.
+        token.cancel();
 
-        Ok(())
+        connection
+            .config_data()
+            .cloned()
+            .ok_or(DataPathError::DisconnectionError(
+                "missing client config data".to_string(),
+            ))
     }
 
     pub fn register_local_connection(

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/datapath/tests/data_path_test.rs

@@ -147,6 +147,71 @@ mod tests {
         assert!(logs_contain(expected_msg));
     }
 
+    #[tokio::test]
+    #[traced_test]
+    async fn test_disconnection() {
+        // setup server from configuration
+        let mut server_conf = ServerConfig::with_endpoint("127.0.0.1:50052");
+        server_conf.tls_setting.insecure = true;
+
+        let (processor, _signal) = MessageProcessor::new();
+        let svc = Arc::new(processor);
+        let msg_processor = svc.clone();
+
+        let ep_server = server_conf
+            .to_server_future(&[DataPlaneServiceServer::from_arc(svc)])
+            .unwrap();
+
+        tokio::spawn(async move {
+            if let Err(e) = ep_server.await {
+                panic!("Server error: {:?}", e);
+            }
+        });
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+        // create a client config we will attach to the connection
+        let mut client_config = ClientConfig::with_endpoint("http://127.0.0.1:50052");
+        client_config.tls_setting.insecure = true;
+        let channel = client_config.to_channel().unwrap();
+
+        // connect with client_config Some(...)
+        let (_, conn_index) = msg_processor
+            .connect(
+                channel,
+                Some(client_config.clone()),
+                None,
+                Some(SocketAddr::from(([127, 0, 0, 1], 50052))),
+            )
+            .await
+            .expect("error creating channel");
+
+        // ensure connection exists before disconnect
+        assert!(
+            msg_processor
+                .connection_table()
+                .get(conn_index as usize)
+                .is_some()
+        );
+
+        // disconnect (should cancel stream and eventually remove connection)
+        let _returned_cfg = msg_processor
+            .disconnect(conn_index)
+            .expect("disconnect should return client config");
+
+        // wait for cancellation to propagate and stream task to drop connection
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+
+        // after disconnect the connection should be removed
+        assert!(
+            msg_processor
+                .connection_table()
+                .get(conn_index as usize)
+                .is_none(),
+            "connection should be removed after disconnect"
+        );
+    }
+
     fn make_message(org: &str, ns: &str, name: &str) -> Message {
         let source = Name::from_strings([org, ns, name]).with_id(0);
         let name = Name::from_strings([org, ns, name]).with_id(1);

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/service/src/app.rs

@@ -296,6 +296,11 @@ where
                                             .await;
 
                                         if let Err(e) = res {
+                                            // Ignore errors due to subscription not found
+                                            if let SessionError::SubscriptionNotFound(_) = e {
+                                                debug!("session not found, ignoring message");
+                                                continue;
+                                            }
                                             error!("error handling message: {}", e);
                                         }
                                     }

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/service/src/service.rs

@@ -344,9 +344,27 @@ impl Service {
     pub fn disconnect(&self, conn: u64) -> Result<(), ServiceError> {
         info!("disconnect from conn {}", conn);
 
-        self.message_processor
-            .disconnect(conn)
-            .map_err(|e| ServiceError::DisconnectError(e.to_string()))
+        match self.message_processor.disconnect(conn) {
+            Ok(cfg) => {
+                let endpoint = cfg.endpoint.clone();
+                let mut clients = self.clients.write();
+                if let Some(stored_conn) = clients.get(&endpoint) {
+                    if *stored_conn == conn {
+                        clients.remove(&endpoint);
+                        info!("removed client mapping for endpoint {}", endpoint);
+                    } else {
+                        debug!(
+                            "client mapping endpoint {} has different conn_id {} != {}",
+                            endpoint, stored_conn, conn
+                        );
+                    }
+                } else {
+                    debug!("no client mapping found for endpoint {}", endpoint);
+                }
+                Ok(())
+            }
+            Err(e) => Err(ServiceError::DisconnectError(e.to_string())),
+        }
     }
 
     pub fn get_connection_id(&self, endpoint: &str) -> Option<u64> {
@@ -469,6 +487,62 @@ mod tests {
         assert!(logs_contain("shutting down server"));
     }
 
+    #[tokio::test]
+    #[traced_test]
+    async fn test_service_disconnection() {
+        // create the service (server + one client we will disconnect)
+        let tls_config = TlsServerConfig::new().with_insecure(true);
+        let server_config =
+            ServerConfig::with_endpoint("0.0.0.0:12346").with_tls_settings(tls_config);
+        let config = ServiceConfiguration::new().with_server([server_config].to_vec());
+        let mut service = config
+            .build_server(ID::new_with_name(Kind::new(KIND).unwrap(), "test-disconnect").unwrap())
+            .unwrap();
+
+        service.run().await.expect("failed to run service");
+
+        // wait a bit for server loop to start
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        // build client configuration and connect
+        let mut client_conf =
+            slim_config::grpc::client::ClientConfig::with_endpoint("http://0.0.0.0:12346");
+        client_conf.tls_setting.insecure = true;
+        let conn_id = service
+            .connect(&client_conf)
+            .await
+            .expect("failed to connect client");
+
+        assert!(service.get_connection_id(&client_conf.endpoint).is_some());
+
+        // disconnect
+        service
+            .disconnect(conn_id)
+            .expect("disconnect should succeed");
+
+        // allow cancellation token to propagate and stream to terminate
+        tokio::time::sleep(Duration::from_millis(200)).await;
+
+        // verify connection is removed from internal client mapping
+        assert!(
+            service.get_connection_id(&client_conf.endpoint).is_none(),
+            "client mapping should be removed after disconnect"
+        );
+
+        // verify connection is removed from connection table
+        assert!(
+            service
+                .message_processor
+                .connection_table()
+                .get(conn_id as usize)
+                .is_none(),
+            "connection should be removed after disconnect"
+        );
+
+        // verify disconnect log
+        assert!(logs_contain("disconnect from conn"));
+    }
+
     #[tokio::test]
     #[traced_test]
     async fn test_service_publish_subscribe() {

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/session/src/channel_endpoint.rs

@@ -2230,7 +2230,7 @@ mod tests {
     #[tokio::test]
     #[traced_test]
     async fn test_full_join_and_leave() {
-        let (tx_app, _) = tokio::sync::mpsc::channel(1);
+        let (tx_app, _) = tokio::sync::mpsc::unbounded_channel();
         let (moderator_tx, mut moderator_rx) = tokio::sync::mpsc::channel(50);
         let (participant_tx, mut participant_rx) = tokio::sync::mpsc::channel(50);
 

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/session/src/common.rs

@@ -16,9 +16,10 @@ pub const SESSION_RANGE: std::ops::Range<u32> = 0..(u32::MAX - 1000);
 pub const SESSION_UNSPECIFIED: u32 = u32::MAX;
 
 /// Channel used in the path service -> app
-pub(crate) type AppChannelSender = tokio::sync::mpsc::Sender<Result<Message, SessionError>>;
+pub(crate) type AppChannelSender =
+    tokio::sync::mpsc::UnboundedSender<Result<Message, SessionError>>;
 /// Channel used in the path app -> service
-pub type AppChannelReceiver = tokio::sync::mpsc::Receiver<Result<Message, SessionError>>;
+pub type AppChannelReceiver = tokio::sync::mpsc::UnboundedReceiver<Result<Message, SessionError>>;
 /// Channel used in the path service -> slim
 pub type SlimChannelSender = tokio::sync::mpsc::Sender<Result<Message, Status>>;
 

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/session/src/context.rs

@@ -174,7 +174,6 @@ mod tests {
             async move {
                 if let Some(tx) = tx {
                     tx.send(msg)
-                        .await
                         .map_err(|e| crate::SessionError::AppTransmission(e.to_string()))?;
                 }
                 Ok(())
@@ -216,7 +215,7 @@ mod tests {
     // Verifies that a newly created context can upgrade its Weak reference to a strong Arc
     // and exposes the expected session identity (id + type).
     async fn context_new_and_upgrade() {
-        let (tx_app, rx_app) = mpsc::channel(8);
+        let (tx_app, rx_app) = mpsc::unbounded_channel();
         let session = build_session_with_app_tx(1, tx_app);
         let ctx = SessionContext::new(session.clone(), rx_app);
         assert!(ctx.session_arc().is_some());
@@ -228,7 +227,7 @@ mod tests {
     // Validates spawn_receiver executes the provided closure on a background task and that
     // the Weak<Session> captured inside can still be upgraded while the original Arc exists.
     async fn context_spawn_receiver_runs_closure() {
-        let (tx_app, rx_app) = mpsc::channel(4);
+        let (tx_app, rx_app) = mpsc::unbounded_channel();
         let session = build_session_with_app_tx(3, tx_app);
         let ctx = SessionContext::new(session.clone(), rx_app);
         let flag = Arc::new(tokio::sync::Mutex::new(false));
@@ -246,7 +245,7 @@ mod tests {
     // After spawning the receiver, dropping the last strong Arc should allow the Weak to
     // observe session deallocation (upgrade returns None).
     async fn context_spawn_receiver_drops_session() {
-        let (tx_app, rx_app) = mpsc::channel(4);
+        let (tx_app, rx_app) = mpsc::unbounded_channel();
         let session = build_session_with_app_tx(4, tx_app);
         let ctx = SessionContext::new(session.clone(), rx_app);
         let weak = ctx.spawn_receiver(|_rx, s| async move {
@@ -265,7 +264,7 @@ mod tests {
     // Ensures the spawned receiver task (which only reads from rx) terminates once
     // the session (and implicitly, in real usage, the channel sender owned by it) is dropped.
     async fn context_spawn_receiver_task_finishes_on_session_drop() {
-        let (tx_app, rx_app) = mpsc::channel(4);
+        let (tx_app, rx_app) = mpsc::unbounded_channel();
         let session = build_session_with_app_tx(5, tx_app);
         let ctx = SessionContext::new(session.clone(), rx_app);
         let (done_tx, done_rx) = oneshot::channel();

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/session/src/errors.rs

@@ -21,6 +21,8 @@ pub enum SessionError {
     AppTransmission(String),
     #[error("error processing message: {0}")]
     Processing(String),
+    #[error("error sending message to session: {0}")]
+    QueueFullError(String),
     #[error("session id already used: {0}")]
     SessionIdAlreadyUsed(String),
     #[error("invalid session id: {0}")]

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/session/src/multicast.rs

@@ -249,7 +249,7 @@ where
         storage_path: std::path::PathBuf,
         tx_session: tokio::sync::mpsc::Sender<Result<SessionLayerMessage, SessionError>>,
     ) -> Self {
-        let (tx, rx) = mpsc::channel(128);
+        let (tx, rx) = mpsc::channel(256);
 
         let common = Common::new(
             id,
@@ -388,7 +388,8 @@ where
                                 }
                                 let (msg, direction) = result.unwrap();
 
-                                tracing::trace!("received message from SLIM {} {}", msg.get_session_message_type().as_str_name(), msg.get_id());
+                                tracing::trace!("received message {} {}", msg.get_session_message_type().as_str_name(), msg.get_id());
+
 
                                 // process the messages for the channel endpoint first
                                 match msg.get_session_header().session_message_type() {
@@ -687,11 +688,8 @@ async fn process_message_from_app<T>(
                 "error sending publication packet to slim on session {}",
                 session_id
             );
-            tx.send_to_app(Err(SessionError::Processing(
-                "error sending message to local slim instance".to_string(),
-            )))
-            .await
-            .expect("error notifying app");
+
+            // no need to notify app here, the session will take care of retransmissions
         }
 
         // set timer for this message
@@ -977,10 +975,9 @@ where
         message: Message,
         direction: MessageDirection,
     ) -> Result<(), SessionError> {
-        self.tx
-            .send(Ok((message, direction)))
-            .await
-            .map_err(|e| SessionError::Processing(e.to_string()))
+        self.tx.try_send(Ok((message, direction))).map_err(|e| {
+            SessionError::QueueFullError(format!("session={}, error={}", self.common.id(), e))
+        })
     }
 }
 
@@ -1060,7 +1057,7 @@ mod tests {
     #[traced_test]
     async fn test_multicast_create() {
         let (tx_slim, _) = tokio::sync::mpsc::channel(1);
-        let (tx_app, _) = tokio::sync::mpsc::channel(1);
+        let (tx_app, _) = tokio::sync::mpsc::unbounded_channel();
 
         let tx = SessionTransmitter {
             slim_tx: tx_slim.clone(),
@@ -1132,7 +1129,7 @@ mod tests {
     #[traced_test]
     async fn test_multicast_sender_and_receiver() {
         let (tx_slim_sender, mut rx_slim_sender) = tokio::sync::mpsc::channel(1);
-        let (tx_app_sender, _rx_app_sender) = tokio::sync::mpsc::channel(1);
+        let (tx_app_sender, _rx_app_sender) = tokio::sync::mpsc::unbounded_channel();
 
         let tx_sender = SessionTransmitter {
             slim_tx: tx_slim_sender,
@@ -1141,7 +1138,7 @@ mod tests {
         };
 
         let (tx_slim_receiver, _rx_slim_receiver) = tokio::sync::mpsc::channel(1);
-        let (tx_app_receiver, mut rx_app_receiver) = tokio::sync::mpsc::channel(1);
+        let (tx_app_receiver, mut rx_app_receiver) = tokio::sync::mpsc::unbounded_channel();
 
         let tx_receiver = SessionTransmitter {
             slim_tx: tx_slim_receiver,
@@ -1234,7 +1231,7 @@ mod tests {
     #[traced_test]
     async fn test_multicast_rtx_timeouts() {
         let (tx_slim, mut rx_slim) = tokio::sync::mpsc::channel(1);
-        let (tx_app, mut rx_app) = tokio::sync::mpsc::channel(1);
+        let (tx_app, mut rx_app) = tokio::sync::mpsc::unbounded_channel();
 
         let tx = SessionTransmitter {
             slim_tx: tx_slim,
@@ -1322,7 +1319,7 @@ mod tests {
     #[traced_test]
     async fn test_multicast_rtx_reception() {
         let (tx_slim, mut rx_slim) = tokio::sync::mpsc::channel(8);
-        let (tx_app, _rx_app) = tokio::sync::mpsc::channel(8);
+        let (tx_app, _rx_app) = tokio::sync::mpsc::unbounded_channel();
 
         let tx = SessionTransmitter {
             slim_tx: tx_slim,
@@ -1425,8 +1422,8 @@ mod tests {
     #[tokio::test]
     #[traced_test]
     async fn test_multicast_e2e_with_losses() {
-        let (tx_slim_sender, mut rx_slim_sender) = tokio::sync::mpsc::channel(1);
-        let (tx_app_sender, _rx_app_sender) = tokio::sync::mpsc::channel(1);
+        let (tx_slim_sender, mut rx_slim_sender) = tokio::sync::mpsc::channel(3);
+        let (tx_app_sender, _rx_app_sender) = tokio::sync::mpsc::unbounded_channel();
 
         let tx_sender = SessionTransmitter {
             slim_tx: tx_slim_sender,
@@ -1434,8 +1431,8 @@ mod tests {
             interceptors: Arc::new(parking_lot::RwLock::new(vec![])),
         };
 
-        let (tx_slim_receiver, mut rx_slim_receiver) = tokio::sync::mpsc::channel(1);
-        let (tx_app_receiver, mut rx_app_receiver) = tokio::sync::mpsc::channel(1);
+        let (tx_slim_receiver, mut rx_slim_receiver) = tokio::sync::mpsc::channel(3);
+        let (tx_app_receiver, mut rx_app_receiver) = tokio::sync::mpsc::unbounded_channel();
 
         let tx_receiver = SessionTransmitter {
             slim_tx: tx_slim_receiver,
@@ -1657,7 +1654,7 @@ mod tests {
     #[traced_test]
     async fn test_session_delete() {
         let (tx_slim, _) = tokio::sync::mpsc::channel(1);
-        let (tx_app, _) = tokio::sync::mpsc::channel(1);
+        let (tx_app, _) = tokio::sync::mpsc::unbounded_channel();
 
         let tx = SessionTransmitter {
             slim_tx: tx_slim,

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/session/src/point_to_point.rs

@@ -209,26 +209,34 @@ where
 #[async_trait]
 impl timer::TimerObserver for AckTimerObserver {
     async fn on_timeout(&self, message_id: u32, timeouts: u32) {
-        self.tx
+        let res = self
+            .tx
             .send(InternalMessage::TimerTimeout {
                 message_id,
                 timeouts,
                 ack: true,
             })
-            .await
-            .expect("failed to send timer timeout");
+            .await;
+
+        if let Err(e) = res {
+            error!("AckTimerObserver: failed to send timer timeout: {}", e);
+        }
     }
 
     async fn on_failure(&self, message_id: u32, timeouts: u32) {
         // remove the state for the lost message
-        self.tx
+        let res = self
+            .tx
             .send(InternalMessage::TimerFailure {
                 message_id,
                 timeouts,
                 ack: true,
             })
-            .await
-            .expect("failed to send timer failure");
+            .await;
+
+        if let Err(e) = res {
+            error!("AckTimerObserver: failed to send timer failure: {}", e);
+        }
     }
 
     async fn on_stop(&self, message_id: u32) {
@@ -239,26 +247,34 @@ impl timer::TimerObserver for AckTimerObserver {
 #[async_trait]
 impl timer::TimerObserver for RtxTimerObserver {
     async fn on_timeout(&self, message_id: u32, timeouts: u32) {
-        self.tx
+        let res = self
+            .tx
             .send(InternalMessage::TimerTimeout {
                 message_id,
                 timeouts,
                 ack: false,
             })
-            .await
-            .expect("failed to send timer timeout");
+            .await;
+
+        if let Err(e) = res {
+            error!("RtxTimerObserver: failed to send timer timeout: {}", e);
+        }
     }
 
     async fn on_failure(&self, message_id: u32, timeouts: u32) {
         // remove the state for the lost message
-        self.tx
+        let res = self
+            .tx
             .send(InternalMessage::TimerFailure {
                 message_id,
                 timeouts,
                 ack: false,
             })
-            .await
-            .expect("failed to send timer failure");
+            .await;
+
+        if let Err(e) = res {
+            error!("RtxTimerObserver: failed to send timer failure: {}", e);
+        }
     }
 
     async fn on_stop(&self, message_id: u32) {
@@ -1085,7 +1101,7 @@ where
         identity_verifier: V,
         storage_path: std::path::PathBuf,
     ) -> Self {
-        let (tx, rx) = mpsc::channel(128);
+        let (tx, rx) = mpsc::channel(256);
 
         // Common session stuff
         let common = Common::new(
@@ -1297,8 +1313,7 @@ where
         direction: MessageDirection,
     ) -> Result<(), SessionError> {
         self.tx
-            .send(InternalMessage::OnMessage { message, direction })
-            .await
+            .try_send(InternalMessage::OnMessage { message, direction })
             .map_err(|e| SessionError::SessionClosed(e.to_string()))
     }
 }
@@ -1319,9 +1334,9 @@ mod tests {
     #[tokio::test]
     async fn test_point_to_point_create() {
         let (tx_slim, _) = tokio::sync::mpsc::channel(1);
-        let (tx_app, _) = tokio::sync::mpsc::channel(1);
+        let (tx_app, _) = tokio::sync::mpsc::unbounded_channel();
 
-        let tx = SessionTransmitter::new(tx_app, tx_slim);
+        let tx = SessionTransmitter::new(tx_slim, tx_app);
 
         let source = Name::from_strings(["cisco", "default", "local"]).with_id(0);
 
@@ -1346,9 +1361,9 @@ mod tests {
     #[tokio::test]
     async fn test_point_to_point_create_with_remote_dst() {
         let (tx_slim, _) = tokio::sync::mpsc::channel(1);
-        let (tx_app, _) = tokio::sync::mpsc::channel(1);
+        let (tx_app, _) = tokio::sync::mpsc::unbounded_channel();
 
-        let tx = SessionTransmitter::new(tx_app, tx_slim);
+        let tx = SessionTransmitter::new(tx_slim, tx_app);
 
         let source = Name::from_strings(["cisco", "default", "local"]).with_id(0);
         let remote = Name::from_strings(["cisco", "default", "remote"]).with_id(999);
@@ -1371,7 +1386,7 @@ mod tests {
     #[tokio::test]
     async fn test_point_to_point_on_message() {
         let (tx_slim, _rx_slim) = tokio::sync::mpsc::channel(1);
-        let (tx_app, mut rx_app) = tokio::sync::mpsc::channel(1);
+        let (tx_app, mut rx_app) = tokio::sync::mpsc::unbounded_channel();
 
         // SessionTransmitter::new expects (slim_tx, app_tx)
         let tx = SessionTransmitter::new(tx_slim, tx_app);
@@ -1418,7 +1433,7 @@ mod tests {
     #[tokio::test]
     async fn test_point_to_point_on_message_with_ack() {
         let (tx_slim, mut rx_slim) = tokio::sync::mpsc::channel(1);
-        let (tx_app, mut rx_app) = tokio::sync::mpsc::channel(1);
+        let (tx_app, mut rx_app) = tokio::sync::mpsc::unbounded_channel();
 
         let tx = SessionTransmitter::new(tx_slim, tx_app);
 
@@ -1479,7 +1494,7 @@ mod tests {
     #[tokio::test]
     async fn test_point_to_point_timers_until_error() {
         let (tx_slim, mut rx_slim) = tokio::sync::mpsc::channel(1);
-        let (tx_app, mut rx_app) = tokio::sync::mpsc::channel(1);
+        let (tx_app, mut rx_app) = tokio::sync::mpsc::unbounded_channel();
 
         // SessionTransmitter::new expects (slim_tx, app_tx)
         let tx = SessionTransmitter::new(tx_slim, tx_app);
@@ -1542,12 +1557,12 @@ mod tests {
     #[tokio::test]
     async fn test_point_to_point_timers_and_ack() {
         let (tx_slim_sender, mut rx_slim_sender) = tokio::sync::mpsc::channel(1);
-        let (tx_app_sender, _rx_app_sender) = tokio::sync::mpsc::channel(1);
+        let (tx_app_sender, _rx_app_sender) = tokio::sync::mpsc::unbounded_channel();
 
         let tx_sender = SessionTransmitter::new(tx_slim_sender, tx_app_sender);
 
         let (tx_slim_receiver, mut rx_slim_receiver) = tokio::sync::mpsc::channel(1);
-        let (tx_app_receiver, mut rx_app_receiver) = tokio::sync::mpsc::channel(1);
+        let (tx_app_receiver, mut rx_app_receiver) = tokio::sync::mpsc::unbounded_channel();
 
         let tx_receiver = SessionTransmitter::new(tx_slim_receiver, tx_app_receiver);
 
@@ -1663,9 +1678,9 @@ mod tests {
     #[traced_test]
     async fn test_session_delete() {
         let (tx_slim, _) = tokio::sync::mpsc::channel(1);
-        let (tx_app, _) = tokio::sync::mpsc::channel(1);
+        let (tx_app, _) = tokio::sync::mpsc::unbounded_channel();
 
-        let tx = SessionTransmitter::new(tx_app, tx_slim);
+        let tx = SessionTransmitter::new(tx_slim, tx_app);
 
         let source = Name::from_strings(["cisco", "default", "local"]).with_id(0);
 
@@ -1686,8 +1701,8 @@ mod tests {
     }
 
     async fn template_test_point_to_point_session(mls_enabled: bool) {
-        let (sender_tx_slim, mut sender_rx_slim) = tokio::sync::mpsc::channel(1);
-        let (sender_tx_app, _sender_rx_app) = tokio::sync::mpsc::channel(1);
+        let (sender_tx_slim, mut sender_rx_slim) = tokio::sync::mpsc::channel(16);
+        let (sender_tx_app, _sender_rx_app) = tokio::sync::mpsc::unbounded_channel();
 
         let sender_tx = SessionTransmitter {
             slim_tx: sender_tx_slim,
@@ -1695,8 +1710,8 @@ mod tests {
             interceptors: Arc::new(RwLock::new(Vec::new())),
         };
 
-        let (receiver_tx_slim, mut receiver_rx_slim) = tokio::sync::mpsc::channel(1);
-        let (receiver_tx_app, mut receiver_rx_app) = tokio::sync::mpsc::channel(1);
+        let (receiver_tx_slim, mut receiver_rx_slim) = tokio::sync::mpsc::channel(16);
+        let (receiver_tx_app, mut receiver_rx_app) = tokio::sync::mpsc::unbounded_channel();
 
         let receiver_tx = SessionTransmitter {
             slim_tx: receiver_tx_slim,

{slim_bindings-0.6.1 → slim_bindings-0.6.3}/core/session/src/session_layer.rs

@@ -222,7 +222,7 @@ where
         };
 
         // Create a new transmitter with identity interceptors
-        let (app_tx, app_rx) = tokio::sync::mpsc::channel(128);
+        let (app_tx, app_rx) = tokio::sync::mpsc::unbounded_channel();
         let tx = SessionTransmitter::new(self.tx_slim.clone(), app_tx);
 
         let identity_interceptor = Arc::new(IdentityInterceptor::new(