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

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

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

{slim_bindings-0.6.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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(

{slim_bindings-0.6.2 → slim_bindings-0.6.3}/core/session/src/transmitter.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Standard library imports
+use std::future::Future;
 use std::sync::Arc;
 
 // Third-party crates
@@ -20,45 +21,13 @@ use crate::{
     notification::Notification,
 };
 
-/// Macro to generate the common transmitter method body pattern
-macro_rules! transmit_with_interceptors {
-    (
-        $self:ident,
-        $message:ident,
-        $tx_field:ident,
-        $interceptor_method:ident,
-        $error_variant:ident
-    ) => {{
-        let tx = $self.$tx_field.clone();
-
-        // Interceptors
-        let interceptors = match &$message {
-            Ok(_) => $self.interceptors.read().clone(),
-            Err(_) => Vec::new(),
-        };
-
-        async move {
-            if let Ok(msg) = $message.as_mut() {
-                // Apply interceptors on the message
-                for interceptor in interceptors {
-                    interceptor.$interceptor_method(msg).await?;
-                }
-            }
-
-            tx.send($message)
-                .await
-                .map_err(|e| SessionError::$error_variant(e.to_string()))
-        }
-    }};
-}
-
 /// Transmitter used to intercept messages sent from sessions and apply interceptors on them
 #[derive(Clone)]
 pub struct SessionTransmitter {
-    /// SLIM tx
+    /// SLIM tx (bounded channel)
     pub(crate) slim_tx: SlimChannelSender,
 
-    /// App tx
+    /// App tx (unbounded channel)
     pub(crate) app_tx: AppChannelSender,
 
     // Interceptors to be called on message reception/send
@@ -90,28 +59,62 @@ impl Transmitter for SessionTransmitter {
         &self,
         mut message: Result<Message, SessionError>,
     ) -> impl Future<Output = Result<(), SessionError>> + Send + 'static {
-        transmit_with_interceptors!(self, message, app_tx, on_msg_from_slim, AppTransmission)
+        let tx = self.app_tx.clone();
+
+        // Interceptors only run on successful messages
+        let interceptors = match &message {
+            Ok(_) => self.interceptors.read().clone(),
+            Err(_) => Vec::new(),
+        };
+
+        async move {
+            if let Ok(msg) = message.as_mut() {
+                for interceptor in interceptors {
+                    interceptor.on_msg_from_slim(msg).await?;
+                }
+            }
+
+            tx.send(message)
+                .map_err(|e| SessionError::AppTransmission(e.to_string()))
+        }
     }
 
     fn send_to_slim(
         &self,
         mut message: Result<Message, Status>,
     ) -> impl Future<Output = Result<(), SessionError>> + Send + 'static {
-        transmit_with_interceptors!(self, message, slim_tx, on_msg_from_app, SlimTransmission)
+        let tx = self.slim_tx.clone();
+
+        // Interceptors only run on successful messages
+        let interceptors = match &message {
+            Ok(_) => self.interceptors.read().clone(),
+            Err(_) => Vec::new(),
+        };
+
+        async move {
+            if let Ok(msg) = message.as_mut() {
+                for interceptor in interceptors {
+                    interceptor.on_msg_from_app(msg).await?;
+                }
+            }
+
+            tx.try_send(message)
+                .map_err(|e| SessionError::SlimTransmission(e.to_string()))
+        }
     }
 }
 
-/// Transmitter used to intercept messages sent from sessions and apply interceptors on them
+/// Transmitter used to intercept messages sent from the application side and apply interceptors
 #[derive(Clone)]
 pub struct AppTransmitter<P, V>
 where
     P: TokenProvider + Send + Sync + Clone + 'static,
     V: Verifier + Send + Sync + Clone + 'static,
 {
-    /// SLIM tx
+    /// SLIM tx (bounded channel)
     pub slim_tx: SlimChannelSender,
 
-    /// App tx
+    /// App tx (bounded channel here; notifications)
     pub app_tx: Sender<Result<Notification<P, V>, SessionError>>,
 
     // Interceptors to be called on message reception/send
@@ -143,7 +146,6 @@ where
     ) -> impl Future<Output = Result<(), SessionError>> + Send + 'static {
         let tx = self.app_tx.clone();
 
-        // Interceptors
         let interceptors = match &message {
             Ok(_) => self.interceptors.read().clone(),
             Err(_) => Vec::new(),
@@ -151,7 +153,6 @@ where
 
         async move {
             if let Ok(msg) = message.as_mut() {
-                // Apply interceptors on the message
                 for interceptor in interceptors {
                     interceptor.on_msg_from_slim(msg).await?;
                 }
@@ -167,7 +168,24 @@ where
         &self,
         mut message: Result<Message, Status>,
     ) -> impl Future<Output = Result<(), SessionError>> + Send + 'static {
-        transmit_with_interceptors!(self, message, slim_tx, on_msg_from_app, SlimTransmission)
+        let tx = self.slim_tx.clone();
+
+        // Interceptors only run on successful messages
+        let interceptors = match &message {
+            Ok(_) => self.interceptors.read().clone(),
+            Err(_) => Vec::new(),
+        };
+
+        async move {
+            if let Ok(msg) = message.as_mut() {
+                for interceptor in interceptors {
+                    interceptor.on_msg_from_app(msg).await?;
+                }
+            }
+
+            tx.try_send(message)
+                .map_err(|e| SessionError::SlimTransmission(e.to_string()))
+        }
     }
 }
 
