Enhance AnySender trait with capacity and is_closed methods for better error handling

Author: lxsaah

aimdb-core/src/emitter.rs

@@ -318,14 +318,23 @@ impl Emitter {
         // Try to send via type-erased trait method
         let boxed_value = Box::new(value) as Box<dyn Any + Send>;
         sender.try_send_any(boxed_value).map_err(|_returned_value| {
-            // We can't easily distinguish between Full and Closed in the type-erased interface
-            // For now, assume Full (more common case). Capacity is unknown at this level.
-            DbError::OutboxFull {
-                capacity: 0, // Unknown at this level
-                #[cfg(feature = "std")]
-                type_name: core::any::type_name::<T>().to_string(),
-                #[cfg(not(feature = "std"))]
-                _type_name: (),
+            // Check if channel is closed to distinguish error types
+            if sender.is_closed() {
+                DbError::OutboxClosed {
+                    #[cfg(feature = "std")]
+                    type_name: core::any::type_name::<T>().to_string(),
+                    #[cfg(not(feature = "std"))]
+                    _type_name: (),
+                }
+            } else {
+                // Channel is full - now we can report the actual capacity
+                DbError::OutboxFull {
+                    capacity: sender.capacity(),
+                    #[cfg(feature = "std")]
+                    type_name: core::any::type_name::<T>().to_string(),
+                    #[cfg(not(feature = "std"))]
+                    _type_name: (),
+                }
             }
         })
     }
@@ -435,6 +444,16 @@ mod tests {
                 Ok(())
             }
         }
+
+        fn capacity(&self) -> usize {
+            // Mock capacity for testing
+            100
+        }
+
+        fn is_closed(&self) -> bool {
+            // If should_fail is true, simulate closed channel
+            self.should_fail
+        }
     }
 
     fn create_test_emitter() -> Emitter {
@@ -548,13 +567,48 @@ mod tests {
 
         match result {
             Err(crate::DbError::OutboxFull { capacity, .. }) => {
-                // Capacity is placeholder (0) at this level
-                assert_eq!(capacity, 0);
+                // Capacity should now be reported from the mock sender
+                assert_eq!(capacity, 100);
             }
             _ => panic!("Expected OutboxFull error"),
         }
     }
 
+    #[test]
+    fn test_try_enqueue_channel_closed() {
+        let emitter = create_test_emitter();
+
+        // Register a mock sender that simulates closed channel (should_fail=true)
+        let mock_sender = MockSender::<TestMessage>::new(true, false);
+        let type_id = TypeId::of::<TestMessage>();
+
+        #[cfg(feature = "std")]
+        {
+            let mut outboxes = emitter.inner.outboxes.lock().unwrap();
+            outboxes.insert(type_id, Box::new(mock_sender));
+        }
+        #[cfg(not(feature = "std"))]
+        {
+            let mut outboxes = emitter.inner.outboxes.lock();
+            outboxes.insert(type_id, Box::new(mock_sender));
+        }
+
+        let msg = TestMessage {
+            id: 88,
+            content: "closed",
+        };
+
+        let result = emitter.try_enqueue(msg);
+        assert!(result.is_err());
+
+        match result {
+            Err(crate::DbError::OutboxClosed { .. }) => {
+                // Expected - should detect closed channel via is_closed()
+            }
+            _ => panic!("Expected OutboxClosed error"),
+        }
+    }
+
     // Tests for enqueue method (async)
     #[cfg(feature = "std")]
     #[tokio::test]

aimdb-core/src/outbox.rs

@@ -209,6 +209,26 @@ pub trait AnySender: Send + Sync {
     /// * `Ok(())` - Message sent successfully
     /// * `Err(value)` - Channel full or closed, value returned
     fn try_send_any(&self, value: Box<dyn Any + Send>) -> Result<(), Box<dyn Any + Send>>;
+
+    /// Returns the channel capacity
+    ///
+    /// This provides information about the maximum number of messages
+    /// the channel can buffer. Useful for error reporting and metrics.
+    ///
+    /// # Returns
+    ///
+    /// The channel capacity, or 0 if unknown/unbounded
+    fn capacity(&self) -> usize;
+
+    /// Checks if the channel is closed
+    ///
+    /// This allows distinguishing between a full channel (temporary backpressure)
+    /// and a closed channel (permanent failure) when `try_send_any` fails.
+    ///
+    /// # Returns
+    ///
+    /// `true` if the channel is closed, `false` otherwise
+    fn is_closed(&self) -> bool;
 }
 
 /// Future type for async send operations
@@ -732,6 +752,16 @@ mod tests {
                 self.values.lock().unwrap().push(value);
                 Ok(())
             }
+
+            fn capacity(&self) -> usize {
+                // Mock capacity for testing
+                1000
+            }
+
+            fn is_closed(&self) -> bool {
+                // Mock: never closed
+                false
+            }
         }
 
         #[derive(Debug, Clone, PartialEq)]

aimdb-embassy-adapter/src/outbox.rs

@@ -216,6 +216,19 @@ impl<T: Send + 'static, const N: usize> AnySender for EmbassySender<T, N> {
             Box::new(v) as Box<dyn Any + Send>
         })
     }
+
+    fn capacity(&self) -> usize {
+        // Embassy channels have const generic capacity N
+        N
+    }
+
+    fn is_closed(&self) -> bool {
+        // Embassy channels don't have a direct is_closed() check
+        // They remain open as long as at least one sender exists
+        // Since we hold a sender reference, it's not closed
+        // This is a simplification - Embassy channels don't close in the same way
+        false
+    }
 }
 
 // Implement Clone for EmbassySender since embassy Sender is Clone

aimdb-tokio-adapter/src/outbox.rs

@@ -192,6 +192,16 @@ impl<T: Send + 'static> AnySender for TokioSender<T> {
             mpsc::error::TrySendError::Closed(v) => Box::new(v) as Box<dyn Any + Send>,
         })
     }
+
+    fn capacity(&self) -> usize {
+        // Tokio channels expose max_capacity() which returns the capacity
+        self.inner.max_capacity()
+    }
+
+    fn is_closed(&self) -> bool {
+        // Tokio channels expose is_closed() method
+        self.inner.is_closed()
+    }
 }
 
 // Implement Clone for TokioSender since mpsc::Sender is Clone