First PUS handler abstraction with request mapping

This is the first attempt of a generic PUS service abstraction where
the PUS telecommands need to be converted into targetted requests.

satrs-example/src/pus/action.rs

@@ -1,23 +1,74 @@
-use crate::requests::{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,
 };
 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: &mut VerificationReporterWithSender,
+    ) -> 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(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 = 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::ActionIdAndVecData {
+                    action_id,
+                    data: user_data[8..].to_vec(),
+                },
+            ))
+        } else {
+            verif_reporter
+                .start_failure(
+                    token,
+                    FailParams::new(Some(time_stamp), &tmtc_err::INVALID_PUS_SUBSERVICE, None),
+                )
+                .expect("Sending start failure failed");
+            Err(PusPacketHandlingError::InvalidSubservice(subservice))
+        }
+    }
+}
 
 pub fn create_action_service_static(
     shared_tm_store: SharedTmPool,
@@ -25,7 +76,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,
@@ -39,12 +90,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 }
 }
@@ -53,7 +108,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,
@@ -66,146 +121,27 @@ 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::ActionIdAndVecData((
-                        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,
+        ExampleActionRequestConverter,
+        GenericRequestRouter,
+        GenericRoutingErrorHandler<8>,
+    >,
 }
 
 impl<TcInMemConverter: EcssTcInMemConverter> Pus8Wrapper<TcInMemConverter> {

satrs-example/src/pus/hk.rs

@@ -1,122 +1,46 @@
-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, 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};
 
-pub fn create_hk_service_static(
-    shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
-    tc_pool: SharedStaticMemoryPool,
-    pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
-    request_map: HashMap<TargetIdWithApid, mpsc::Sender<RequestWithToken>>,
-) -> Pus3Wrapper<EcssTcInSharedStoreConverter> {
-    let hk_srv_tm_sender = MpscTmInSharedPoolSender::new(
-        TmSenderId::PusHk as ChannelId,
-        "PUS_3_TM_SENDER",
-        shared_tm_store.clone(),
-        tm_funnel_tx.clone(),
-    );
-    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,
-    );
-    Pus3Wrapper { pus_3_handler }
-}
+use crate::requests::GenericRequestRouter;
 
-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>>,
-) -> Pus3Wrapper<EcssTcInVecConverter> {
-    let hk_srv_tm_sender = MpscTmAsVecSender::new(
-        TmSenderId::PusHk as ChannelId,
-        "PUS_3_TM_SENDER",
-        tm_funnel_tx.clone(),
-    );
-    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,
-    );
-    Pus3Wrapper { pus_3_handler }
-}
+use super::GenericRoutingErrorHandler;
 
-pub struct PusService3HkHandler<TcInMemConverter: EcssTcInMemConverter> {
-    psb: PusServiceHelper<TcInMemConverter>,
-    request_handlers: HashMap<TargetIdWithApid, Sender<RequestWithToken>>,
-}
+#[derive(Default)]
+pub struct ExampleHkRequestConverter {}
 
