Merge pull request 'some test fixes' (#235) from test-fix into main

Reviewed-on: #235

satrs-example/src/acs/assembly.rs

@@ -1,175 +1 @@
 // TODO: Write the assembly
-//
-
-use std::sync::mpsc;
-
-use satrs::{
-    dev_mgmt::{DevManagerCommandingHelper, DevManagerHelperResult, TransparentDevManagerHook},
-    mode::{
-        ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeReplyReceiver as _,
-        ModeReplySender as _, ModeRequest, ModeRequestHandler, ModeRequestReceiver as _,
-        ModeRequestorAndHandlerMpscBounded, UNKNOWN_MODE,
-    },
-    mode_tree::{ModeChild, ModeNode, ModeParent},
-    queue::GenericTargetedMessagingError,
-    request::{GenericMessage, MessageMetadata},
-    ComponentId,
-};
-use satrs_example::{ids, DeviceMode};
-
-pub type RequestSenderType = mpsc::SyncSender<GenericMessage<ModeRequest>>;
-pub type ReplySenderType = mpsc::SyncSender<GenericMessage<ModeReply>>;
-
-// TODO: Needs to perform same functions as the integration test assembly, but also needs
-// to track mode changes and health changes of children.
-pub struct MgmAssembly {
-    pub mode_node: ModeRequestorAndHandlerMpscBounded,
-    pub mode_requestor_info: Option<MessageMetadata>,
-    pub mode_and_submode: ModeAndSubmode,
-    pub commanding_helper: DevManagerCommandingHelper<TransparentDevManagerHook>,
-}
-
-impl MgmAssembly {
-    pub fn new(mode_node: ModeRequestorAndHandlerMpscBounded) -> Self {
-        Self {
-            mode_node,
-            mode_requestor_info: None,
-            mode_and_submode: UNKNOWN_MODE,
-            commanding_helper: DevManagerCommandingHelper::new(TransparentDevManagerHook::default()),
-        }
-    }
-
-    pub const fn id() -> ComponentId {
-        ids::acs::MGM_ASSEMBLY.raw()
-    }
-
-    pub fn periodic_operation(&mut self) {
-        self.check_mode_requests().expect("mode messaging error");
-        self.check_mode_replies().expect("mode messaging error");
-        // TODO: perform target keeping, check whether children are in correct mode.
-    }
-
-    pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
-        while let Some(request) = self.mode_node.try_recv_mode_request()? {
-            self.handle_mode_request(request).unwrap();
-        }
-        Ok(())
-    }
-
-    pub fn check_mode_replies(&mut self) -> Result<(), ModeError> {
-        while let Some(reply_and_id) = self.mode_node.try_recv_mode_reply()? {
-            match self.commanding_helper.handle_mode_reply(&reply_and_id) {
-                Ok(result) => {
-                    if let DevManagerHelperResult::ModeCommandingDone(context) = result {
-                        // Complete the mode command.
-                        self.mode_and_submode = context.target_mode;
-                        self.handle_mode_reached(self.mode_requestor_info)?;
-                    }
-                }
-                Err(err) => match err {
-                    satrs::dev_mgmt::DevManagerHelperError::ChildNotInStore => todo!(),
-                },
-            }
-        }
-        Ok(())
-    }
-}
-
-impl ModeNode for MgmAssembly {
-    fn id(&self) -> ComponentId {
-        Self::id()
-    }
-}
-impl ModeParent for MgmAssembly {
-    type Sender = RequestSenderType;
-
-    fn add_mode_child(&mut self, id: ComponentId, request_sender: RequestSenderType) {
-        self.mode_node.add_request_target(id, request_sender);
-        self.commanding_helper.add_mode_child(id, UNKNOWN_MODE);
-    }
-}
-
-impl ModeChild for MgmAssembly {
-    type Sender = ReplySenderType;
-
-    fn add_mode_parent(&mut self, id: ComponentId, reply_sender: ReplySenderType) {
-        self.mode_node.add_reply_target(id, reply_sender);
-    }
-}
-
-impl ModeProvider for MgmAssembly {
-    fn mode_and_submode(&self) -> ModeAndSubmode {
-        self.mode_and_submode
-    }
-}
-
-impl ModeRequestHandler for MgmAssembly {
-    type Error = ModeError;
-    fn start_transition(
-        &mut self,
-        requestor: MessageMetadata,
-        mode_and_submode: ModeAndSubmode,
-        forced: bool,
-    ) -> Result<(), Self::Error> {
-        // Always accept forced commands and commands to mode OFF.
-        if self.commanding_helper.target_mode().is_some()
-            && !forced
-            && mode_and_submode.mode() != DeviceMode::Off as u32
-        {
-            return Err(ModeError::Busy);
-        }
-        self.mode_requestor_info = Some(requestor);
-        self.commanding_helper.send_mode_cmd_to_all_children(
-            requestor.request_id(),
-            mode_and_submode,
-            forced,
-            &self.mode_node,
-        )?;
-        Ok(())
-    }
-
-    fn announce_mode(&self, requestor_info: Option<MessageMetadata>, recursive: bool) {
-        println!(
-            "TestAssembly: Announcing mode (recursively: {}): {:?}",
-            recursive, self.mode_and_submode
-        );
-        let request_id = requestor_info.map_or(0, |info| info.request_id());
-        self.commanding_helper
-            .send_announce_mode_cmd_to_children(request_id, &self.mode_node, recursive)
-            .expect("sending mode request failed");
-        // TODO: Send announce event.
-        log::info!(
-            "MGM assembly announcing mode: {:?}",
-            self.mode_and_submode()
-        );
-    }
-
-    fn handle_mode_reached(
-        &mut self,
-        mode_requestor: Option<MessageMetadata>,
-    ) -> Result<(), Self::Error> {
-        if let Some(requestor) = mode_requestor {
-            self.send_mode_reply(requestor, ModeReply::ModeReply(self.mode_and_submode))?;
-        }
-        self.announce_mode(mode_requestor, false);
-        Ok(())
-    }
-
-    fn handle_mode_info(
-        &mut self,
-        requestor_info: MessageMetadata,
-        info: ModeAndSubmode,
-    ) -> Result<(), Self::Error> {
-        // TODO: Perform mode keeping.
-        Ok(())
-    }
-
-    fn send_mode_reply(
-        &self,
-        requestor: MessageMetadata,
-        reply: ModeReply,
-    ) -> Result<(), Self::Error> {
-        self.mode_node.send_mode_reply(requestor, reply)?;
-        Ok(())
-    }
-}

