simplified event management

satrs-example/src/events.rs

@@ -8,10 +8,7 @@ use satrs::pus::verification::VerificationReporter;
 use satrs::pus::EcssTmSender;
 use satrs::request::UniqueApidTargetId;
 use satrs::{
-    event_man::{
-        EventManagerWithBoundedMpsc, EventSendProvider, EventU32SenderMpscBounded,
-        MpscEventReceiver,
-    },
+    event_man::{EventManagerWithBoundedMpsc, EventSendProvider, EventU32SenderMpscBounded},
     pus::{
         event_man::{
             DefaultPusEventU32Dispatcher, EventReporter, EventRequest, EventRequestWithToken,
@@ -136,34 +133,42 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
     }
 }
 
-/// This is a thin wrapper around the event manager which also caches the sender component
-/// used to send events to the event manager.
-pub struct EventManagerWrapper {
+pub struct EventHandler<TmSender: EcssTmSender> {
+    pub pus_event_handler: PusEventHandler<TmSender>,
     event_manager: EventManagerWithBoundedMpsc,
-    event_sender: mpsc::Sender<EventMessageU32>,
 }
 
-impl EventManagerWrapper {
-    pub fn new() -> Self {
-        // The sender handle is the primary sender handle for all components which want to create events.
-        // The event manager will receive the RX handle to receive all the events.
-        let (event_sender, event_man_rx) = mpsc::channel();
-        let event_recv = MpscEventReceiver::new(event_man_rx);
+impl<TmSender: EcssTmSender> EventHandler<TmSender> {
+    pub fn new(
+        tm_sender: TmSender,
+        event_rx: mpsc::Receiver<EventMessageU32>,
+        event_request_rx: mpsc::Receiver<EventRequestWithToken>,
+    ) -> Self {
+        let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx);
+        let pus_event_handler = PusEventHandler::new(
+            tm_sender,
+            create_verification_reporter(PUS_EVENT_MANAGEMENT.id(), PUS_EVENT_MANAGEMENT.apid),
+            &mut event_manager,
+            event_request_rx,
+        );
+
         Self {
-            event_manager: EventManagerWithBoundedMpsc::new(event_recv),
-            event_sender,
+            pus_event_handler,
+            event_manager,
         }
     }
 
-    // Returns a cached event sender to send events to the event manager for routing.
-    pub fn clone_event_sender(&self) -> mpsc::Sender<EventMessageU32> {
-        self.event_sender.clone()
-    }
-
+    #[allow(dead_code)]
     pub fn event_manager(&mut self) -> &mut EventManagerWithBoundedMpsc {
         &mut self.event_manager
     }
 
+    pub fn periodic_operation(&mut self) {
+        self.pus_event_handler.handle_event_requests();
+        self.try_event_routing();
+        self.pus_event_handler.generate_pus_event_tm();
+    }
+
     pub fn try_event_routing(&mut self) {
         let error_handler = |event_msg: &EventMessageU32, error: EventRoutingError| {
             self.routing_error_handler(event_msg, error)
@@ -176,42 +181,3 @@ impl EventManagerWrapper {
         log::warn!("event routing error for event {event_msg:?}: {error:?}");
     }
 }
-
-pub struct EventHandler<TmSender: EcssTmSender> {
-    pub event_man_wrapper: EventManagerWrapper,
-    pub pus_event_handler: PusEventHandler<TmSender>,
-}
-
-impl<TmSender: EcssTmSender> EventHandler<TmSender> {
-    pub fn new(
-        tm_sender: TmSender,
-        event_request_rx: mpsc::Receiver<EventRequestWithToken>,
-    ) -> Self {
-        let mut event_man_wrapper = EventManagerWrapper::new();
-        let pus_event_handler = PusEventHandler::new(
-            tm_sender,
-            create_verification_reporter(PUS_EVENT_MANAGEMENT.id(), PUS_EVENT_MANAGEMENT.apid),
-            event_man_wrapper.event_manager(),
-            event_request_rx,
-        );
-        Self {
-            event_man_wrapper,
-            pus_event_handler,
-        }
-    }
-
-    pub fn clone_event_sender(&self) -> mpsc::Sender<EventMessageU32> {
-        self.event_man_wrapper.clone_event_sender()
-    }
-
-    #[allow(dead_code)]
-    pub fn event_manager(&mut self) -> &mut EventManagerWithBoundedMpsc {
-        self.event_man_wrapper.event_manager()
-    }
-
-    pub fn periodic_operation(&mut self) {
-        self.pus_event_handler.handle_event_requests();
-        self.event_man_wrapper.try_event_routing();
-        self.pus_event_handler.generate_pus_event_tm();
-    }
-}

satrs-example/src/main.rs

@@ -80,11 +80,12 @@ fn static_tmtc_pool_main() {
     // Create event handling components
     // These sender handles are used to send event requests, for example to enable or disable
     // certain events.
+    let (event_tx, event_rx) = mpsc::sync_channel(100);
     let (event_request_tx, event_request_rx) = mpsc::channel::<EventRequestWithToken>();
 
     // The event task is the core handler to perform the event routing and TM handling as specified
     // in the sat-rs documentation.
-    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_request_rx);
+    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_rx, event_request_rx);
 
     let (pus_test_tx, pus_test_rx) = mpsc::channel();
     let (pus_event_tx, pus_event_rx) = mpsc::channel();
@@ -108,7 +109,7 @@ fn static_tmtc_pool_main() {
     let pus_test_service = create_test_service_static(
         tm_funnel_tx_sender.clone(),
         shared_tc_pool.clone(),
-        event_handler.clone_event_sender(),
+        event_tx.clone(),
         pus_test_rx,
     );
     let pus_scheduler_service = create_scheduler_service_static(
@@ -314,10 +315,11 @@ fn dyn_tmtc_pool_main() {
     // Create event handling components
     // These sender handles are used to send event requests, for example to enable or disable
     // certain events.
+    let (event_tx, event_rx) = mpsc::sync_channel(100);
     let (event_request_tx, event_request_rx) = mpsc::channel::<EventRequestWithToken>();
     // The event task is the core handler to perform the event routing and TM handling as specified
     // in the sat-rs documentation.
-    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_request_rx);
+    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_rx, event_request_rx);
 
     let (pus_test_tx, pus_test_rx) = mpsc::channel();
     let (pus_event_tx, pus_event_rx) = mpsc::channel();
@@ -339,11 +341,8 @@ fn dyn_tmtc_pool_main() {
         mode_tc_sender: pus_mode_tx,
     };
 
-    let pus_test_service = create_test_service_dynamic(
-        tm_funnel_tx.clone(),
-        event_handler.clone_event_sender(),
-        pus_test_rx,
-    );
+    let pus_test_service =
+        create_test_service_dynamic(tm_funnel_tx.clone(), event_tx.clone(), pus_test_rx);
     let pus_scheduler_service = create_scheduler_service_dynamic(
         tm_funnel_tx.clone(),
         tc_source_tx.clone(),

satrs-example/src/pus/test.rs

@@ -23,7 +23,7 @@ use super::HandlingStatus;
 pub fn create_test_service_static(
     tm_sender: PacketSenderWithSharedPool,
     tc_pool: SharedStaticMemoryPool,
-    event_sender: mpsc::Sender<EventMessageU32>,
+    event_sender: mpsc::SyncSender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper<PacketSenderWithSharedPool, EcssTcInSharedStoreConverter> {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
@@ -41,7 +41,7 @@ pub fn create_test_service_static(
 
 pub fn create_test_service_dynamic(
     tm_funnel_tx: mpsc::Sender<PacketAsVec>,
-    event_sender: mpsc::Sender<EventMessageU32>,
+    event_sender: mpsc::SyncSender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
@@ -61,7 +61,7 @@ pub struct TestCustomServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: Ec
 {
     pub handler:
         PusService17TestHandler<MpscTcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
-    pub test_srv_event_sender: mpsc::Sender<EventMessageU32>,
+    pub test_srv_event_sender: mpsc::SyncSender<EventMessageU32>,
 }
 
 impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>