-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,
-        }
-    }
+impl PusHkToRequestConverter for ExampleHkRequestConverter {
+    type Error = PusPacketHandlingError;
 
-    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);
+    fn convert(
+        &mut self,
+        token: VerificationToken<TcStateAccepted>,
+        tc: &PusTcReader,
+        time_stamp: &[u8],
+        verif_reporter: &mut VerificationReporterWithSender,
+    ) -> Result<(TargetId, HkRequest), Self::Error> {
         let user_data = tc.user_data();
         if user_data.is_empty() {
-            self.psb
-                .common
-                .verification_handler
-                .borrow_mut()
+            verif_reporter
                 .start_failure(
-                    ecss_tc_and_token.token,
-                    FailParams::new(Some(&time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
+                    token,
+                    FailParams::new(Some(time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
                 )
                 .expect("Sending start failure TM failed");
             return Err(PusPacketHandlingError::NotEnoughAppData(
@@ -129,84 +53,153 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService3HkHandler<TcInMemConvert
             } 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),
-                )
+            verif_reporter
+                .start_failure(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()
+        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(
-                    ecss_tc_and_token.token,
-                    FailParams::new(Some(&time_stamp), &hk_err::UNKNOWN_TARGET_ID, None),
+                    token,
+                    FailParams::new(
+                        Some(time_stamp),
+                        &tmtc_err::INVALID_PUS_SUBSERVICE,
+                        Some(&[subservice]),
+                    ),
                 )
                 .expect("Sending start failure TM failed");
-            return Err(PusPacketHandlingError::NotEnoughAppData(format!(
-                "Unknown target ID {target_id}"
-            )));
+            return Err(PusPacketHandlingError::InvalidSubservice(subservice));
         }
-        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,
+        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(
+                                    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(),
+                        ));
+                    }
+                    HkRequest::ModifyCollectionInterval(
+                        unique_id,
+                        CollectionIntervalFactor::from_be_bytes(
+                            user_data[8..12].try_into().unwrap(),
                         ),
                     )
-                    .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)
+                }
+                _ => {
+                    verif_reporter
+                        .start_failure(
+                            token,
+                            FailParams::new(
+                                Some(time_stamp),
+                                &tmtc_err::PUS_SUBSERVICE_NOT_IMPLEMENTED,
+                                Some(&[subservice]),
+                            ),
+                        )
+                        .expect("Sending start failure TM failed");
+                    return Err(PusPacketHandlingError::InvalidSubservice(subservice));
+                }
+            },
+        ))
     }
 }
 
+pub fn create_hk_service_static(
+    shared_tm_store: SharedTmPool,
+    tm_funnel_tx: mpsc::Sender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSender,
+    tc_pool: SharedStaticMemoryPool,
+    pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
+    request_router: GenericRequestRouter,
+) -> Pus3Wrapper<EcssTcInSharedStoreConverter> {
+    let hk_srv_tm_sender = MpscTmInSharedPoolSender::new(
+        TmSenderId::PusHk as ChannelId,
+        "PUS_3_TM_SENDER",
+        shared_tm_store.clone(),
+        tm_funnel_tx.clone(),
+    );
+    let hk_srv_receiver =
+        MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
+    let pus_3_handler = PusService3HkHandler::new(
+        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 }
+}
+
+pub fn create_hk_service_dynamic(
+    tm_funnel_tx: mpsc::Sender<Vec<u8>>,
+    verif_reporter: VerificationReporterWithSender,
+    pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
+    request_router: GenericRequestRouter,
+) -> Pus3Wrapper<EcssTcInVecConverter> {
+    let hk_srv_tm_sender = MpscTmAsVecSender::new(
+        TmSenderId::PusHk as ChannelId,
+        "PUS_3_TM_SENDER",
+        tm_funnel_tx.clone(),
+    );
+    let hk_srv_receiver =
+        MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
+    let pus_3_handler = PusService3HkHandler::new(
+        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 Pus3Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub(crate) pus_3_handler: PusService3HkHandler<TcInMemConverter>,
+    pub(crate) pus_3_handler: PusService3HkHandler<
+        TcInMemConverter,
+        ExampleHkRequestConverter,
+        GenericRequestRouter,
+        GenericRoutingErrorHandler<3>,
+    >,
 }
 
 impl<TcInMemConverter: EcssTcInMemConverter> Pus3Wrapper<TcInMemConverter> {

satrs-example/src/pus/mod.rs

@@ -1,7 +1,9 @@
 use crate::tmtc::MpscStoreAndSendError;
 use log::warn;
 use satrs::pus::verification::{FailParams, StdVerifReporterWithSender};
-use satrs::pus::{EcssTcAndToken, PusPacketHandlerResult, TcInMemory};
+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;
@@ -151,3 +153,62 @@ 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: &mut satrs::pus::verification::VerificationReporterWithSender,
+    ) {
+        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(
+                            Some(time_stamp),
+                            &tmtc_err::UNKNOWN_TARGET_ID,
+                            Some(&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(
+                            Some(time_stamp),
+                            &tmtc_err::ROUTING_ERROR,
+                            Some(&fail_data),
+                        ),
+                    )
+                    .expect("Sending start failure failed");
+            }
+            GenericRoutingError::NotEnoughAppData => {
+                verif_reporter
+                    .start_failure(
+                        token,
+                        FailParams::new(Some(time_stamp), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
+                    )
+                    .expect("Sending start failure failed");
+            }
+        }
+    }
+}