satrs-example/src/acs/mgm.rs

@@ -400,7 +400,6 @@ impl<
     }
 
     fn announce_mode(&self, _requestor_info: Option<MessageMetadata>, _recursive: bool) {
-        // TODO: Event
         log::info!(
             "{} announcing mode: {:?}",
             self.dev_str,
@@ -493,7 +492,7 @@ mod tests {
         tmtc::PacketAsVec,
         ComponentId,
     };
-    use satrs_example::ids::{acs::MGM_ASSEMBLY, Apid};
+    use satrs_example::ids::{acs::ASSEMBLY, Apid};
     use satrs_minisim::acs::lis3mdl::MgmLis3RawValues;
 
     use crate::{eps::TestSwitchHelper, pus::hk::HkReply, requests::CompositeRequest};
@@ -594,7 +593,7 @@ mod tests {
                 shared_mgm_set,
             );
             handler.add_mode_parent(PUS_MODE.into(), reply_tx_to_pus);
-            handler.add_mode_parent(MGM_ASSEMBLY.into(), reply_tx_to_parent);
+            handler.add_mode_parent(ASSEMBLY.into(), reply_tx_to_parent);
             Self {
                 mode_request_tx: request_tx,
                 mode_reply_rx_to_pus: reply_rx_to_pus,

satrs-example/src/ids.rs

@@ -15,15 +15,15 @@ pub mod acs {
     #[derive(Debug, Copy, Clone, PartialEq, Eq)]
     pub enum Id {
         Subsystem = 1,
-        MgmAssembly = 2,
+        Assembly = 2,
         Mgm0 = 3,
         Mgm1 = 4,
     }
 
     pub const SUBSYSTEM: super::UniqueApidTargetId =
         super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Subsystem as u32);
-    pub const MGM_ASSEMBLY: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::MgmAssembly as u32);
+    pub const ASSEMBLY: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Assembly as u32);
     pub const MGM0: super::UniqueApidTargetId =
         super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm0 as u32);
     pub const MGM1: super::UniqueApidTargetId =

satrs-example/src/main.rs

@@ -5,10 +5,7 @@ use std::{
     time::Duration,
 };
 
