it compiles again

satrs-example/src/pus/action.rs

@@ -3,7 +3,7 @@ use satrs::action::{ActionRequest, ActionRequestVariant};
 use satrs::params::WritableToBeBytes;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::action::{
-    ActionReplyPus, ActionReplyPusWithActionId, ActionRequestWithId, ActivePusActionRequest,
+    ActionReplyPus, ActionReplyPusWithActionId, ActionRequestWithId, ActivePusActionRequestStd,
     DefaultActiveActionRequestMap,
 };
 use satrs::pus::verification::{
@@ -21,7 +21,6 @@ use satrs::pus::{
 use satrs::request::{GenericMessage, TargetAndApidId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket};
-use satrs::spacepackets::time::UnixTimestamp;
 use satrs::tmtc::tm_helper::SharedTmPool;
 use satrs::ChannelId;
 use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
@@ -44,13 +43,13 @@ impl Default for ActionReplyHandler {
     }
 }
 
-impl PusReplyHandler<ActivePusActionRequest, ActionReplyPusWithActionId> for ActionReplyHandler {
+impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPusWithActionId> for ActionReplyHandler {
     type Error = EcssTmtcError;
 
     fn handle_unexpected_reply(
         &mut self,
         reply: &GenericMessage<ActionReplyPusWithActionId>,
-        tm_sender: &impl EcssTmSenderCore,
+        _tm_sender: &impl EcssTmSenderCore,
     ) {
         log::warn!("received unexpected reply for service 8: {reply:?}");
     }
@@ -58,12 +57,12 @@ impl PusReplyHandler<ActivePusActionRequest, ActionReplyPusWithActionId> for Act
     fn handle_reply(
         &mut self,
         reply: &satrs::request::GenericMessage<ActionReplyPusWithActionId>,
-        active_request: &ActivePusActionRequest,
+        active_request: &ActivePusActionRequestStd,
         verification_handler: &impl VerificationReportingProvider,
         time_stamp: &[u8],
-        tm_sender: &impl EcssTmSenderCore,
+        _tm_sender: &impl EcssTmSenderCore,
     ) -> Result<bool, Self::Error> {
-        let remove_entry = match reply.message.variant {
+        let remove_entry = match &reply.message.variant {
             ActionReplyPus::CompletionFailed { error_code, params } => {
                 let fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
                 verification_handler
@@ -71,7 +70,7 @@ impl PusReplyHandler<ActivePusActionRequest, ActionReplyPusWithActionId> for Act
                         active_request.token(),
                         FailParams::new(
                             time_stamp,
-                            &error_code,
+                            error_code,
                             &self.fail_data_buf[..fail_data_len],
                         ),
                     )
@@ -89,8 +88,8 @@ impl PusReplyHandler<ActivePusActionRequest, ActionReplyPusWithActionId> for Act
                         active_request.token(),
                         FailParamsWithStep::new(
                             time_stamp,
-                            &EcssEnumU16::new(step),
-                            &error_code,
+                            &EcssEnumU16::new(*step),
+                            error_code,
                             &self.fail_data_buf[..fail_data_len],
                         ),
                     )
@@ -107,7 +106,7 @@ impl PusReplyHandler<ActivePusActionRequest, ActionReplyPusWithActionId> for Act
                 verification_handler.step_success(
                     &active_request.token(),
                     time_stamp,
-                    EcssEnumU16::new(step),
+                    EcssEnumU16::new(*step),
                 )?;
                 false
             }
@@ -130,7 +129,7 @@ impl PusReplyHandler<ActivePusActionRequest, ActionReplyPusWithActionId> for Act
 #[derive(Default)]
 pub struct ExampleActionRequestConverter {}
 
-impl PusTcToRequestConverter<ActivePusActionRequest, ActionRequestWithId>
+impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequestWithId>
     for ExampleActionRequestConverter
 {
     type Error = PusPacketHandlingError;
@@ -141,7 +140,7 @@ impl PusTcToRequestConverter<ActivePusActionRequest, ActionRequestWithId>
         tc: &PusTcReader,
         time_stamp: &[u8],
         verif_reporter: &impl VerificationReportingProvider,
-    ) -> Result<(ActivePusActionRequest, ActionRequestWithId), Self::Error> {
+    ) -> Result<(ActivePusActionRequestStd, ActionRequestWithId), Self::Error> {
         let subservice = tc.subservice();
         let user_data = tc.user_data();
         if user_data.len() < 8 {
@@ -163,11 +162,10 @@ impl PusTcToRequestConverter<ActivePusActionRequest, ActionRequestWithId>
                 .start_success(token, time_stamp)
                 .map_err(|e| e.0)?;
             Ok((
-                ActivePusActionRequest::new(
+                ActivePusActionRequestStd::new(
                     action_id,
                     target_id_and_apid.into(),
                     token,
-                    UnixTimestamp::from_now().unwrap(),
                     Duration::from_secs(30),
                 ),
                 ActionRequestWithId {
@@ -309,7 +307,7 @@ pub struct Pus8Wrapper<
         ExampleActionRequestConverter,
         ActionReplyHandler,
         DefaultActiveActionRequestMap,
-        ActivePusActionRequest,
+        ActivePusActionRequestStd,
         ActionRequestWithId,
         ActionReplyPusWithActionId,
     >,

satrs-example/src/pus/hk.rs

@@ -6,7 +6,7 @@ use satrs::pus::verification::{
     VerificationReporterWithVecMpscSender, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    ActivePusRequest, ActiveRequestProvider, DefaultActiveRequestMap, EcssTcAndToken,
+    ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap, EcssTcAndToken,
     EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTcReceiverCore,
     EcssTmSenderCore, MpscTcReceiver, PusPacketHandlerResult, PusPacketHandlingError,
     PusReplyHandler, PusServiceHelper, PusTcToRequestConverter, TmAsVecSenderWithId,
@@ -15,9 +15,8 @@ use satrs::pus::{
 use satrs::request::TargetAndApidId;
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket};
-use satrs::spacepackets::time::UnixTimestamp;
 use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::{ChannelId, TargetId};
+use satrs::ChannelId;
 use satrs_example::config::{hk_err, tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
 use std::sync::mpsc::{self};
 use std::time::Duration;
@@ -31,25 +30,16 @@ pub enum HkReply {
     Ack,
 }
 
-pub struct HkReplyHandler {
-    fail_data_buf: [u8; 128],
-}
+#[derive(Default)]
+pub struct HkReplyHandler {}
 
-impl Default for HkReplyHandler {
-    fn default() -> Self {
-        Self {
-            fail_data_buf: [0; 128],
-        }
-    }
-}
-
-impl PusReplyHandler<ActivePusRequest, HkReply> for HkReplyHandler {
+impl PusReplyHandler<ActivePusRequestStd, HkReply> for HkReplyHandler {
     type Error = ();
 
     fn handle_unexpected_reply(
         &mut self,
         reply: &satrs::request::GenericMessage<HkReply>,
-        tm_sender: &impl EcssTmSenderCore,
+        _tm_sender: &impl EcssTmSenderCore,
     ) {
         log::warn!("received unexpected reply for service 3: {reply:?}");
     }
@@ -57,27 +47,35 @@ impl PusReplyHandler<ActivePusRequest, HkReply> for HkReplyHandler {
     fn handle_reply(
         &mut self,
         reply: &satrs::request::GenericMessage<HkReply>,
-        active_request: &ActivePusRequest,
+        active_request: &ActivePusRequestStd,
         verification_handler: &impl VerificationReportingProvider,
         time_stamp: &[u8],
-        tm_sender: &impl EcssTmSenderCore,
+        _tm_sender: &impl EcssTmSenderCore,
     ) -> Result<bool, Self::Error> {
-        let remove_entry = match reply.message {
+        match reply.message {
             HkReply::Ack => {
                 verification_handler
                     .completion_success(active_request.token(), time_stamp)
                     .expect("Sending end success TM failed");
-                true
             }
         };
-        Ok(remove_entry)
+        Ok(true)
     }
 }
 
-#[derive(Default)]
-pub struct ExampleHkRequestConverter {}
+pub struct ExampleHkRequestConverter {
+    timeout: Duration,
+}
 
-impl PusTcToRequestConverter<ActivePusRequest, HkRequest> for ExampleHkRequestConverter {
+impl Default for ExampleHkRequestConverter {
+    fn default() -> Self {
+        Self {
+            timeout: Duration::from_secs(60),
+        }
+    }
+}
+
+impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for ExampleHkRequestConverter {
     type Error = PusPacketHandlingError;
 
     fn convert(
@@ -86,7 +84,7 @@ impl PusTcToRequestConverter<ActivePusRequest, HkRequest> for ExampleHkRequestCo
         tc: &PusTcReader,
         time_stamp: &[u8],
         verif_reporter: &impl VerificationReportingProvider,
-    ) -> Result<(ActivePusRequest, HkRequest), Self::Error> {
+    ) -> Result<(ActivePusRequestStd, HkRequest), Self::Error> {
         let user_data = tc.user_data();
         if user_data.is_empty() {
             let user_data_len = user_data.len() as u32;
@@ -188,13 +186,7 @@ impl PusTcToRequestConverter<ActivePusRequest, HkRequest> for ExampleHkRequestCo
             .start_success(token, time_stamp)
             .map_err(|e| e.0)?;
         Ok((
-            ActivePusRequest::new(
-                target_id_and_apid.into(),
-                token,
-                UnixTimestamp::from_now().unwrap(),
-                Duration::from_secs(60),
-            )
-            .into(),
+            ActivePusRequestStd::new(target_id_and_apid.into(), token, self.timeout),
             request,
         ))
     }
@@ -284,8 +276,8 @@ pub struct Pus3Wrapper<
         VerificationReporter,
         ExampleHkRequestConverter,
         HkReplyHandler,
-        DefaultActiveRequestMap<ActivePusRequest>,
-        ActivePusRequest,
+        DefaultActiveRequestMap<ActivePusRequestStd>,
+        ActivePusRequestStd,
         HkRequest,
         HkReply,
     >,

satrs-example/src/pus/mod.rs

@@ -4,8 +4,9 @@ use log::warn;
 use satrs::pus::verification::{self, FailParams, VerificationReportingProvider};
 use satrs::pus::{
     ActiveRequestMapProvider, ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter,
-    EcssTcReceiverCore, EcssTmSenderCore, PusPacketHandlerResult, PusPacketHandlingError,
-    PusReplyHandler, PusRequestRouter, PusServiceHelper, PusTcToRequestConverter, TcInMemory,
+    EcssTcReceiverCore, EcssTmSenderCore, GenericRoutingError, PusPacketHandlerResult,
+    PusPacketHandlingError, PusReplyHandler, PusRequestRouter, PusServiceHelper,
+    PusTcToRequestConverter, TcInMemory,
 };
 use satrs::request::GenericMessage;
 use satrs::spacepackets::ecss::tc::PusTcReader;
@@ -120,6 +121,8 @@ impl<
         RequestType,
         ReplyType,
     >
+where
+    GenericRequestRouter: PusRequestRouter<RequestType, Error = GenericRoutingError>,
 {
     pub fn new(
         service_helper: PusServiceHelper<
@@ -156,27 +159,26 @@ impl<
             .service_helper
             .tc_in_mem_converter
             .convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token.tc_in_memory)?;
-        let mut partial_error = None;
-        let (active_request, action_request) = self.request_converter.convert(
+        let (request_info, request) = self.request_converter.convert(
             ecss_tc_and_token.token,
             &tc,
-            &time_stamp,
+            time_stamp,
             &self.service_helper.common.verification_handler,
         )?;
-        if let Err(e) = self.request_router.route(
-            active_request.target_id(),
-            action_request,
-            ecss_tc_and_token.token,
-        ) {
-            let verif_request_id = verification::RequestId::new(&tc);
+        let verif_request_id = verification::RequestId::new(&tc);
+        if let Err(e) =
+            self.request_router
+                .route(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(), active_request);
+                .insert(&verif_request_id.into(), request_info);
             self.request_router.handle_error(
-                active_request.target_id(),
+                target_id,
                 ecss_tc_and_token.token,
                 &tc,
                 e.clone(),
-                &time_stamp,
+                time_stamp,
                 &self.service_helper.common.verification_handler,
             );
             return Err(e.into());
@@ -184,9 +186,7 @@ impl<
         Ok(PusPacketHandlerResult::RequestHandled)
     }
 
-    pub fn insert_reply(&mut self, reply: &GenericMessage<ReplyType>) {
-        // self.reply_hook.insert_reply(reply, &self.active_request_map);
-    }
+    pub fn insert_reply(&mut self, reply: &GenericMessage<ReplyType>) {}
 }
 
 impl<VerificationReporter: VerificationReportingProvider> PusReceiver<VerificationReporter> {

satrs-example/src/pus/stack.rs

@@ -68,8 +68,8 @@ impl<
             is_srv_finished(self.test_srv.handle_next_packet(&time_stamp));
             is_srv_finished(self.schedule_srv.handle_next_packet(&time_stamp));
             is_srv_finished(self.event_srv.handle_next_packet(&time_stamp));
-            is_srv_finished(self.action_srv.handle_next_packet());
-            is_srv_finished(self.hk_srv.handle_next_packet());
+            is_srv_finished(self.action_srv.handle_next_packet(&time_stamp));
+            is_srv_finished(self.hk_srv.handle_next_packet(&time_stamp));
             if all_queues_empty {
                 break;
             }

satrs-example/src/requests.rs

@@ -3,9 +3,9 @@ use std::sync::mpsc;
 
 use derive_new::new;
 use log::warn;
-use satrs::action::ActionRequest;
 use satrs::hk::HkRequest;
 use satrs::mode::ModeRequest;
+use satrs::pus::action::ActionRequestWithId;
 use satrs::pus::verification::{
     FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
 };
@@ -17,21 +17,21 @@ use satrs::TargetId;
 use satrs_example::config::tmtc_err;
 
 #[allow(dead_code)]
-#[derive(Clone, Eq, PartialEq, Debug)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum Request {
     Hk(HkRequest),
     Mode(ModeRequest),
-    Action(ActionRequest),
+    Action(ActionRequestWithId),
 }
 
-#[derive(Clone, Eq, PartialEq, Debug, new)]
+#[derive(Clone, Debug, new)]
 pub struct TargetedRequest {
     pub(crate) target_id: TargetId,
     pub(crate) request: Request,
 }
 
-#[derive(Clone, Eq, PartialEq, Debug)]
+#[derive(Clone, Debug)]
 pub struct RequestWithToken {
     pub(crate) targeted_request: TargetedRequest,
     pub(crate) token: VerificationToken<TcStateAccepted>,
@@ -138,13 +138,13 @@ impl PusRequestRouter<HkRequest> for GenericRequestRouter {
     }
 }
 
-impl PusRequestRouter<ActionRequest> for GenericRequestRouter {
+impl PusRequestRouter<ActionRequestWithId> for GenericRequestRouter {
     type Error = GenericRoutingError;
 
     fn route(
         &self,
         target_id: TargetId,
-        action_request: ActionRequest,
+        action_request: ActionRequestWithId,
         token: VerificationToken<TcStateAccepted>,
     ) -> Result<(), Self::Error> {
         if let Some(sender) = self.0.get(&target_id) {