try unifying some direct PUS handler code

satrs-example/src/pus/event.rs

@@ -1,7 +1,6 @@
 use std::sync::mpsc;
 
 use crate::pus::create_verification_reporter;
-use log::{error, warn};
 use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::event_srv::PusEventServiceHandler;
@@ -11,10 +10,11 @@ use satrs::pus::{
     EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTmSender, MpscTcReceiver,
     MpscTmAsVecSender, PartialPusHandlingError, PusServiceHelper,
 };
+use satrs::spacepackets::ecss::PusServiceId;
 use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
 use satrs_example::config::components::PUS_EVENT_MANAGEMENT;
 
-use super::HandlingStatus;
+use super::{DirectPusService, HandlingStatus};
 
 pub fn create_event_service_static(
     tm_sender: PacketSenderWithSharedPool,
@@ -62,28 +62,55 @@ pub struct EventServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcI
         PusEventServiceHandler<MpscTcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
 }
 
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusService
+    for EventServiceWrapper<TmSender, TcInMemConverter>
+{
+    const SERVICE_ID: u8 = PusServiceId::Event as u8;
+
+    const SERVICE_STR: &'static str = "events";
+}
+
 impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
     EventServiceWrapper<TmSender, TcInMemConverter>
 {
     pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
         let error_handler = |partial_error: &PartialPusHandlingError| {
-            log::warn!("PUS 5 partial error: {:?}", partial_error);
+            log::warn!(
+                "PUS {}({}) partial error: {:?}",
+                Self::SERVICE_ID,
+                Self::SERVICE_STR,
+                partial_error
+            );
         };
-        match self
+        let result = self
             .handler
-            .poll_and_handle_next_tc(error_handler, time_stamp)
+            .poll_and_handle_next_tc(error_handler, time_stamp);
-        {
+        if let Err(e) = result {
-            Ok(result) => match result {
+            log::warn!(
+                "PUS {}({}) error: {:?}",
+                Self::SERVICE_ID,
+                Self::SERVICE_STR,
+                e
+            );
+            return HandlingStatus::HandledOne;
+        }
+        match result.unwrap() {
             DirectPusPacketHandlerResult::Handled(handling_status) => return handling_status,
-                DirectPusPacketHandlerResult::CustomSubservice(invalid, _) => {
+            DirectPusPacketHandlerResult::CustomSubservice(subservice, _) => {
-                    warn!("PUS 5 invalid subservice {invalid}");
+                log::warn!(
+                    "PUS {}({}) subservice {} not implemented",
+                    Self::SERVICE_ID,
+                    Self::SERVICE_STR,
+                    subservice
+                );
             }
             DirectPusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
-                    warn!("PUS 5 subservice {subservice} not implemented");
+                log::warn!(
-                }
+                    "PUS {}({}) subservice {} not implemented",
-            },
+                    Self::SERVICE_ID,
-            Err(error) => {
+                    Self::SERVICE_STR,
-                error!("PUS 5 packet handling error: {error:?}")
+                    subservice
+                );
             }
         }
         HandlingStatus::HandledOne

satrs-example/src/pus/mod.rs

@@ -524,6 +524,11 @@ pub fn generic_pus_request_timeout_handler(
     Ok(())
 }
 
+pub trait DirectPusService {
+    const SERVICE_ID: u8;
+    const SERVICE_STR: &'static str;
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
     use std::time::Duration;

satrs-example/src/pus/scheduler.rs

@@ -2,7 +2,7 @@ use std::sync::mpsc;
 use std::time::Duration;
 
 use crate::pus::create_verification_reporter;
-use log::{error, info, warn};
+use log::info;
 use satrs::pool::{PoolProvider, StaticMemoryPool};
 use satrs::pus::scheduler::{PusScheduler, TcInfo};
 use satrs::pus::scheduler_srv::PusSchedServiceHandler;
@@ -12,11 +12,12 @@ use satrs::pus::{
     EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTmSender, MpscTcReceiver,
     MpscTmAsVecSender, PartialPusHandlingError, PusServiceHelper,
 };
+use satrs::spacepackets::ecss::PusServiceId;
 use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool};
 use satrs::ComponentId;
 use satrs_example::config::components::PUS_SCHED_SERVICE;
 
-use super::HandlingStatus;
+use super::{DirectPusService, HandlingStatus};
 
 pub trait TcReleaser {
     fn release(&mut self, sender_id: ComponentId, enabled: bool, info: &TcInfo, tc: &[u8]) -> bool;
@@ -77,6 +78,13 @@ pub struct SchedulingServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: Ec
     pub releaser_buf: [u8; 4096],
     pub tc_releaser: Box<dyn TcReleaser + Send>,
 }
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusService
+    for SchedulingServiceWrapper<TmSender, TcInMemConverter>
+{
+    const SERVICE_ID: u8 = PusServiceId::Verification as u8;
+
+    const SERVICE_STR: &'static str = "verification";
+}
 
 impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
     SchedulingServiceWrapper<TmSender, TcInMemConverter>
@@ -106,25 +114,46 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
     }
 
     pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
-        let error_handler = |patial_error: &PartialPusHandlingError| {
+        let error_handler = |partial_error: &PartialPusHandlingError| {
-            log::warn!("PUS 11 partial error: {:?}", patial_error);
+            log::warn!(
+                "PUS {}({}) partial error: {:?}",
+                Self::SERVICE_ID,
+                Self::SERVICE_STR,
+                partial_error
+            );
         };
-        match self.pus_11_handler.poll_and_handle_next_tc(
+
+        let result = self.pus_11_handler.poll_and_handle_next_tc(
             error_handler,
             time_stamp,
             &mut self.sched_tc_pool,
-        ) {
+        );
-            Ok(result) => match result {
+        if let Err(e) = result {
+            log::warn!(
+                "PUS {}({}) error: {:?}",
+                Self::SERVICE_ID,
+                Self::SERVICE_STR,
+                e
+            );
+            return HandlingStatus::HandledOne;
+        }
+        match result.unwrap() {
             DirectPusPacketHandlerResult::Handled(handling_status) => return handling_status,
-                DirectPusPacketHandlerResult::CustomSubservice(invalid, _) => {
+            DirectPusPacketHandlerResult::CustomSubservice(subservice, _) => {
-                    warn!("PUS 11 invalid subservice {invalid}");
+                log::warn!(
+                    "PUS {}({}) subservice {} not implemented",
+                    Self::SERVICE_ID,
+                    Self::SERVICE_STR,
+                    subservice
+                );
             }
             DirectPusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
-                    warn!("PUS 11 Subservice {subservice} not implemented");
+                log::warn!(
-                }
+                    "PUS {}({}) subservice {} not implemented",
-            },
+                    Self::SERVICE_ID,
-            Err(error) => {
+                    Self::SERVICE_STR,
-                error!("PUS 11 packet handling error: {error:?}")
+                    subservice
+                );
             }
         }
         HandlingStatus::HandledOne

satrs-example/src/pus/test.rs

@@ -1,5 +1,5 @@
 use crate::pus::create_verification_reporter;
-use log::{info, warn};
+use log::info;
 use satrs::event_man::{EventMessage, EventMessageU32};
 use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::test::PusService17TestHandler;
@@ -10,15 +10,13 @@ use satrs::pus::{
 };
 use satrs::pus::{EcssTcInSharedStoreConverter, PartialPusHandlingError};
 use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::PusPacket;
+use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
-use satrs::spacepackets::time::cds::CdsTime;
-use satrs::spacepackets::time::TimeWriter;
 use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
 use satrs_example::config::components::PUS_TEST_SERVICE;
 use satrs_example::config::{tmtc_err, TEST_EVENT};
 use std::sync::mpsc;
 
-use super::HandlingStatus;
+use super::{DirectPusService, HandlingStatus};
 
 pub fn create_test_service_static(
     tm_sender: PacketSenderWithSharedPool,
@@ -64,18 +62,36 @@ pub struct TestCustomServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: Ec
     pub test_srv_event_sender: mpsc::SyncSender<EventMessageU32>,
 }
 
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> DirectPusService
+    for TestCustomServiceWrapper<TmSender, TcInMemConverter>
+{
+    const SERVICE_ID: u8 = PusServiceId::Test as u8;
+
+    const SERVICE_STR: &'static str = "test";
+}
+
 impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
     TestCustomServiceWrapper<TmSender, TcInMemConverter>
 {
-    pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+    pub fn poll_and_handle_next_tc(&mut self, timestamp: &[u8]) -> HandlingStatus {
-        let error_handler = |patial_error: &PartialPusHandlingError| {
+        let error_handler = |partial_error: &PartialPusHandlingError| {
-            log::warn!("PUS 17 partial error: {:?}", patial_error);
+            log::warn!(
+                "PUS {}({}) partial error: {:?}",
+                Self::SERVICE_ID,
+                Self::SERVICE_STR,
+                partial_error
+            );
         };
         let res = self
             .handler
-            .poll_and_handle_next_tc(error_handler, time_stamp);
+            .poll_and_handle_next_tc(error_handler, timestamp);
-        if res.is_err() {
+        if let Err(e) = res {
-            warn!("PUS 17 handler error: {:?}", res.unwrap_err());
+            log::warn!(
+                "PUS {}({}) error: {:?}",
+                Self::SERVICE_ID,
+                Self::SERVICE_STR,
+                e
+            );
             return HandlingStatus::HandledOne;
         }
         match res.unwrap() {
@@ -87,7 +103,12 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
                 return handling_status;
             }
             DirectPusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
-                warn!("PUS17: Subservice {subservice} not implemented")
+                log::warn!(
+                    "PUS {}({}) subservice {} not implemented",
+                    Self::SERVICE_ID,
+                    Self::SERVICE_STR,
+                    subservice
+                );
             }
             DirectPusPacketHandlerResult::CustomSubservice(subservice, token) => {
                 let (tc, _) = PusTcReader::new(
@@ -97,29 +118,34 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
                         .tc_slice_raw(),
                 )
                 .unwrap();
-                let time_stamper = CdsTime::now_with_u16_days().unwrap();
-                let mut stamp_buf: [u8; 7] = [0; 7];
-                time_stamper.write_to_bytes(&mut stamp_buf).unwrap();
                 if subservice == 128 {
-                    info!("Generating test event");
+                    info!("generating test event");
                     self.test_srv_event_sender
                         .send(EventMessage::new(PUS_TEST_SERVICE.id(), TEST_EVENT.into()))
                         .expect("Sending test event failed");
-                    let start_token = self
+                    match self.handler.service_helper.verif_reporter().start_success(
+                        self.handler.service_helper.tm_sender(),
+                        token,
+                        timestamp,
+                    ) {
+                        Ok(started_token) => {
+                            if let Err(e) = self
                                 .handler
-                        .service_helper
-                        .verif_reporter()
-                        .start_success(self.handler.service_helper.tm_sender(), token, &stamp_buf)
-                        .expect("Error sending start success");
-                    self.handler
                                 .service_helper
                                 .verif_reporter()
                                 .completion_success(
                                     self.handler.service_helper.tm_sender(),
-                            start_token,
+                                    started_token,
-                            &stamp_buf,
+                                    timestamp,
                                 )
-                        .expect("Error sending completion success");
+                            {
+                                error_handler(&PartialPusHandlingError::Verification(e));
+                            }
+                        }
+                        Err(e) => {
+                            error_handler(&PartialPusHandlingError::Verification(e));
+                        }
+                    }
                 } else {
                     let fail_data = [tc.subservice()];
                     self.handler
@@ -129,7 +155,7 @@ impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
                             self.handler.service_helper.tm_sender(),
                             token,
                             FailParams::new(
-                                &stamp_buf,
+                                timestamp,
                                 &tmtc_err::INVALID_PUS_SUBSERVICE,
                                 &fail_data,
                             ),