Continue update

satrs/tests/hk_helpers.rs

@@ -2,7 +2,7 @@
 use core::mem::size_of;
 use serde::{Deserialize, Serialize};
 use spacepackets::ecss::{PfcReal, PfcUnsigned, Ptc};
-use spacepackets::time::cds::TimeProvider;
+use spacepackets::time::cds::CdsTime;
 use spacepackets::time::{CcsdsTimeProvider, TimeWriter};
 
 enum NumOfParamsInfo {
@@ -36,7 +36,7 @@ struct TestMgmHkWithIndividualValidity {
 
 #[derive(Serialize, Deserialize)]
 struct TestMgmHkWithGroupValidity {
-    last_valid_stamp: TimeProvider,
+    last_valid_stamp: CdsTime,
     valid: bool,
     temp: f32,
     mgm_vals: [u16; 3],
@@ -150,7 +150,7 @@ pub fn main() {
     // The easiest and probably best approach, trading off big advantages for TM downlink capacity:
     // Use a JSON format
     let mgm_hk_group_validity = TestMgmHkWithGroupValidity {
-        last_valid_stamp: TimeProvider::from_now_with_u16_days().unwrap(),
+        last_valid_stamp: CdsTime::now_with_u16_days().unwrap(),
         valid: false,
         temp: 20.0,
         mgm_vals: [0x1f1f, 0x2f2f, 0x3f3f],

satrs/tests/mode_tree.rs

@@ -1,13 +1,12 @@
 use core::cell::Cell;
 use std::{println, sync::mpsc};
 
-use satrs::action::ActionRequest;
 use satrs::mode::{
     ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, ModeRequestHandler,
     ModeRequestHandlerMpscBounded, ModeRequestReceiver, ModeRequestorAndHandlerMpscBounded,
     ModeRequestorBoundedMpsc,
 };
-use satrs::request::RequestId;
+use satrs::request::{MessageMetadata, RequestId};
 use satrs::{
     mode::{ModeAndSubmode, ModeReply, ModeRequest},
     queue::GenericTargetedMessagingError,
@@ -46,11 +45,30 @@ struct TestDevice {
     pub name: String,
     pub mode_node: ModeRequestHandlerMpscBounded,
     pub mode_and_submode: ModeAndSubmode,
-    pub mode_requestor_info: Option<(RequestId, ComponentId)>,
-    // pub action_queue: mpsc::Receiver<GenericMessage<ActionRequest>>,
+    pub mode_requestor_info: Option<MessageMetadata>,
 }
 
-pub struct ModeLeafDeviceHelper {}
+fn mode_leaf_node_req_handler(
+    handler: &mut impl ModeRequestHandler,
+    request: GenericMessage<ModeRequest>,
+) {
+    match request.message {
+        ModeRequest::SetMode(mode_and_submode) => {
+            handler
+                .start_transition(request.requestor_info, mode_and_submode)
+                .unwrap();
+        }
+        ModeRequest::ReadMode => handler
+            .send_mode_reply(
+                request.requestor_info,
+                ModeReply::ModeReply(handler.mode_and_submode()),
+            )
+            .unwrap(),
+        ModeRequest::AnnounceMode => handler.announce_mode(request.requestor_info, false),
+        ModeRequest::AnnounceModeRecursive => handler.announce_mode(request.requestor_info, true),
+        ModeRequest::ModeInfo(_) => todo!(),
+    }
+}
 
 impl TestDevice {
     pub fn run(&mut self) {
@@ -61,24 +79,22 @@ impl TestDevice {
         if let Some(request) = self.mode_node.try_recv_mode_request()? {
             match request.message {
                 ModeRequest::SetMode(mode_and_submode) => {
-                    self.start_transition(request.request_id, request.sender_id, mode_and_submode)
+                    self.start_transition(request.requestor_info, mode_and_submode)
                         .unwrap();
-                    self.mode_requestor_info = Some((request.request_id, request.sender_id));
+                    self.mode_requestor_info = Some(request.requestor_info);
                 }
                 ModeRequest::ReadMode => self
                     .mode_node
                     .send_mode_reply(
-                        request.request_id,
-                        request.sender_id,
+                        request.requestor_info,
                         ModeReply::ModeReply(self.mode_and_submode),
                     )
                     .unwrap(),
-                ModeRequest::AnnounceMode => {
-                    self.announce_mode(request.request_id, request.sender_id, false)
-                }
+                ModeRequest::AnnounceMode => self.announce_mode(request.requestor_info, false),
                 ModeRequest::AnnounceModeRecursive => {
-                    self.announce_mode(request.request_id, request.sender_id, true)
+                    self.announce_mode(request.requestor_info, true)
                 }
+                ModeRequest::ModeInfo(_) => todo!(),
             }
         }
         Ok(())
@@ -90,39 +106,49 @@ impl ModeProvider for TestDevice {
         self.mode_and_submode
     }
 }
+
 impl ModeRequestHandler for TestDevice {
     fn start_transition(
         &mut self,
-        _request_id: RequestId,
-        _sender_id: ComponentId,
+        requestor: MessageMetadata,
         mode_and_submode: ModeAndSubmode,
     ) -> Result<(), ModeError> {
         self.mode_and_submode = mode_and_submode;
-        self.handle_mode_reached()?;
+        self.handle_mode_reached(Some(requestor))?;
         Ok(())
     }
 
-    fn announce_mode(&self, _request_id: RequestId, _sender_id: ComponentId, _recursive: bool) {
+    fn announce_mode(&self, requestor_info: MessageMetadata, _recursive: bool) {
         println!(
             "{}: announcing mode: {:?}",
             self.name, self.mode_and_submode
         );
     }
 
-    fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError> {
-        let (req_id, sender_id) = self.mode_requestor_info.unwrap();
-        self.mode_node.send_mode_reply(
-            req_id,
-            sender_id,
-            ModeReply::ModeReply(self.mode_and_submode),
-        )?;
+    fn handle_mode_reached(
+        &mut self,
+
+        requestor: Option<MessageMetadata>,
+    ) -> Result<(), GenericTargetedMessagingError> {
+        if let Some(requestor) = requestor {
+            self.send_mode_reply(requestor, ModeReply::ModeReply(self.mode_and_submode))?;
+        }
+        Ok(())
+    }
+    fn send_mode_reply(
+        &self,
+        requestor_info: MessageMetadata,
+        reply: ModeReply,
+    ) -> Result<(), GenericTargetedMessagingError> {
+        self.mode_node
+            .send_mode_reply(requestor_info, ModeReply::ModeReply(self.mode_and_submode))?;
         Ok(())
     }
 }
 
 struct TestAssembly {
     pub mode_node: ModeRequestorAndHandlerMpscBounded,
-    pub mode_requestor_info: Option<(RequestId, ComponentId)>,
+    pub mode_requestor_info: Option<MessageMetadata>,
     pub mode_and_submode: ModeAndSubmode,
     pub target_mode_and_submode: Option<ModeAndSubmode>,
 }
@@ -143,23 +169,21 @@ impl TestAssembly {
         if let Some(request) = self.mode_node.try_recv_mode_request()? {
             match request.message {
                 ModeRequest::SetMode(mode_and_submode) => {
-                    self.start_transition(request.request_id, request.sender_id, mode_and_submode)
+                    self.start_transition(request.requestor_info, mode_and_submode)
                         .unwrap();
                 }
                 ModeRequest::ReadMode => self
                     .mode_node
                     .send_mode_reply(
-                        request.request_id,
-                        request.sender_id,
+                        request.requestor_info,
                         ModeReply::ModeReply(self.mode_and_submode),
                     )
                     .unwrap(),
-                ModeRequest::AnnounceMode => {
-                    self.announce_mode(request.request_id, request.sender_id, false)
-                }
+                ModeRequest::AnnounceMode => self.announce_mode(request.requestor_info, false),
                 ModeRequest::AnnounceModeRecursive => {
-                    self.announce_mode(request.request_id, request.sender_id, true)
+                    self.announce_mode(request.requestor_info, true)
                 }
+                ModeRequest::ModeInfo(_) => todo!(),
             }
         }
         Ok(())
@@ -168,18 +192,20 @@ impl TestAssembly {
     pub fn check_mode_replies(&mut self) -> Result<(), GenericTargetedMessagingError> {
         if let Some(reply_and_id) = self.mode_node.try_recv_mode_reply()? {
             match reply_and_id.message {
-                ModeReply::ModeInfo(_) => todo!(),
                 ModeReply::ModeReply(reply) => {
                     println!(
                         "TestAssembly: Received mode reply from {:?}, reached: {:?}",
-                        reply_and_id.sender_id, reply
+                        reply_and_id.sender_id(),
+                        reply
                     );
                 }
                 ModeReply::CantReachMode(_) => todo!(),
                 ModeReply::WrongMode { expected, reached } => {
                     println!(
                         "TestAssembly: Wrong mode reply from {:?}, reached {:?}, expected {:?}",
-                        reply_and_id.sender_id, reached, expected
+                        reply_and_id.sender_id(),
+                        reached,
+                        expected
                     );
                 }
             }
@@ -191,16 +217,15 @@ impl TestAssembly {
 impl ModeRequestHandler for TestAssembly {
     fn start_transition(
         &mut self,
-        request_id: RequestId,
-        sender_id: ComponentId,
+        requestor: MessageMetadata,
         mode_and_submode: ModeAndSubmode,
     ) -> Result<(), ModeError> {
-        self.mode_requestor_info = Some((request_id, sender_id));
+        self.mode_requestor_info = Some(requestor);
         self.target_mode_and_submode = Some(mode_and_submode);
         Ok(())
     }
 
-    fn announce_mode(&self, request_id: RequestId, _sender_id: ComponentId, recursive: bool) {
+    fn announce_mode(&self, requestor_info: MessageMetadata, recursive: bool) {
         println!(
             "TestAssembly: Announcing mode (recursively: {}): {:?}",
             recursive, self.mode_and_submode
@@ -217,21 +242,33 @@ impl ModeRequestHandler for TestAssembly {
             .for_each(|(_, sender)| {
                 sender
                     .send(GenericMessage::new(
-                        request_id,
-                        self.mode_node.local_channel_id_generic(),
+                        MessageMetadata::new(
+                            requestor_info.request_id(),
+                            self.mode_node.local_channel_id_generic(),
+                        ),
                         mode_request,
                     ))
                     .expect("sending mode request failed");
             });
     }
 
-    fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError> {
-        let (req_id, sender_id) = self.mode_requestor_info.unwrap();
-        self.mode_node.send_mode_reply(
-            req_id,
-            sender_id,
-            ModeReply::ModeReply(self.mode_and_submode),
-        )?;
+    fn handle_mode_reached(
+        &mut self,
+        mode_requestor: Option<MessageMetadata>,
+    ) -> Result<(), GenericTargetedMessagingError> {
+        if let Some(requestor) = mode_requestor {
+            self.send_mode_reply(requestor, ModeReply::ModeReply(self.mode_and_submode))?;
+        }
+        Ok(())
+    }
+
+    fn send_mode_reply(
+        &self,
+        requestor: MessageMetadata,
+        reply: ModeReply,
+    ) -> Result<(), GenericTargetedMessagingError> {
+        self.mode_node
+            .send_mode_reply(requestor, ModeReply::ModeReply(self.mode_and_submode))?;
         Ok(())
     }
 }

satrs/tests/pus_events.rs

@@ -5,7 +5,8 @@ use satrs::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo};
 use satrs::params::U32Pair;
 use satrs::params::{Params, ParamsHeapless, WritableToBeBytes};
 use satrs::pus::event_man::{DefaultPusEventMgmtBackend, EventReporter, PusEventDispatcher};
-use satrs::pus::TmAsVecSenderWithMpsc;
+use satrs::pus::PusTmAsVec;
+use satrs::request::UniqueApidTargetId;
 use spacepackets::ecss::tm::PusTmReader;
 use spacepackets::ecss::{PusError, PusPacket};
 use std::sync::mpsc::{self, SendError, TryRecvError};
@@ -15,6 +16,8 @@ const INFO_EVENT: EventU32TypedSev<SeverityInfo> =
     EventU32TypedSev::<SeverityInfo>::const_new(1, 0);
 const LOW_SEV_EVENT: EventU32 = EventU32::const_new(Severity::LOW, 1, 5);
 const EMPTY_STAMP: [u8; 7] = [0; 7];
+const TEST_APID: u16 = 0x02;
+const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05);
 
 #[derive(Debug, Clone)]
 pub enum CustomTmSenderError {
@@ -32,13 +35,12 @@ fn test_threaded_usage() {
     let pus_event_man_send_provider = EventU32SenderMpsc::new(1, pus_event_man_tx);
     event_man.subscribe_all(pus_event_man_send_provider.target_id());
     event_man.add_sender(pus_event_man_send_provider);
-    let (event_tx, event_rx) = mpsc::channel();
-    let reporter = EventReporter::new(0x02, 128).expect("Creating event reporter failed");
-    let mut pus_event_man =
-        PusEventDispatcher::new(reporter, DefaultPusEventMgmtBackend::default());
+    let (event_tx, event_rx) = mpsc::channel::<PusTmAsVec>();
+    let reporter =
+        EventReporter::new(TEST_ID.raw(), 0x02, 128).expect("Creating event reporter failed");
+    let pus_event_man = PusEventDispatcher::new(reporter, DefaultPusEventMgmtBackend::default());
     // PUS + Generic event manager thread
     let jh0 = thread::spawn(move || {
-        let mut sender = TmAsVecSenderWithMpsc::new(0, "event_sender", event_tx);
         let mut event_cnt = 0;
         let mut params_array: [u8; 128] = [0; 128];
         loop {
@@ -46,9 +48,9 @@ fn test_threaded_usage() {
             assert!(res.is_ok());
             match pus_event_man_rx.try_recv() {
                 Ok((event, aux_data)) => {
-                    let mut gen_event = |aux_data| {
+                    let gen_event = |aux_data| {
                         pus_event_man.generate_pus_event_tm_generic(
-                            &mut sender,
+                            &event_tx,
                             &EMPTY_STAMP,
                             event,
                             aux_data,
@@ -101,8 +103,8 @@ fn test_threaded_usage() {
             match event_rx.try_recv() {
                 // Event TM received successfully
                 Ok(event_tm) => {
-                    let tm =
-                        PusTmReader::new(event_tm.as_slice(), 7).expect("Deserializing TM failed");
+                    let tm = PusTmReader::new(event_tm.packet.as_slice(), 7)
+                        .expect("Deserializing TM failed");
                     assert_eq!(tm.0.service(), 5);
                     assert_eq!(tm.0.subservice(), 1);
                     let src_data = tm.0.source_data();
@@ -127,8 +129,8 @@ fn test_threaded_usage() {
             match event_rx.try_recv() {
                 // Event TM received successfully
                 Ok(event_tm) => {
-                    let tm =
-                        PusTmReader::new(event_tm.as_slice(), 7).expect("Deserializing TM failed");
+                    let tm = PusTmReader::new(event_tm.packet.as_slice(), 7)
+                        .expect("Deserializing TM failed");
                     assert_eq!(tm.0.service(), 5);
                     assert_eq!(tm.0.subservice(), 2);
                     let src_data = tm.0.source_data();

satrs/tests/pus_verification.rs

@@ -3,10 +3,11 @@ pub mod crossbeam_test {
     use hashbrown::HashMap;
     use satrs::pool::{PoolProvider, PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig};
     use satrs::pus::verification::{
-        FailParams, RequestId, VerificationReporterCfg, VerificationReporterWithSender,
+        FailParams, RequestId, VerificationReporter, VerificationReporterCfg,
         VerificationReportingProvider,
     };
     use satrs::pus::TmInSharedPoolSenderWithCrossbeam;
+    use satrs::request::UniqueApidTargetId;
     use satrs::tmtc::tm_helper::SharedTmPool;
     use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
     use spacepackets::ecss::tm::PusTmReader;
@@ -17,6 +18,8 @@ pub mod crossbeam_test {
     use std::time::Duration;
 
     const TEST_APID: u16 = 0x03;
+    const TEST_ID: TargetAndApidId = TargetAndApidId::new(TEST_APID, 0x05);
+
     const FIXED_STAMP: [u8; 7] = [0; 7];
     const PACKETS_SENT: u8 = 8;
 
@@ -40,13 +43,9 @@ pub mod crossbeam_test {
         let shared_tc_pool_0 = Arc::new(RwLock::new(StaticMemoryPool::new(pool_cfg)));
         let shared_tc_pool_1 = shared_tc_pool_0.clone();
         let (tx, rx) = crossbeam_channel::bounded(10);
-        let sender = TmInSharedPoolSenderWithCrossbeam::new(
-            0,
-            "verif_sender",
-            shared_tm_pool.clone(),
-            tx.clone(),
-        );
-        let mut reporter_with_sender_0 = VerificationReporterWithSender::new(&cfg, sender);
+        let sender_0 = TmInSharedPoolSenderWithCrossbeam::new(shared_tm_pool.clone(), tx.clone());
+        let sender_1 = sender_0.clone();
+        let mut reporter_with_sender_0 = VerificationReporter::new(&cfg);
         let mut reporter_with_sender_1 = reporter_with_sender_0.clone();
         // For test purposes, we retrieve the request ID from the TCs and pass them to the receiver
         // tread.
@@ -93,24 +92,36 @@ pub mod crossbeam_test {
 
             let token = reporter_with_sender_0.add_tc_with_req_id(req_id_0);
             let accepted_token = reporter_with_sender_0
-                .acceptance_success(token, &FIXED_STAMP)
+                .acceptance_success(TEST_ID.raw(), &sender_0, token, &FIXED_STAMP)
                 .expect("Acceptance success failed");
 
             // Do some start handling here
             let started_token = reporter_with_sender_0
-                .start_success(accepted_token, &FIXED_STAMP)
+                .start_success(TEST_ID.raw(), &sender_0, accepted_token, &FIXED_STAMP)
                 .expect("Start success failed");
             // Do some step handling here
             reporter_with_sender_0
-                .step_success(&started_token, &FIXED_STAMP, EcssEnumU8::new(0))
+                .step_success(
+                    TEST_ID.raw(),
+                    &sender_0,
+                    &started_token,
+                    &FIXED_STAMP,
+                    EcssEnumU8::new(0),
+                )
                 .expect("Start success failed");
 
             // Finish up
             reporter_with_sender_0
-                .step_success(&started_token, &FIXED_STAMP, EcssEnumU8::new(1))
+                .step_success(
+                    TEST_ID.raw(),
+                    &sender_0,
+                    &started_token,
+                    &FIXED_STAMP,
+                    EcssEnumU8::new(1),
+                )
                 .expect("Start success failed");
             reporter_with_sender_0
-                .completion_success(started_token, &FIXED_STAMP)
+                .completion_success(TEST_ID.raw(), &sender_0, started_token, &FIXED_STAMP)
                 .expect("Completion success failed");
         });
 
@@ -128,15 +139,15 @@ pub mod crossbeam_test {
             let (tc, _) = PusTcReader::new(&tc_buf[0..tc_len]).unwrap();
             let token = reporter_with_sender_1.add_tc(&tc);
             let accepted_token = reporter_with_sender_1
-                .acceptance_success(token, &FIXED_STAMP)
+                .acceptance_success(TEST_ID.raw(), &sender_1, token, &FIXED_STAMP)
                 .expect("Acceptance success failed");
             let started_token = reporter_with_sender_1
-                .start_success(accepted_token, &FIXED_STAMP)
+                .start_success(TEST_ID.raw(), &sender_1, accepted_token, &FIXED_STAMP)
                 .expect("Start success failed");
             let fail_code = EcssEnumU16::new(2);
             let params = FailParams::new_no_fail_data(&FIXED_STAMP, &fail_code);
             reporter_with_sender_1
-                .completion_failure(started_token, params)
+                .completion_failure(TEST_ID.raw(), &sender_1, started_token, params)
                 .expect("Completion success failed");
         });
 
@@ -145,14 +156,14 @@ pub mod crossbeam_test {
             let mut tm_buf: [u8; 1024] = [0; 1024];
             let mut verif_map = HashMap::new();
             while packet_counter < PACKETS_SENT {
-                let verif_addr = rx
+                let tm_in_pool = rx
                     .recv_timeout(Duration::from_millis(50))
                     .expect("Packet reception timeout");
                 let tm_len;
                 let shared_tm_store = shared_tm_pool.clone_backing_pool();
                 {
                     let mut rg = shared_tm_store.write().expect("Error locking shared pool");
-                    let store_guard = rg.read_with_guard(verif_addr);
+                    let store_guard = rg.read_with_guard(tm_in_pool.store_addr);
                     tm_len = store_guard
                         .read(&mut tm_buf)
                         .expect("Error reading TM slice");