put crossbeam dep behind feature gate

satrs-core/Cargo.toml

@@ -10,7 +10,7 @@ delegate = "0.8"
 hashbrown = "0.13"
 heapless = "0.7"
 paste = "1.0"
-dyn-clone = "1.0.9"
+dyn-clone = "1.0"
 embed-doc-image = "0.1"
 
 [dependencies.num-traits]
@@ -28,6 +28,7 @@ optional = true
 [dependencies.crossbeam-channel]
 version= "0.5"
 default-features = false
+optional = true
 
 [dependencies.serde]
 version = "1.0"
@@ -52,6 +53,7 @@ default = ["std"]
 std = ["downcast-rs/std", "alloc", "bus", "postcard/use-std", "crossbeam-channel/std", "serde/std", "spacepackets/std"]
 alloc = ["serde/alloc", "spacepackets/alloc"]
 serde = ["dep:serde", "spacepackets/serde"]
+crossbeam = ["crossbeam-channel"]
 heapless = []
 doc-images = []
 

satrs-core/src/pus/verification.rs

@@ -13,10 +13,10 @@
 //! executed. Note that the verification part could also be done in a separate thread.
 //!
 //! ```
-//! use std::sync::{Arc, RwLock};
+//! use std::sync::{Arc, mpsc, RwLock};
 //! use std::time::Duration;
 //! use satrs_core::pool::{LocalPool, PoolCfg, PoolProvider, SharedPool};
-//! use satrs_core::pus::verification::{CrossbeamVerifSender, VerificationReporterCfg, VerificationReporterWithSender};
+//! use satrs_core::pus::verification::{MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender};
 //! use satrs_core::seq_count::SimpleSeqCountProvider;
 //! use spacepackets::ecss::PusPacket;
 //! use spacepackets::SpHeader;
@@ -28,8 +28,8 @@
 //!
 //! let pool_cfg = PoolCfg::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
 //! let shared_tm_pool: SharedPool = Arc::new(RwLock::new(Box::new(LocalPool::new(pool_cfg.clone()))));
-//! let (verif_tx, verif_rx) = crossbeam_channel::bounded(10);
+//! let (verif_tx, verif_rx) = mpsc::channel();
-//! let sender = CrossbeamVerifSender::new(shared_tm_pool.clone(), verif_tx);
+//! let sender = MpscVerifSender::new(shared_tm_pool.clone(), verif_tx);
 //! let cfg = VerificationReporterCfg::new(TEST_APID, Box::new(SimpleSeqCountProvider::default()), 1, 2, 8).unwrap();
 //! let mut  reporter = VerificationReporterWithSender::new(&cfg , Box::new(sender));
 //!
@@ -93,10 +93,12 @@ pub use alloc_mod::{
 };
 
 use crate::seq_count::SequenceCountProvider;