-use acs::{
-    assembly::MgmAssembly,
-    mgm::{MgmHandlerLis3Mdl, SpiDummyInterface, SpiSimInterface, SpiSimInterfaceWrapper},
-};
+use acs::mgm::{MgmHandlerLis3Mdl, SpiDummyInterface, SpiSimInterface, SpiSimInterfaceWrapper};
 use eps::{
     pcdu::{PcduHandler, SerialInterfaceDummy, SerialInterfaceToSim, SerialSimInterfaceWrapper},
     PowerSwitchHelper,
@@ -34,10 +31,7 @@ use pus::{
 use requests::GenericRequestRouter;
 use satrs::{
     hal::std::{tcp_server::ServerConfig, udp_server::UdpTcServer},
-    mode::{
-        Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded,
-        ModeRequestorAndHandlerMpscBounded,
-    },
+    mode::{Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded},
     mode_tree::connect_mode_nodes,
     pus::{event_man::EventRequestWithToken, EcssTcInMemConverter, HandlingStatus},
     request::{GenericMessage, MessageMetadata},
@@ -309,15 +303,6 @@ fn main() {
     let (switch_request_tx, switch_request_rx) = mpsc::sync_channel(20);
     let switch_helper = PowerSwitchHelper::new(switch_request_tx, shared_switch_set.clone());
 
-    let (mgm_assy_mode_req_tx, mgm_assy_mode_req_rx) = mpsc::sync_channel(20);
-    let (mgm_assy_mode_reply_tx, mgm_assy_mode_reply_rx) = mpsc::sync_channel(20);
-    let mgm_assembly_mode_node = ModeRequestorAndHandlerMpscBounded::new(
-        MgmAssembly::id(),
-        mgm_assy_mode_req_rx,
-        mgm_assy_mode_reply_rx,
-    );
-    let mut mgm_assembly = MgmAssembly::new(mgm_assembly_mode_node);
-
     let shared_mgm_0_set = Arc::default();
     let shared_mgm_1_set = Arc::default();
     let mgm_0_mode_node = ModeRequestHandlerMpscBounded::new(MGM0.into(), mgm_0_handler_mode_rx);
@@ -379,19 +364,6 @@ fn main() {
         &mut mgm_1_handler,
         pus_mode_reply_tx.clone(),
     );
-    // Connect assembly to device handlers.
-    connect_mode_nodes(
-        &mut mgm_assembly,
-        mgm_assy_mode_req_tx.clone(),
-        &mut mgm_1_handler,
-        mgm_assy_mode_reply_tx.clone(),
-    );
-    connect_mode_nodes(
-        &mut mgm_assembly,
-        mgm_assy_mode_req_tx,
-        &mut mgm_1_handler,
-        mgm_assy_mode_reply_tx,
-    );
 
     let pcdu_serial_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
         sim_client.add_reply_recipient(satrs_minisim::SimComponent::Pcdu, pcdu_sim_reply_tx);
@@ -483,7 +455,6 @@ fn main() {
     let jh_aocs = thread::Builder::new()
         .name("sat-rs aocs".to_string())
         .spawn(move || loop {
-            mgm_assembly.periodic_operation();
             mgm_0_handler.periodic_operation();
             mgm_1_handler.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_AOCS));

satrs/src/encoding/ccsds.rs

@@ -90,8 +90,8 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
 #[cfg(test)]
 mod tests {
     use spacepackets::{
-        ecss::{tc::PusTcCreator, WritablePusPacket},
-        CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader,
+        ecss::tc::PusTcCreator, CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType,
+        SequenceFlags, SpHeader,
     };
 
     use crate::{encoding::tests::TcCacher, ComponentId};

satrs/src/hal/std/udp_server.rs

@@ -129,7 +129,6 @@ mod tests {
     use crate::ComponentId;
     use core::cell::RefCell;
     use spacepackets::ecss::tc::PusTcCreator;
-    use spacepackets::ecss::WritablePusPacket;
     use spacepackets::SpHeader;
     use std::collections::VecDeque;
     use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};

satrs/src/request.rs

@@ -39,7 +39,7 @@ impl UniqueApidTargetId {
         }
     }
 
-    pub const fn raw(&self) -> ComponentId {
+    pub fn raw(&self) -> ComponentId {
         ((self.apid as u64) << 32) | (self.unique_id as u64)
     }
 

satrs/tests/pus_verification.rs

@@ -46,8 +46,8 @@ pub mod crossbeam_test {
         let sender =
             PacketSenderWithSharedPool::new_with_shared_packet_pool(tx.clone(), &shared_tm_pool);
         let sender_1 = sender.clone();
-        let mut reporter_with_sender_0 = VerificationReporter::new(TEST_COMPONENT_ID_0.id(), &cfg);
-        let mut reporter_with_sender_1 = reporter_with_sender_0.clone();
+        let reporter_with_sender_0 = VerificationReporter::new(TEST_COMPONENT_ID_0.id(), &cfg);
+        let 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.
         let req_id_0;