added new RequestId

satrs/tests/mode_tree.rs

@@ -1,6 +1,8 @@
+use core::cell::Cell;
 use std::{println, sync::mpsc};
 
 use satrs::mode_tree::ModeRequestSender;
+use satrs::request::RequestId;
 use satrs::{
     mode::{ModeAndSubmode, ModeReply, ModeRequest},
     mode_tree::{
@@ -9,7 +11,7 @@ use satrs::{
         MpscBoundedModeRequestorConnector,
     },
     queue::GenericTargetedMessagingError,
-    request::MessageWithSenderId,
+    request::GenericMessage,
     ChannelId,
 };
 use std::string::{String, ToString};
@@ -22,6 +24,7 @@ pub enum TestChannelId {
 }
 
 struct PusModeService {
+    pub request_id_counter: Cell<u32>,
     pub mode_node: MpscBoundedModeRequestorConnector,
 }
 
@@ -29,10 +32,13 @@ impl PusModeService {
     pub fn send_announce_mode_cmd_to_assy(&self) {
         self.mode_node
             .send_mode_request(
+                self.request_id_counter.get(),
                 TestChannelId::Assembly as u32,
                 ModeRequest::AnnounceModeRecursive,
             )
             .unwrap();
+        self.request_id_counter
+            .replace(self.request_id_counter.get() + 1);
     }
 }
 
@@ -40,7 +46,7 @@ struct TestDevice {
     pub name: String,
     pub mode_node: MpscBoundedModeRequestHandlerConnector,
     pub mode_and_submode: ModeAndSubmode,
-    pub mode_req_commander: Option<ChannelId>,
+    pub mode_requestor_info: Option<(RequestId, ChannelId)>,
 }
 
 impl TestDevice {
@@ -49,21 +55,27 @@ impl TestDevice {
     }
 
     pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
-        if let Some(request_and_id) = self.mode_node.try_recv_mode_request()? {
-            match request_and_id.message {
+        if let Some(request) = self.mode_node.try_recv_mode_request()? {
+            match request.message {
                 ModeRequest::SetMode(mode_and_submode) => {
-                    self.start_transition(mode_and_submode).unwrap();
-                    self.mode_req_commander = Some(request_and_id.sender_id);
+                    self.start_transition(request.request_id, request.sender_id, mode_and_submode)
+                        .unwrap();
+                    self.mode_requestor_info = Some((request.request_id, request.sender_id));
                 }
                 ModeRequest::ReadMode => self
                     .mode_node
                     .send_mode_reply(
-                        request_and_id.sender_id,
+                        request.request_id,
+                        request.sender_id,
                         ModeReply::ModeReply(self.mode_and_submode),
                     )
                     .unwrap(),
-                ModeRequest::AnnounceMode => self.announce_mode(false),
-                ModeRequest::AnnounceModeRecursive => self.announce_mode(true),
+                ModeRequest::AnnounceMode => {
+                    self.announce_mode(request.request_id, request.sender_id, false)
+                }
+                ModeRequest::AnnounceModeRecursive => {
+                    self.announce_mode(request.request_id, request.sender_id, true)
+                }
             }
         }
         Ok(())
@@ -76,13 +88,18 @@ impl ModeProvider for TestDevice {
     }
 }
 impl ModeRequestHandler for TestDevice {
-    fn start_transition(&mut self, mode_and_submode: ModeAndSubmode) -> Result<(), ModeError> {
+    fn start_transition(
+        &mut self,
+        _request_id: RequestId,
+        _sender_id: ChannelId,
+        mode_and_submode: ModeAndSubmode,
+    ) -> Result<(), ModeError> {
         self.mode_and_submode = mode_and_submode;
         self.handle_mode_reached()?;
         Ok(())
     }
 
-    fn announce_mode(&self, _recursive: bool) {
+    fn announce_mode(&self, _request_id: RequestId, _sender_id: ChannelId, _recursive: bool) {
         println!(
             "{}: announcing mode: {:?}",
             self.name, self.mode_and_submode
@@ -90,8 +107,10 @@ impl ModeRequestHandler for TestDevice {
     }
 
     fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError> {
+        let (req_id, sender_id) = self.mode_requestor_info.unwrap();
         self.mode_node.send_mode_reply(
-            self.mode_req_commander.unwrap(),
+            req_id,
+            sender_id,
             ModeReply::ModeReply(self.mode_and_submode),
         )?;
         Ok(())
@@ -100,7 +119,7 @@ impl ModeRequestHandler for TestDevice {
 
 struct TestAssembly {
     pub mode_node: MpscBoundedModeConnector,
-    pub mode_req_commander: Option<ChannelId>,
+    pub mode_requestor_info: Option<(RequestId, ChannelId)>,
     pub mode_and_submode: ModeAndSubmode,
     pub target_mode_and_submode: Option<ModeAndSubmode>,
 }
@@ -118,21 +137,26 @@ impl TestAssembly {
     }
 
     pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
-        if let Some(request_and_id) = self.mode_node.try_recv_mode_request()? {
-            match request_and_id.message {
+        if let Some(request) = self.mode_node.try_recv_mode_request()? {
+            match request.message {
                 ModeRequest::SetMode(mode_and_submode) => {
-                    self.start_transition(mode_and_submode).unwrap();
-                    self.mode_req_commander = Some(request_and_id.sender_id);
+                    self.start_transition(request.request_id, request.sender_id, mode_and_submode)
+                        .unwrap();
                 }
                 ModeRequest::ReadMode => self
                     .mode_node
                     .send_mode_reply(
-                        request_and_id.sender_id,
+                        request.request_id,
+                        request.sender_id,
                         ModeReply::ModeReply(self.mode_and_submode),
                     )
                     .unwrap(),
-                ModeRequest::AnnounceMode => self.announce_mode(false),
-                ModeRequest::AnnounceModeRecursive => self.announce_mode(true),
+                ModeRequest::AnnounceMode => {
+                    self.announce_mode(request.request_id, request.sender_id, false)
+                }
+                ModeRequest::AnnounceModeRecursive => {
+                    self.announce_mode(request.request_id, request.sender_id, true)
+                }
             }
         }
         Ok(())
@@ -162,16 +186,23 @@ impl TestAssembly {
 }
 
 impl ModeRequestHandler for TestAssembly {
-    fn start_transition(&mut self, mode_and_submode: ModeAndSubmode) -> Result<(), ModeError> {
+    fn start_transition(
+        &mut self,
+        request_id: RequestId,
+        sender_id: ChannelId,
+        mode_and_submode: ModeAndSubmode,
+    ) -> Result<(), ModeError> {
+        self.mode_requestor_info = Some((request_id, sender_id));
         self.target_mode_and_submode = Some(mode_and_submode);
         Ok(())
     }
 
-    fn announce_mode(&self, recursive: bool) {
+    fn announce_mode(&self, request_id: RequestId, _sender_id: ChannelId, recursive: bool) {
         println!(
             "TestAssembly: Announcing mode (recursively: {}): {:?}",
             recursive, self.mode_and_submode
         );
+        // self.mode_requestor_info = Some((request_id, sender_id));
         let mut mode_request = ModeRequest::AnnounceMode;
         if recursive {
             mode_request = ModeRequest::AnnounceModeRecursive;
@@ -182,7 +213,8 @@ impl ModeRequestHandler for TestAssembly {
             .iter()
             .for_each(|(_, sender)| {
                 sender
-                    .send(MessageWithSenderId::new(
+                    .send(GenericMessage::new(
+                        request_id,
                         self.mode_node.local_channel_id_generic(),
                         mode_request,
                     ))
@@ -191,8 +223,10 @@ impl ModeRequestHandler for TestAssembly {
     }
 
     fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError> {
+        let (req_id, sender_id) = self.mode_requestor_info.unwrap();
         self.mode_node.send_mode_reply(
-            self.mode_req_commander.unwrap(),
+            req_id,
+            sender_id,
             ModeReply::ModeReply(self.mode_and_submode),
         )?;
         Ok(())
@@ -260,22 +294,23 @@ fn main() {
     let mut device1 = TestDevice {
         name: "Test Device 1".to_string(),
         mode_node: mode_node_dev1,
-        mode_req_commander: None,
+        mode_requestor_info: None,
         mode_and_submode: ModeAndSubmode::new(0, 0),
     };
     let mut device2 = TestDevice {
         name: "Test Device 2".to_string(),
         mode_node: mode_node_dev2,
-        mode_req_commander: None,
+        mode_requestor_info: None,
         mode_and_submode: ModeAndSubmode::new(0, 0),
     };
     let mut assy = TestAssembly {
         mode_node: mode_node_assy,
-        mode_req_commander: None,
+        mode_requestor_info: None,
         mode_and_submode: ModeAndSubmode::new(0, 0),
         target_mode_and_submode: None,
     };
     let pus_service = PusModeService {
+        request_id_counter: Cell::new(0),
         mode_node: mode_node_pus,
     };