+#[cfg(feature = "crossbeam")]
+pub use stdmod::CrossbeamVerifSender;
 #[cfg(feature = "std")]
 pub use stdmod::{
-    CrossbeamVerifSender, MpscVerifSender, SharedStdVerifReporterWithSender,
+    MpscVerifSender, SharedStdVerifReporterWithSender, StdVerifReporterWithSender,
-    StdVerifReporterWithSender, StdVerifSenderError,
+    StdVerifSenderError,
 };
 
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
@@ -1091,11 +1093,13 @@ mod stdmod {
 
     /// Verification sender with a [crossbeam_channel::Sender] backend.
     /// It implements the [EcssTmSender] trait to be used as PUS Verification TM sender
+    #[cfg(feature = "crossbeam")]
     #[derive(Clone)]
     pub struct CrossbeamVerifSender {
         base: StdSenderBase<crossbeam_channel::Sender<StoreAddr>>,
     }
 
+    #[cfg(feature = "crossbeam")]
     impl CrossbeamVerifSender {
         pub fn new(tm_store: SharedPool, tx: crossbeam_channel::Sender<StoreAddr>) -> Self {
             Self {
@@ -1105,6 +1109,7 @@ mod stdmod {
     }
 
     //noinspection RsTraitImplementation
+    #[cfg(feature = "crossbeam")]
     impl EcssTmSender for CrossbeamVerifSender {
         type Error = StdVerifSenderError;
 
@@ -1115,7 +1120,10 @@ mod stdmod {
         );
     }
 
+    // TODO: Are those really necessary? Check with test..
+    #[cfg(feature = "crossbeam")]
     unsafe impl Sync for CrossbeamVerifSender {}
+    #[cfg(feature = "crossbeam")]
     unsafe impl Send for CrossbeamVerifSender {}
 
     impl<S: SendBackend + Clone + 'static> EcssTmSender for StdSenderBase<S> {

satrs-core/tests/pus_verification.rs

@@ -1,31 +1,33 @@
-use hashbrown::HashMap;
+#[cfg(feature = "crossbeam")]
-use satrs_core::pool::{LocalPool, PoolCfg, PoolProvider, SharedPool};
+pub mod crossbeam_test {
-use satrs_core::pus::verification::{
+    use hashbrown::HashMap;
+    use satrs_core::pool::{LocalPool, PoolCfg, PoolProvider, SharedPool};
+    use satrs_core::pus::verification::{
         CrossbeamVerifSender, FailParams, RequestId, VerificationReporterCfg,
         VerificationReporterWithSender,
-};
+    };
-use satrs_core::seq_count::SyncSeqCountProvider;
+    use satrs_core::seq_count::SyncSeqCountProvider;
-use spacepackets::ecss::{EcssEnumU16, EcssEnumU8, PusPacket};
+    use spacepackets::ecss::{EcssEnumU16, EcssEnumU8, PusPacket};
-use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
+    use spacepackets::tc::{PusTc, PusTcSecondaryHeader};
-use spacepackets::tm::PusTm;
+    use spacepackets::tm::PusTm;
-use spacepackets::SpHeader;
+    use spacepackets::SpHeader;
-use std::sync::{Arc, RwLock};
+    use std::sync::{Arc, RwLock};
-use std::thread;
+    use std::thread;
-use std::time::Duration;
+    use std::time::Duration;
 
-const TEST_APID: u16 = 0x03;
+    const TEST_APID: u16 = 0x03;
-const FIXED_STAMP: [u8; 7] = [0; 7];
+    const FIXED_STAMP: [u8; 7] = [0; 7];
-const PACKETS_SENT: u8 = 8;
+    const PACKETS_SENT: u8 = 8;
 
-/// This test also shows how the verification report could be used in a multi-threaded context,
+    /// This test also shows how the verification report could be used in a multi-threaded context,
-/// wrapping it into an [Arc] and [Mutex] and then passing it to two threads.
+    /// wrapping it into an [Arc] and [Mutex] and then passing it to two threads.
-///
+    ///
-///  - The first thread generates a acceptance, a start, two steps and one completion report
+    ///  - The first thread generates a acceptance, a start, two steps and one completion report
-///  - The second generates an acceptance and start success report and a completion failure
+    ///  - The second generates an acceptance and start success report and a completion failure
-///  - The third thread is the verification receiver. In the test case, it verifies the other two
+    ///  - The third thread is the verification receiver. In the test case, it verifies the other two
-///    threads have sent the correct expected verification reports
+    ///    threads have sent the correct expected verification reports
-#[test]
+    #[test]
-fn test_shared_reporter() {
+    fn test_shared_reporter() {
         // We use a synced sequence count provider here because both verification reporters have the
         // the same APID. If they had distinct APIDs, the more correct approach would be to have
         // each reporter have an own sequence count provider.
@@ -45,7 +47,8 @@ fn test_shared_reporter() {
         let shared_tc_pool_1 = shared_tc_pool_0.clone();
         let (tx, rx) = crossbeam_channel::bounded(5);
         let sender = CrossbeamVerifSender::new(shared_tm_pool.clone(), tx.clone());
-    let mut reporter_with_sender_0 = VerificationReporterWithSender::new(&cfg, Box::new(sender));
+        let mut reporter_with_sender_0 =
+            VerificationReporterWithSender::new(&cfg, Box::new(sender));
         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.
@@ -155,10 +158,11 @@ fn test_shared_reporter() {
                     tm_len = slice.len();
                     tm_buf[0..tm_len].copy_from_slice(slice);
                 }
-            let (pus_tm, _) =
+                let (pus_tm, _) = PusTm::from_bytes(&tm_buf[0..tm_len], 7)
-                PusTm::from_bytes(&tm_buf[0..tm_len], 7).expect("Error reading verification TM");
+                    .expect("Error reading verification TM");
                 let req_id = RequestId::from_bytes(
-                &pus_tm.source_data().expect("Invalid TM source data")[0..RequestId::SIZE_AS_BYTES],
+                    &pus_tm.source_data().expect("Invalid TM source data")
+                        [0..RequestId::SIZE_AS_BYTES],
                 )
                 .unwrap();
                 if !verif_map.contains_key(&req_id) {
@@ -190,4 +194,5 @@ fn test_shared_reporter() {
         verif_sender_0.join().expect("Joining thread 0 failed");
         verif_sender_1.join().expect("Joining thread 1 failed");
         verif_receiver.join().expect("Joining thread 2 failed");
+    }
 }