where to start and where to accept?

satrs-example/src/main.rs

@@ -119,6 +119,10 @@ fn static_tmtc_pool_main() {
     let (pus_sched_tx, pus_sched_rx) = channel();
     let (pus_hk_tx, pus_hk_rx) = channel();
     let (pus_action_tx, pus_action_rx) = channel();
+
+    let (pus_action_reply_tx, pus_action_reply_rx) = channel();
+    let (pus_hk_reply_tx, pus_hk_reply_rx) = channel();
+
     let pus_router = PusTcMpscRouter {
         test_service_receiver: pus_test_tx,
         event_service_receiver: pus_event_tx,
@@ -157,6 +161,7 @@ fn static_tmtc_pool_main() {
         shared_tc_pool.pool.clone(),
         pus_action_rx,
         request_map.clone(),
+        pus_action_reply_rx,
     );
     let pus_hk_service = create_hk_service_static(
         shared_tm_pool.clone(),
@@ -165,6 +170,7 @@ fn static_tmtc_pool_main() {
         shared_tc_pool.pool.clone(),
         pus_hk_rx,
         request_map,
+        pus_hk_reply_rx
     );
     let mut pus_stack = PusStack::new(
         pus_hk_service,
@@ -340,6 +346,10 @@ fn dyn_tmtc_pool_main() {
     let (pus_sched_tx, pus_sched_rx) = channel();
     let (pus_hk_tx, pus_hk_rx) = channel();
     let (pus_action_tx, pus_action_rx) = channel();
+
+    let (pus_action_reply_tx, pus_action_reply_rx) = channel();
+    let (pus_hk_reply_tx, pus_hk_reply_rx) = channel();
+
     let pus_router = PusTcMpscRouter {
         test_service_receiver: pus_test_tx,
         event_service_receiver: pus_event_tx,
@@ -373,12 +383,14 @@ fn dyn_tmtc_pool_main() {
         verif_reporter.clone(),
         pus_action_rx,
         request_map.clone(),
+        pus_action_reply_rx,
     );
     let pus_hk_service = create_hk_service_dynamic(
         tm_funnel_tx.clone(),
         verif_reporter.clone(),
         pus_hk_rx,
         request_map,
+        pus_hk_reply_rx
     );
     let mut pus_stack = PusStack::new(
         pus_hk_service,

satrs-example/src/pus/action.rs

@@ -3,8 +3,8 @@ use satrs::action::{ActionRequest, ActionRequestVariant};
 use satrs::params::WritableToBeBytes;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::action::{
-    ActionReplyPus, ActionReplyPusWithActionId, ActionRequestWithId, ActionRequestorBoundedMpsc,
+    ActionReplyPus, ActionReplyPusWithActionId, ActionRequestWithId, ActivePusActionRequestStd,
-    ActionRequestorMpsc, ActivePusActionRequestStd, DefaultActiveActionRequestMap,
+    DefaultActiveActionRequestMap,
 };
 use satrs::pus::verification::{
     self, FailParams, FailParamsWithStep, TcStateAccepted,
@@ -18,7 +18,7 @@ use satrs::pus::{
     PusTcToRequestConverter, TmAsVecSenderWithId, TmAsVecSenderWithMpsc,
     TmInSharedPoolSenderWithBoundedMpsc, TmInSharedPoolSenderWithId,
 };
-use satrs::request::{GenericMessage, MessageReceiver, MessageSender, TargetAndApidId};
+use satrs::request::{GenericMessage, TargetAndApidId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket};
 use satrs::tmtc::tm_helper::SharedTmPool;
@@ -200,13 +200,13 @@ pub fn create_action_service_static(
     verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
-    action_router: ActionRequestorBoundedMpsc,
+    action_router: GenericRequestRouter,
+    reply_receiver: mpsc::Receiver<GenericMessage<ActionReplyPusWithActionId>>,
 ) -> Pus8Wrapper<
     MpscTcReceiver,
     TmInSharedPoolSenderWithBoundedMpsc,
     EcssTcInSharedStoreConverter,
     VerificationReporterWithSharedPoolMpscBoundedSender,
-    mpsc::SyncSender<GenericMessage<ActionRequest>>,
 > {
     let action_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusAction as ChannelId,
@@ -233,6 +233,7 @@ pub fn create_action_service_static(
         DefaultActiveActionRequestMap::default(),
         ActionReplyHandler::default(),
         action_router,
+        reply_receiver,
     );
     Pus8Wrapper {
         action_request_handler,
@@ -243,13 +244,13 @@ pub fn create_action_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
     verif_reporter: VerificationReporterWithVecMpscSender,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
-    action_router: ActionRequestorMpsc,
+    action_router: GenericRequestRouter,
+    reply_receiver: mpsc::Receiver<GenericMessage<ActionReplyPusWithActionId>>,
 ) -> Pus8Wrapper<
     MpscTcReceiver,
     TmAsVecSenderWithMpsc,
     EcssTcInVecConverter,
     VerificationReporterWithVecMpscSender,
-    mpsc::Sender<GenericMessage<ActionRequest>>,
 > {
     let action_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusAction as ChannelId,
@@ -273,6 +274,7 @@ pub fn create_action_service_dynamic(
         DefaultActiveActionRequestMap::default(),
         ActionReplyHandler::default(),
         action_router,
+        reply_receiver,
     );
     Pus8Wrapper {
         action_request_handler,
@@ -284,7 +286,6 @@ pub struct Pus8Wrapper<
     TmSender: EcssTmSenderCore,
     TcInMemConverter: EcssTcInMemConverter,
     VerificationReporter: VerificationReportingProvider,
-    RequestSender: MessageSender<ActionRequest>,
 > {
     pub(crate) action_request_handler: PusTargetedRequestService<
         TcReceiver,
@@ -295,8 +296,7 @@ pub struct Pus8Wrapper<
         ActionReplyHandler,
         DefaultActiveActionRequestMap,
         ActivePusActionRequestStd,
-        RequestSender,
+        ActionRequestWithId,
-        ActionRequest,
         ActionReplyPusWithActionId,
     >,
 }
@@ -306,8 +306,7 @@ impl<
         TmSender: EcssTmSenderCore,
         TcInMemConverter: EcssTcInMemConverter,
         VerificationReporter: VerificationReportingProvider,
-        RequestSender: MessageSender<ActionRequest>,
+    > Pus8Wrapper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>
-    > Pus8Wrapper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter, RequestSender>
 {
     pub fn handle_next_packet(&mut self, time_stamp: &[u8]) -> bool {
         match self.action_request_handler.handle_one_tc(time_stamp) {

satrs-example/src/pus/hk.rs

@@ -13,7 +13,7 @@ use satrs::pus::{
     TmAsVecSenderWithId, TmAsVecSenderWithMpsc, TmInSharedPoolSenderWithBoundedMpsc,
     TmInSharedPoolSenderWithId,
 };
-use satrs::request::TargetAndApidId;
+use satrs::request::{TargetAndApidId, GenericMessage};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket};
 use satrs::tmtc::tm_helper::SharedTmPool;
@@ -212,6 +212,7 @@ pub fn create_hk_service_static(
     tc_pool: SharedStaticMemoryPool,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
+    reply_receiver: mpsc::Receiver<GenericMessage<HkReply>>,
 ) -> Pus3Wrapper<
     MpscTcReceiver,
     TmInSharedPoolSenderWithBoundedMpsc,
@@ -235,9 +236,10 @@ pub fn create_hk_service_static(
             EcssTcInSharedStoreConverter::new(tc_pool, 2048),
         ),
         ExampleHkRequestConverter::default(),
-        request_router,
         DefaultActiveRequestMap::default(),
         HkReplyHandler::default(),
+        request_router,
+        reply_receiver
     );
     Pus3Wrapper { pus_3_handler }
 }
@@ -247,6 +249,7 @@ pub fn create_hk_service_dynamic(
     verif_reporter: VerificationReporterWithVecMpscSender,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
+    reply_receiver: mpsc::Receiver<GenericMessage<HkReply>>,
 ) -> Pus3Wrapper<
     MpscTcReceiver,
     TmAsVecSenderWithMpsc,
@@ -269,9 +272,10 @@ pub fn create_hk_service_dynamic(
             EcssTcInVecConverter::default(),
         ),
         ExampleHkRequestConverter::default(),
-        request_router,
         DefaultActiveRequestMap::default(),
         HkReplyHandler::default(),
+        request_router,
+        reply_receiver
     );
     Pus3Wrapper { pus_3_handler }
 }

satrs-example/src/pus/mod.rs

@@ -9,6 +9,7 @@ use satrs::pus::{
     PusPacketHandlerResult, PusPacketHandlingError, PusReplyHandler, PusRequestRouter,
     PusServiceHelper, PusTcToRequestConverter, TcInMemory,
 };
+use satrs::queue::GenericReceiveError;
 use satrs::request::{GenericMessage, MessageReceiver, MessageSender, MessageSenderAndReceiver};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusServiceId;
@@ -87,18 +88,16 @@ pub struct PusTargetedRequestService<
     ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
     ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
     ActiveRequestInfo: ActiveRequestProvider,
-    RequestSender: MessageSender<RequestType>,
+    RequestType,
-    RequestType: Send,
     ReplyType,
 > {
     pub service_helper:
         PusServiceHelper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
-    //pub request_router: GenericRequestRouter,
+    pub request_router: GenericRequestRouter,
     pub request_converter: RequestConverter,
     pub active_request_map: ActiveRequestMap,
-    pub request_router_reply_receiver:
-        MessageSenderAndReceiver<RequestType, ReplyType, RequestSender, mpsc::Receiver<ReplyType>>,
     pub reply_handler: ReplyHandler,
+    pub reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
     phantom: std::marker::PhantomData<(RequestType, ActiveRequestInfo, ReplyType)>,
 }
 
@@ -111,8 +110,7 @@ impl<
         ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
         ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
         ActiveRequestInfo: ActiveRequestProvider,
-        RequestSender: MessageSender<RequestType>,
+        RequestType,
-        RequestType: Send,
         ReplyType,
     >
     PusTargetedRequestService<
@@ -124,7 +122,6 @@ impl<
         ReplyHandler,
         ActiveRequestMap,
         ActiveRequestInfo,
-        RequestSender,
         RequestType,
         ReplyType,
     >
@@ -141,19 +138,16 @@ where
         request_converter: RequestConverter,
         active_request_map: ActiveRequestMap,
         reply_hook: ReplyHandler,
-        request_router_reply_receiver: MessageSenderAndReceiver<
+        request_router: GenericRequestRouter,
-            RequestType,
+        reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
-            ReplyType,
-            RequestSender,
-            mpsc::Receiver<GenericMessage<ReplyType>>,
-        >,
     ) -> Self {
         Self {
             service_helper,
             request_converter,
             active_request_map,
             reply_handler: reply_hook,
-            request_router_reply_receiver,
+            request_router,
+            reply_receiver,
             phantom: std::marker::PhantomData,
         }
     }
@@ -178,18 +172,16 @@ where
             &self.service_helper.common.verification_handler,
         )?;
         let verif_request_id = verification::RequestId::new(&tc);
-        if let Err(e) = self
+        if let Err(e) =
-            .request_router_reply_receiver
+            self.request_router
-            .message_sender_map
+                .route(request_info.target_id(), request, request_info.token())
-            .send_message(request_id, local_channel_id, target_channel_id, request)
-        // .(request_info.target_id(), request, ecss_tc_and_token.token)
         {
             let target_id = request_info.target_id();
             self.active_request_map
                 .insert(&verif_request_id.into(), request_info);
             self.request_router.handle_error(
                 target_id,
-                ecss_tc_and_token.token,
+                request_info.token(),
                 &tc,
                 e.clone(),
                 time_stamp,
@@ -200,7 +192,26 @@ where
         Ok(PusPacketHandlerResult::RequestHandled)
     }
 
-    pub fn insert_reply(
+    pub fn check_one_reply(&mut self, time_stamp: &[u8]) -> Result<bool, EcssTmtcError> {
+        match self.reply_receiver.try_recv() {
+            Ok(reply) => {
+                self.handle_reply(&reply, time_stamp)?;
+                Ok(true)
+            }
+            Err(e) => match e {
+                mpsc::TryRecvError::Empty => {
+                    return Ok(false);
+                }
+                mpsc::TryRecvError::Disconnected => {
+                    return Err(EcssTmtcError::Receive(GenericReceiveError::TxDisconnected(
+                        None,
+                    )));
+                }
+            },
+        }
+    }
+
+    pub fn handle_reply(
         &mut self,
         reply: &GenericMessage<ReplyType>,
         time_stamp: &[u8],