Added high-level abstraction for some PUS services

Introduced high-level abstractions for targetable requests in general.

- PUS Service 3 (HK) abstraction for targetable HK requests
- PUS Service 8 (Action) abstraction for targetable action requests

satrs-example/src/pus/action.rs

@@ -1,22 +1,76 @@
-use crate::requests::{ActionRequest, Request, RequestWithToken};
 use log::{error, warn};
+use satrs::action::ActionRequest;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
+use satrs::pus::action::{PusActionToRequestConverter, PusService8ActionHandler};
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationToken,
+    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationReportingProvider,
+    VerificationToken,
 };
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    EcssTcReceiver, EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender,
-    PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHelper,
+    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
+    PusPacketHandlingError, PusServiceHelper,
 };
+use satrs::request::TargetAndApidId;
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
+use satrs::{ChannelId, TargetId};
 use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
-use satrs_example::TargetIdWithApid;
-use std::collections::HashMap;
-use std::sync::mpsc::{self, Sender};
+use std::sync::mpsc::{self};
+
+use crate::requests::GenericRequestRouter;
+
+use super::GenericRoutingErrorHandler;
+
+#[derive(Default)]
+pub struct ExampleActionRequestConverter {}
+
+impl PusActionToRequestConverter for ExampleActionRequestConverter {
+    type Error = PusPacketHandlingError;
+
+    fn convert(
+        &mut self,
+        token: VerificationToken<TcStateAccepted>,
+        tc: &PusTcReader,
+        time_stamp: &[u8],
+        verif_reporter: &impl VerificationReportingProvider,
+    ) -> Result<(TargetId, ActionRequest), Self::Error> {
+        let subservice = tc.subservice();
+        let user_data = tc.user_data();
+        if user_data.len() < 8 {
+            verif_reporter
+                .start_failure(
+                    token,
+                    FailParams::new_no_fail_data(time_stamp, &tmtc_err::NOT_ENOUGH_APP_DATA),
+                )
+                .expect("Sending start failure failed");
+            return Err(PusPacketHandlingError::NotEnoughAppData {
+                expected: 8,
+                found: user_data.len(),
+            });
+        }
+        let target_id = TargetAndApidId::from_pus_tc(tc).unwrap();
+        let action_id = u32::from_be_bytes(user_data[4..8].try_into().unwrap());
+        if subservice == 128 {
+            Ok((
+                target_id.raw(),
+                ActionRequest::UnsignedIdAndVecData {
+                    action_id,
+                    data: user_data[8..].to_vec(),
+                },
+            ))
+        } else {
+            verif_reporter
+                .start_failure(
+                    token,
+                    FailParams::new_no_fail_data(time_stamp, &tmtc_err::INVALID_PUS_SUBSERVICE),
+                )
+                .expect("Sending start failure failed");
+            Err(PusPacketHandlingError::InvalidSubservice(subservice))
+        }
+    }
+}
 
 pub fn create_action_service_static(
     shared_tm_store: SharedTmPool,
@@ -24,7 +78,7 @@ pub fn create_action_service_static(
     verif_reporter: VerificationReporterWithSender,
     tc_pool: SharedStaticMemoryPool,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
-    request_map: HashMap<TargetIdWithApid, mpsc::Sender<RequestWithToken>>,
+    action_router: GenericRequestRouter,
 ) -> Pus8Wrapper<EcssTcInSharedStoreConverter> {
     let action_srv_tm_sender = MpscTmInSharedPoolSender::new(
         TmSenderId::PusAction as ChannelId,
@@ -38,12 +92,16 @@ pub fn create_action_service_static(
         pus_action_rx,
     );
     let pus_8_handler = PusService8ActionHandler::new(
-        Box::new(action_srv_receiver),
-        Box::new(action_srv_tm_sender),
-        PUS_APID,
-        verif_reporter.clone(),
-        EcssTcInSharedStoreConverter::new(tc_pool.clone(), 2048),
-        request_map.clone(),
+        PusServiceHelper::new(
+            Box::new(action_srv_receiver),
+            Box::new(action_srv_tm_sender),
+            PUS_APID,
+            verif_reporter.clone(),
+            EcssTcInSharedStoreConverter::new(tc_pool.clone(), 2048),
+        ),
+        ExampleActionRequestConverter::default(),
+        action_router,
+        GenericRoutingErrorHandler::<8>::default(),
     );
     Pus8Wrapper { pus_8_handler }
 }
@@ -52,7 +110,7 @@ pub fn create_action_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
     verif_reporter: VerificationReporterWithSender,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
-    request_map: HashMap<TargetIdWithApid, mpsc::Sender<RequestWithToken>>,
+    action_router: GenericRequestRouter,
 ) -> Pus8Wrapper<EcssTcInVecConverter> {
     let action_srv_tm_sender = MpscTmAsVecSender::new(
         TmSenderId::PusAction as ChannelId,
@@ -65,146 +123,28 @@ pub fn create_action_service_dynamic(
         pus_action_rx,
     );
     let pus_8_handler = PusService8ActionHandler::new(
-        Box::new(action_srv_receiver),
-        Box::new(action_srv_tm_sender),
-        PUS_APID,
-        verif_reporter.clone(),
-        EcssTcInVecConverter::default(),
-        request_map.clone(),
+        PusServiceHelper::new(
+            Box::new(action_srv_receiver),
+            Box::new(action_srv_tm_sender),
+            PUS_APID,
+            verif_reporter.clone(),
+            EcssTcInVecConverter::default(),
+        ),
+        ExampleActionRequestConverter::default(),
+        action_router,
+        GenericRoutingErrorHandler::<8>::default(),
     );
     Pus8Wrapper { pus_8_handler }
 }
 
-pub struct PusService8ActionHandler<TcInMemConverter: EcssTcInMemConverter> {
-    service_helper: PusServiceHelper<TcInMemConverter>,
-    request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
-}
-
-impl<TcInMemConverter: EcssTcInMemConverter> PusService8ActionHandler<TcInMemConverter> {
-    pub fn new(
-        tc_receiver: Box<dyn EcssTcReceiver>,
-        tm_sender: Box<dyn EcssTmSender>,
-        tm_apid: u16,
-        verification_handler: VerificationReporterWithSender,
-        tc_in_mem_converter: TcInMemConverter,
-        request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
-    ) -> Self {
-        Self {
-            service_helper: PusServiceHelper::new(
-                tc_receiver,
-                tm_sender,
-                tm_apid,
-                verification_handler,
-                tc_in_mem_converter,
-            ),
-            request_handlers,
-        }
-    }
-
-    fn handle_action_request_with_id(
-        &self,
-        token: VerificationToken<TcStateAccepted>,
-        tc: &PusTcReader,
-        time_stamp: &[u8],
-    ) -> Result<(), PusPacketHandlingError> {
-        let user_data = tc.user_data();
-        if user_data.len() < 8 {
-            self.service_helper
-                .common
-                .verification_handler
-                .borrow_mut()
-                .start_failure(
-                    token,
-                    FailParams::new(Some(time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
-                )
-                .expect("Sending start failure failed");
-            return Err(PusPacketHandlingError::NotEnoughAppData(
-                "Expected at least 4 bytes".into(),
-            ));
-        }
-        //let target_id = u32::from_be_bytes(user_data[0..4].try_into().unwrap());
-        let target_id = TargetIdWithApid::from_tc(tc).unwrap();
-        let action_id = u32::from_be_bytes(user_data[4..8].try_into().unwrap());
-        if let Some(sender) = self.request_handlers.get(&target_id) {
-            sender
-                .send(RequestWithToken::new(
-                    target_id,
-                    Request::Action(ActionRequest::CmdWithU32Id((
-                        action_id,
-                        Vec::from(&user_data[8..]),
-                    ))),
-                    token,
-                ))
-                .expect("Forwarding action request failed");
-        } else {
-            let mut fail_data: [u8; 4] = [0; 4];
-            fail_data.copy_from_slice(&target_id.target.to_be_bytes());
-            self.service_helper
-                .common
-                .verification_handler
-                .borrow_mut()
-                .start_failure(
-                    token,
-                    FailParams::new(
-                        Some(time_stamp),
-                        &tmtc_err::UNKNOWN_TARGET_ID,
-                        Some(&fail_data),
-                    ),
-                )
-                .expect("Sending start failure failed");
-            return Err(PusPacketHandlingError::Other(format!(
-                "Unknown target ID {target_id}"
-            )));
-        }
-        Ok(())
-    }
-
-    fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
-        let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
-        if possible_packet.is_none() {
-            return Ok(PusPacketHandlerResult::Empty);
-        }
-        let ecss_tc_and_token = possible_packet.unwrap();
-        self.service_helper
-            .tc_in_mem_converter
-            .cache_ecss_tc_in_memory(&ecss_tc_and_token.tc_in_memory)?;
-        let tc = PusTcReader::new(self.service_helper.tc_in_mem_converter.tc_slice_raw())?.0;
-        let subservice = tc.subservice();
-        let mut partial_error = None;
-        let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
-        match subservice {
-            128 => {
-                self.handle_action_request_with_id(ecss_tc_and_token.token, &tc, &time_stamp)?;
-            }
-            _ => {
-                let fail_data = [subservice];
-                self.service_helper
-                    .common
-                    .verification_handler
-                    .get_mut()
-                    .start_failure(
-                        ecss_tc_and_token.token,
-                        FailParams::new(
-                            Some(&time_stamp),
-                            &tmtc_err::INVALID_PUS_SUBSERVICE,
-                            Some(&fail_data),
-                        ),
-                    )
-                    .expect("Sending start failure failed");
-                return Err(PusPacketHandlingError::InvalidSubservice(subservice));
-            }
-        }
-        if let Some(partial_error) = partial_error {
-            return Ok(PusPacketHandlerResult::RequestHandledPartialSuccess(
-                partial_error,
-            ));
-        }
-        Ok(PusPacketHandlerResult::RequestHandled)
-    }
-}
-
 pub struct Pus8Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub(crate) pus_8_handler: PusService8ActionHandler<TcInMemConverter>,
+    pub(crate) pus_8_handler: PusService8ActionHandler<
+        TcInMemConverter,
+        VerificationReporterWithSender,
+        ExampleActionRequestConverter,
+        GenericRequestRouter,
+        GenericRoutingErrorHandler<8>,
+    >,
 }
 
 impl<TcInMemConverter: EcssTcInMemConverter> Pus8Wrapper<TcInMemConverter> {

satrs-example/src/pus/event.rs

@@ -76,7 +76,7 @@ pub fn create_event_service_dynamic(
 }
 
 pub struct Pus5Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus_5_handler: PusService5EventHandler<TcInMemConverter>,
+    pub pus_5_handler: PusService5EventHandler<TcInMemConverter, VerificationReporterWithSender>,
 }
 
 impl<TcInMemConverter: EcssTcInMemConverter> Pus5Wrapper<TcInMemConverter> {

satrs-example/src/pus/hk.rs

@@ -1,22 +1,145 @@
-use crate::requests::{Request, RequestWithToken};
 use log::{error, warn};
 use satrs::hk::{CollectionIntervalFactor, HkRequest};
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
+use satrs::pus::hk::{PusHkToRequestConverter, PusService3HkHandler};
 use satrs::pus::verification::{
-    FailParams, StdVerifReporterWithSender, VerificationReporterWithSender,
+    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationReportingProvider,
+    VerificationToken,
 };
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    EcssTcReceiver, EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender,
-    PusPacketHandlerResult, PusPacketHandlingError, PusServiceBase, PusServiceHelper,
+    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
+    PusPacketHandlingError, PusServiceHelper,
 };
+use satrs::request::TargetAndApidId;
+use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket};
 use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
+use satrs::{ChannelId, TargetId};
 use satrs_example::config::{hk_err, tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
-use satrs_example::TargetIdWithApid;
-use std::collections::HashMap;
-use std::sync::mpsc::{self, Sender};
+use std::sync::mpsc::{self};
+
+use crate::requests::GenericRequestRouter;
+
+use super::GenericRoutingErrorHandler;
+
+#[derive(Default)]
+pub struct ExampleHkRequestConverter {}
+
+impl PusHkToRequestConverter for ExampleHkRequestConverter {
+    type Error = PusPacketHandlingError;
+
+    fn convert(
+        &mut self,
+        token: VerificationToken<TcStateAccepted>,
+        tc: &PusTcReader,
+        time_stamp: &[u8],
+        verif_reporter: &impl VerificationReportingProvider,
+    ) -> Result<(TargetId, HkRequest), Self::Error> {
+        let user_data = tc.user_data();
+        if user_data.is_empty() {
+            let user_data_len = user_data.len() as u32;
+            let user_data_len_raw = user_data_len.to_be_bytes();
+            verif_reporter
+                .start_failure(
+                    token,
+                    FailParams::new(
+                        time_stamp,
+                        &tmtc_err::NOT_ENOUGH_APP_DATA,
+                        &user_data_len_raw,
+                    ),
+                )
+                .expect("Sending start failure TM failed");
+            return Err(PusPacketHandlingError::NotEnoughAppData {
+                expected: 4,
+                found: 0,
+            });
+        }
+        if user_data.len() < 8 {
+            let err = if user_data.len() < 4 {
+                &hk_err::TARGET_ID_MISSING
+            } else {
+                &hk_err::UNIQUE_ID_MISSING
+            };
+            let user_data_len = user_data.len() as u32;
+            let user_data_len_raw = user_data_len.to_be_bytes();
+            verif_reporter
+                .start_failure(token, FailParams::new(time_stamp, err, &user_data_len_raw))
+                .expect("Sending start failure TM failed");
+            return Err(PusPacketHandlingError::NotEnoughAppData {
+                expected: 8,
+                found: 4,
+            });
+        }
+        let subservice = tc.subservice();
+        let target_id = TargetAndApidId::from_pus_tc(tc).expect("invalid tc format");
+        let unique_id = u32::from_be_bytes(tc.user_data()[4..8].try_into().unwrap());
+
+        let standard_subservice = hk::Subservice::try_from(subservice);
+        if standard_subservice.is_err() {
+            verif_reporter
+                .start_failure(
+                    token,
+                    FailParams::new(time_stamp, &tmtc_err::INVALID_PUS_SUBSERVICE, &[subservice]),
+                )
+                .expect("Sending start failure TM failed");
+            return Err(PusPacketHandlingError::InvalidSubservice(subservice));
+        }
+        Ok((
+            target_id.into(),
+            match standard_subservice.unwrap() {
+                hk::Subservice::TcEnableHkGeneration | hk::Subservice::TcEnableDiagGeneration => {
+                    HkRequest::Enable(unique_id)
+                }
+                hk::Subservice::TcDisableHkGeneration | hk::Subservice::TcDisableDiagGeneration => {
+                    HkRequest::Disable(unique_id)
+                }
+                hk::Subservice::TcReportHkReportStructures => todo!(),
+                hk::Subservice::TmHkPacket => todo!(),
+                hk::Subservice::TcGenerateOneShotHk | hk::Subservice::TcGenerateOneShotDiag => {
+                    HkRequest::OneShot(unique_id)
+                }
+                hk::Subservice::TcModifyDiagCollectionInterval
+                | hk::Subservice::TcModifyHkCollectionInterval => {
+                    if user_data.len() < 12 {
+                        verif_reporter
+                            .start_failure(
+                                token,
+                                FailParams::new_no_fail_data(
+                                    time_stamp,
+                                    &tmtc_err::NOT_ENOUGH_APP_DATA,
+                                ),
+                            )
+                            .expect("Sending start failure TM failed");
+                        return Err(PusPacketHandlingError::NotEnoughAppData {
+                            expected: 12,
+                            found: user_data.len(),
+                        });
+                    }
+                    HkRequest::ModifyCollectionInterval(
+                        unique_id,
+                        CollectionIntervalFactor::from_be_bytes(
+                            user_data[8..12].try_into().unwrap(),
+                        ),
+                    )
+                }
+                _ => {
+                    verif_reporter
+                        .start_failure(
+                            token,
+                            FailParams::new(
+                                time_stamp,
+                                &tmtc_err::PUS_SUBSERVICE_NOT_IMPLEMENTED,
+                                &[subservice],
+                            ),
+                        )
+                        .expect("Sending start failure TM failed");
+                    return Err(PusPacketHandlingError::InvalidSubservice(subservice));
+                }
+            },
+        ))
+    }
+}
 
 pub fn create_hk_service_static(
     shared_tm_store: SharedTmPool,
@@ -24,7 +147,7 @@ pub fn create_hk_service_static(
     verif_reporter: VerificationReporterWithSender,
     tc_pool: SharedStaticMemoryPool,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
-    request_map: HashMap<TargetIdWithApid, mpsc::Sender<RequestWithToken>>,
+    request_router: GenericRequestRouter,
 ) -> Pus3Wrapper<EcssTcInSharedStoreConverter> {
     let hk_srv_tm_sender = MpscTmInSharedPoolSender::new(
         TmSenderId::PusHk as ChannelId,
@@ -35,12 +158,16 @@ pub fn create_hk_service_static(
     let hk_srv_receiver =
         MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
     let pus_3_handler = PusService3HkHandler::new(
-        Box::new(hk_srv_receiver),
-        Box::new(hk_srv_tm_sender),
-        PUS_APID,
-        verif_reporter.clone(),
-        EcssTcInSharedStoreConverter::new(tc_pool, 2048),
-        request_map,
+        PusServiceHelper::new(
+            Box::new(hk_srv_receiver),
+            Box::new(hk_srv_tm_sender),
+            PUS_APID,
+            verif_reporter.clone(),
+            EcssTcInSharedStoreConverter::new(tc_pool, 2048),
+        ),
+        ExampleHkRequestConverter::default(),
+        request_router,
+        GenericRoutingErrorHandler::default(),
     );
     Pus3Wrapper { pus_3_handler }
 }
@@ -49,7 +176,7 @@ pub fn create_hk_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
     verif_reporter: VerificationReporterWithSender,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
-    request_map: HashMap<TargetIdWithApid, mpsc::Sender<RequestWithToken>>,
+    request_router: GenericRequestRouter,
 ) -> Pus3Wrapper<EcssTcInVecConverter> {
     let hk_srv_tm_sender = MpscTmAsVecSender::new(
         TmSenderId::PusHk as ChannelId,
@@ -59,154 +186,28 @@ pub fn create_hk_service_dynamic(
     let hk_srv_receiver =
         MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
     let pus_3_handler = PusService3HkHandler::new(
-        Box::new(hk_srv_receiver),
-        Box::new(hk_srv_tm_sender),
-        PUS_APID,
-        verif_reporter.clone(),
-        EcssTcInVecConverter::default(),
-        request_map,
+        PusServiceHelper::new(
+            Box::new(hk_srv_receiver),
+            Box::new(hk_srv_tm_sender),
+            PUS_APID,
+            verif_reporter.clone(),
+            EcssTcInVecConverter::default(),
+        ),
+        ExampleHkRequestConverter::default(),
+        request_router,
+        GenericRoutingErrorHandler::default(),
     );
     Pus3Wrapper { pus_3_handler }
 }
 
-pub struct PusService3HkHandler<TcInMemConverter: EcssTcInMemConverter> {
-    psb: PusServiceHelper<TcInMemConverter>,
-    request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
-}
-
-impl<TcInMemConverter: EcssTcInMemConverter> PusService3HkHandler<TcInMemConverter> {
-    pub fn new(
-        tc_receiver: Box<dyn EcssTcReceiver>,
-        tm_sender: Box<dyn EcssTmSender>,
-        tm_apid: u16,
-        verification_handler: StdVerifReporterWithSender,
-        tc_in_mem_converter: TcInMemConverter,
-        request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
-    ) -> Self {
-        Self {
-            psb: PusServiceHelper::new(
-                tc_receiver,
-                tm_sender,
-                tm_apid,
-                verification_handler,
-                tc_in_mem_converter,
-            ),
-            request_handlers,
-        }
-    }
-
-    fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
-        let possible_packet = self.psb.retrieve_and_accept_next_packet()?;
-        if possible_packet.is_none() {
-            return Ok(PusPacketHandlerResult::Empty);
-        }
-        let ecss_tc_and_token = possible_packet.unwrap();
-        let tc = self
-            .psb
-            .tc_in_mem_converter
-            .convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token.tc_in_memory)?;
-        let subservice = tc.subservice();
-        let mut partial_error = None;
-        let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
-        let user_data = tc.user_data();
-        if user_data.is_empty() {
-            self.psb
-                .common
-                .verification_handler
-                .borrow_mut()
-                .start_failure(
-                    ecss_tc_and_token.token,
-                    FailParams::new(Some(&time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
-                )
-                .expect("Sending start failure TM failed");
-            return Err(PusPacketHandlingError::NotEnoughAppData(
-                "Expected at least 8 bytes of app data".into(),
-            ));
-        }
-        if user_data.len() < 8 {
-            let err = if user_data.len() < 4 {
-                &hk_err::TARGET_ID_MISSING
-            } else {
-                &hk_err::UNIQUE_ID_MISSING
-            };
-            self.psb
-                .common
-                .verification_handler
-                .borrow_mut()
-                .start_failure(
-                    ecss_tc_and_token.token,
-                    FailParams::new(Some(&time_stamp), err, None),
-                )
-                .expect("Sending start failure TM failed");
-            return Err(PusPacketHandlingError::NotEnoughAppData(
-                "Expected at least 8 bytes of app data".into(),
-            ));
-        }
-        let target_id = TargetIdWithApid::from_tc(&tc).expect("invalid tc format");
-        let unique_id = u32::from_be_bytes(tc.user_data()[0..4].try_into().unwrap());
-        if !self.request_handlers.contains_key(&target_id) {
-            self.psb
-                .common
-                .verification_handler
-                .borrow_mut()
-                .start_failure(
-                    ecss_tc_and_token.token,
-                    FailParams::new(Some(&time_stamp), &hk_err::UNKNOWN_TARGET_ID, None),
-                )
-                .expect("Sending start failure TM failed");
-            return Err(PusPacketHandlingError::NotEnoughAppData(format!(
-                "Unknown target ID {target_id}"
-            )));
-        }
-        let send_request = |target: TargetIdWithApid, request: HkRequest| {
-            let sender = self.request_handlers.get(&target).unwrap();
-            sender
-                .send(RequestWithToken::new(
-                    target,
-                    Request::Hk(request),
-                    ecss_tc_and_token.token,
-                ))
-                .unwrap_or_else(|_| panic!("Sending HK request {request:?} failed"));
-        };
-        if subservice == hk::Subservice::TcEnableHkGeneration as u8 {
-            send_request(target_id, HkRequest::Enable(unique_id));
-        } else if subservice == hk::Subservice::TcDisableHkGeneration as u8 {
-            send_request(target_id, HkRequest::Disable(unique_id));
-        } else if subservice == hk::Subservice::TcGenerateOneShotHk as u8 {
-            send_request(target_id, HkRequest::OneShot(unique_id));
-        } else if subservice == hk::Subservice::TcModifyHkCollectionInterval as u8 {
-            if user_data.len() < 12 {
-                self.psb
-                    .common
-                    .verification_handler
-                    .borrow_mut()
-                    .start_failure(
-                        ecss_tc_and_token.token,
-                        FailParams::new(
-                            Some(&time_stamp),
-                            &hk_err::COLLECTION_INTERVAL_MISSING,
-                            None,
-                        ),
-                    )
-                    .expect("Sending start failure TM failed");
-                return Err(PusPacketHandlingError::NotEnoughAppData(
-                    "Collection interval missing".into(),
-                ));
-            }
-            send_request(
-                target_id,
-                HkRequest::ModifyCollectionInterval(
-                    unique_id,
-                    CollectionIntervalFactor::from_be_bytes(user_data[8..12].try_into().unwrap()),
-                ),
-            );
-        }
-        Ok(PusPacketHandlerResult::RequestHandled)
-    }
-}
-
 pub struct Pus3Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub(crate) pus_3_handler: PusService3HkHandler<TcInMemConverter>,
+    pub(crate) pus_3_handler: PusService3HkHandler<
+        TcInMemConverter,
+        VerificationReporterWithSender,
+        ExampleHkRequestConverter,
+        GenericRequestRouter,
+        GenericRoutingErrorHandler<3>,
+    >,
 }
 
 impl<TcInMemConverter: EcssTcInMemConverter> Pus3Wrapper<TcInMemConverter> {

satrs-example/src/pus/mod.rs

@@ -1,7 +1,11 @@
 use crate::tmtc::MpscStoreAndSendError;
 use log::warn;
-use satrs::pus::verification::{FailParams, StdVerifReporterWithSender};
-use satrs::pus::{EcssTcAndToken, PusPacketHandlerResult, TcInMemory};
+use satrs::pus::verification::{
+    FailParams, StdVerifReporterWithSender, VerificationReportingProvider,
+};
+use satrs::pus::{
+    EcssTcAndToken, GenericRoutingError, PusPacketHandlerResult, PusRoutingErrorHandler, TcInMemory,
+};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusServiceId;
 use satrs::spacepackets::time::cds::TimeProvider;
@@ -78,7 +82,7 @@ impl PusReceiver {
         self.stamp_helper.update_from_now();
         let accepted_token = self
             .verif_reporter
-            .acceptance_success(init_token, Some(self.stamp_helper.stamp()))
+            .acceptance_success(init_token, self.stamp_helper.stamp())
             .expect("Acceptance success failure");
         let service = PusServiceId::try_from(service);
         match service {
@@ -115,9 +119,9 @@ impl PusReceiver {
                     let result = self.verif_reporter.start_failure(
                         accepted_token,
                         FailParams::new(
-                            Some(self.stamp_helper.stamp()),
+                            self.stamp_helper.stamp(),
                             &tmtc_err::PUS_SERVICE_NOT_IMPLEMENTED,
-                            Some(&[standard_service as u8]),
+                            &[standard_service as u8],
                         ),
                     );
                     if result.is_err() {
@@ -139,9 +143,9 @@ impl PusReceiver {
                         .start_failure(
                             accepted_token,
                             FailParams::new(
-                                Some(self.stamp_helper.stamp()),
+                                self.stamp_helper.stamp(),
                                 &tmtc_err::INVALID_PUS_SUBSERVICE,
-                                Some(&[e.number]),
+                                &[e.number],
                             ),
                         )
                         .expect("Start failure verification failed")
@@ -151,3 +155,56 @@ impl PusReceiver {
         Ok(PusPacketHandlerResult::RequestHandled)
     }
 }
+
+#[derive(Default)]
+pub struct GenericRoutingErrorHandler<const SERVICE_ID: u8> {}
+
+impl<const SERVICE_ID: u8> PusRoutingErrorHandler for GenericRoutingErrorHandler<SERVICE_ID> {
+    type Error = satrs::pus::GenericRoutingError;
+
+    fn handle_error(
+        &self,
+        target_id: satrs::TargetId,
+        token: satrs::pus::verification::VerificationToken<
+            satrs::pus::verification::TcStateAccepted,
+        >,
+        _tc: &PusTcReader,
+        error: Self::Error,
+        time_stamp: &[u8],
+        verif_reporter: &impl VerificationReportingProvider,
+    ) {
+        warn!("Routing request for service {SERVICE_ID} failed: {error:?}");
+        match error {
+            GenericRoutingError::UnknownTargetId(id) => {
+                let mut fail_data: [u8; 8] = [0; 8];
+                fail_data.copy_from_slice(&id.to_be_bytes());
+                verif_reporter
+                    .start_failure(
+                        token,
+                        FailParams::new(time_stamp, &tmtc_err::UNKNOWN_TARGET_ID, &fail_data),
+                    )
+                    .expect("Sending start failure failed");
+            }
+            GenericRoutingError::SendError(_) => {
+                let mut fail_data: [u8; 8] = [0; 8];
+                fail_data.copy_from_slice(&target_id.to_be_bytes());
+                verif_reporter
+                    .start_failure(
+                        token,
+                        FailParams::new(time_stamp, &tmtc_err::ROUTING_ERROR, &fail_data),
+                    )
+                    .expect("Sending start failure failed");
+            }
+            GenericRoutingError::NotEnoughAppData { expected, found } => {
+                let mut context_info = (found as u32).to_be_bytes().to_vec();
+                context_info.extend_from_slice(&(expected as u32).to_be_bytes());
+                verif_reporter
+                    .start_failure(
+                        token,
+                        FailParams::new(time_stamp, &tmtc_err::NOT_ENOUGH_APP_DATA, &context_info),
+                    )
+                    .expect("Sending start failure failed");
+            }
+        }
+    }
+}

satrs-example/src/pus/scheduler.rs

@@ -52,7 +52,8 @@ impl TcReleaser for mpsc::Sender<Vec<u8>> {
 }
 
 pub struct Pus11Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus_11_handler: PusService11SchedHandler<TcInMemConverter, PusScheduler>,
+    pub pus_11_handler:
+        PusService11SchedHandler<TcInMemConverter, VerificationReporterWithSender, PusScheduler>,
     pub sched_tc_pool: StaticMemoryPool,
     pub releaser_buf: [u8; 4096],
     pub tc_releaser: Box<dyn TcReleaser + Send>,

satrs-example/src/pus/test.rs

@@ -2,7 +2,9 @@ use log::{info, warn};
 use satrs::params::Params;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::test::PusService17TestHandler;
-use satrs::pus::verification::{FailParams, VerificationReporterWithSender};
+use satrs::pus::verification::{
+    FailParams, VerificationReporterWithSender, VerificationReportingProvider,
+};
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender,
     MpscTmInSharedPoolSender, PusPacketHandlerResult, PusServiceHelper,
@@ -79,7 +81,7 @@ pub fn create_test_service_dynamic(
 }
 
 pub struct Service17CustomWrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus17_handler: PusService17TestHandler<TcInMemConverter>,
+    pub pus17_handler: PusService17TestHandler<TcInMemConverter, VerificationReporterWithSender>,
     pub test_srv_event_sender: Sender<(EventU32, Option<Params>)>,
 }
 
@@ -125,15 +127,13 @@ impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConve
                         .service_helper
                         .common
                         .verification_handler
-                        .get_mut()
-                        .start_success(token, Some(&stamp_buf))
+                        .start_success(token, &stamp_buf)
                         .expect("Error sending start success");
                     self.pus17_handler
                         .service_helper
                         .common
                         .verification_handler
-                        .get_mut()
-                        .completion_success(start_token, Some(&stamp_buf))
+                        .completion_success(start_token, &stamp_buf)
                         .expect("Error sending completion success");
                 } else {
                     let fail_data = [tc.subservice()];
@@ -141,13 +141,12 @@ impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConve
                         .service_helper
                         .common
                         .verification_handler
-                        .get_mut()
                         .start_failure(
                             token,
                             FailParams::new(
-                                Some(&stamp_buf),
+                                &stamp_buf,
                                 &tmtc_err::INVALID_PUS_SUBSERVICE,
-                                Some(&fail_data),
+                                &fail_data,
                             ),
                         )
                         .expect("Sending start failure verification failed");