@@ -242,41 +260,37 @@ mod tests {
     fn make_message() -> Message {
         let source = Name::from_strings(["a", "b", "c"]).with_id(0);
         let dst = Name::from_strings(["d", "e", "f"]).with_id(0);
-        // Signature: (&Name, &Name, Option<SlimHeaderFlags>, &str, Vec<u8>)
         Message::new_publish(&source, &dst, None, "application/octet-stream", Vec::new())
     }
 
     #[tokio::test]
     async fn session_transmitter_interceptor_application_send_to_slim() {
         let (slim_tx, mut slim_rx) = mpsc::channel::<Result<Message, Status>>(4);
-        let (app_tx, mut app_rx) = mpsc::channel::<Result<Message, SessionError>>(4);
+        let (app_tx, mut app_rx) = mpsc::unbounded_channel::<Result<Message, SessionError>>();
         let tx = SessionTransmitter::new(slim_tx, app_tx);
         let interceptor = Arc::new(RecordingInterceptor::default());
         tx.add_interceptor(interceptor.clone());
 
-        // send_to_slim treats the message as originating from the app -> on_msg_from_app invoked
         tx.send_to_slim(Ok(make_message())).await.unwrap();
         let sent = slim_rx.recv().await.unwrap().unwrap();
         assert_eq!(sent.get_metadata("APP").map(|s| s.as_str()), Some("1"));
         assert_eq!(*interceptor.app_calls.read(), 1);
         assert_eq!(*interceptor.slim_calls.read(), 0);
 
-        // send_to_app treats the message as coming from slim -> on_msg_from_slim invoked
         tx.send_to_app(Ok(make_message())).await.unwrap();
         let app_msg = app_rx.recv().await.unwrap().unwrap();
         assert_eq!(app_msg.get_metadata("SLIM").map(|s| s.as_str()), Some("1"));
-        assert_eq!(*interceptor.slim_calls.read(), 1); // first slim direction call
+        assert_eq!(*interceptor.slim_calls.read(), 1);
     }
 
     #[tokio::test]
     async fn session_transmitter_error_bypasses_interceptors() {
         let (slim_tx, mut slim_rx) = mpsc::channel::<Result<Message, Status>>(1);
-        let (app_tx, _app_rx) = mpsc::channel::<Result<Message, SessionError>>(1);
+        let (app_tx, _app_rx) = mpsc::unbounded_channel::<Result<Message, SessionError>>();
         let tx = SessionTransmitter::new(slim_tx, app_tx);
         let interceptor = Arc::new(RecordingInterceptor::default());
         tx.add_interceptor(interceptor.clone());
 
-        // Error result: interceptors should not run, calls remain 0
         tx.send_to_slim(Err(Status::failed_precondition("err")))
             .await
             .unwrap();
@@ -298,7 +312,6 @@ mod tests {
         let interceptor = Arc::new(RecordingInterceptor::default());
         tx.add_interceptor(interceptor.clone());
 
-        // AppTransmitter::send_to_app uses on_msg_from_slim (message inbound from slim)
         tx.send_to_app(Ok(make_message())).await.unwrap();
         if let Ok(Notification::NewMessage(msg)) = app_rx.recv().await.unwrap() {
             assert_eq!(msg.get_metadata("SLIM").map(|s| s.as_str()), Some("1"));
@@ -308,7 +321,6 @@ mod tests {
             panic!("expected NewMessage notification");
         }
 
-        // AppTransmitter::send_to_slim uses on_msg_from_app (message outbound to slim)
         tx.send_to_slim(Ok(make_message())).await.unwrap();
         let slim_msg = slim_rx.recv().await.unwrap().unwrap();
         assert_eq!(slim_msg.get_metadata("APP").map(|s| s.as_str()), Some("1"));

{slim_bindings-0.6.2 → slim_bindings-0.6.3}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "maturin"
 
 [project]
 name = "slim-bindings"
-version = "0.6.2"
+version = "0.6.3"
 description = "SLIM Rust bindings for Python"
 requires-python = ">=3.9, <4.0"
 readme = "README.md"

{slim_bindings-0.6.2 → slim_bindings-0.6.3}/python/bindings/uv.lock

@@ -340,7 +340,7 @@ wheels = [
 
 [[package]]
 name = "slim-bindings"
-version = "0.6.1"
+version = "0.6.2"
 source = { editable = "." }
 
 [package.dev-dependencies]