Mode Tree Feature Update

satrs-example/src/acs/mgm.rs

@@ -26,7 +26,7 @@ use crate::hk::PusHkHelper;
 use crate::pus::hk::{HkReply, HkReplyVariant};
 use crate::requests::CompositeRequest;
 use crate::spi::SpiInterface;
-use crate::tmtc::sender::TmTcSender;
+use crate::tm_sender::TmSender;
 
 use serde::{Deserialize, Serialize};
 
@@ -165,7 +165,7 @@ pub struct MgmHandlerLis3Mdl<
     composite_request_rx: mpsc::Receiver<GenericMessage<CompositeRequest>>,
     hk_reply_tx: mpsc::SyncSender<GenericMessage<HkReply>>,
     switch_helper: SwitchHelper,
-    tm_sender: TmTcSender,
+    tm_sender: TmSender,
     pub com_interface: ComInterface,
     shared_mgm_set: Arc<Mutex<MgmData>>,
     #[new(value = "PusHkHelper::new(id)")]
@@ -576,9 +576,9 @@ mod tests {
             let id = UniqueApidTargetId::new(Apid::Acs as u16, 1);
             let mode_node = ModeRequestHandlerMpscBounded::new(id.into(), request_rx);
             let (composite_request_tx, composite_request_rx) = mpsc::channel();
-            let (hk_reply_tx, hk_reply_rx) = mpsc::sync_channel(10);
-            let (tm_tx, tm_rx) = mpsc::sync_channel(10);
-            let tm_sender = TmTcSender::Heap(tm_tx);
+            let (hk_reply_tx, hk_reply_rx) = mpsc::channel();
+            let (tm_tx, tm_rx) = mpsc::channel();
+            let tm_sender = TmSender::new_heap(tm_tx);
             let shared_mgm_set = Arc::default();
             let mut handler = MgmHandlerLis3Mdl::new(
                 id,

satrs-example/src/eps/pcdu.rs

@@ -574,7 +574,7 @@ mod tests {
             let mode_node =
                 ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), mode_request_rx);
             let (composite_request_tx, composite_request_rx) = mpsc::channel();
-            let (hk_reply_tx, hk_reply_rx) = mpsc::sync_channel(10);
+            let (hk_reply_tx, hk_reply_rx) = mpsc::channel();
             let (tm_tx, tm_rx) = mpsc::channel::<PacketAsVec>();
             let (switch_request_tx, switch_reqest_rx) = mpsc::channel();
             let shared_switch_map = Arc::new(Mutex::new(SwitchSet::default()));

satrs-example/src/interface/tcp.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use log::{info, warn};
-use satrs::tmtc::StoreAndSendError;
+use satrs::tmtc::{StoreAndSendError, TcSender};
 use satrs::{
     encoding::ccsds::{SpValidity, SpacePacketValidator},
     hal::std::tcp_server::{HandledConnectionHandler, ServerConfig, TcpSpacepacketsServer},
@@ -13,8 +13,6 @@ use satrs::{
     tmtc::PacketSource,
 };
 
-use crate::tmtc::sender::TmTcSender;
-
 #[derive(Default)]
 pub struct ConnectionFinishedHandler {}
 
@@ -112,13 +110,13 @@ pub type TcpServer<ReceivesTc, SendError> = TcpSpacepacketsServer<
     SendError,
 >;
 
-pub struct TcpTask(pub TcpServer<TmTcSender, StoreAndSendError>);
+pub struct TcpTask(pub TcpServer<TcSender, StoreAndSendError>);
 
 impl TcpTask {
     pub fn new(
         cfg: ServerConfig,
         tm_source: SyncTcpTmSource,
-        tc_sender: TmTcSender,
+        tc_sender: TcSender,
         valid_ids: HashSet<PacketId>,
     ) -> Result<Self, std::io::Error> {
         Ok(Self(TcpSpacepacketsServer::new(

satrs-example/src/interface/udp.rs

@@ -3,14 +3,12 @@ use std::sync::mpsc;
 
 use log::{info, warn};
 use satrs::pus::HandlingStatus;
-use satrs::tmtc::{PacketAsVec, PacketInPool, StoreAndSendError};
+use satrs::tmtc::{PacketAsVec, PacketInPool, StoreAndSendError, TcSender};
 use satrs::{
     hal::std::udp_server::{ReceiveResult, UdpTcServer},
     pool::{PoolProviderWithGuards, SharedStaticMemoryPool},
 };
 
-use crate::tmtc::sender::TmTcSender;
-
 pub trait UdpTmHandler {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr);
 }
@@ -67,7 +65,7 @@ impl UdpTmHandler for DynamicUdpTmHandler {
 }
 
 pub struct UdpTmtcServer<TmHandler: UdpTmHandler> {
-    pub udp_tc_server: UdpTcServer<TmTcSender, StoreAndSendError>,
+    pub udp_tc_server: UdpTcServer<TcSender, StoreAndSendError>,
     pub tm_handler: TmHandler,
 }
 
@@ -107,6 +105,7 @@ impl<TmHandler: UdpTmHandler> UdpTmtcServer<TmHandler> {
 mod tests {
     use std::net::Ipv4Addr;
     use std::{
+        cell::RefCell,
         collections::VecDeque,
         net::IpAddr,
         sync::{Arc, Mutex},
@@ -117,16 +116,30 @@ mod tests {
             ecss::{tc::PusTcCreator, WritablePusPacket},
             SpHeader,
         },
+        tmtc::PacketSenderRaw,
         ComponentId,
     };
     use satrs_example::config::{components, OBSW_SERVER_ADDR};
 
-    use crate::tmtc::sender::{MockSender, TmTcSender};
-
     use super::*;
 
     const UDP_SERVER_ID: ComponentId = 0x05;
 
+    #[derive(Default, Debug)]
+    pub struct TestSender {
+        tc_vec: RefCell<VecDeque<PacketAsVec>>,
+    }
+
+    impl PacketSenderRaw for TestSender {
+        type Error = ();
+
+        fn send_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
+            let mut mut_queue = self.tc_vec.borrow_mut();
+            mut_queue.push_back(PacketAsVec::new(sender_id, tc_raw.to_vec()));
+            Ok(())
+        }
+    }
+
     #[derive(Default, Debug, Clone)]
     pub struct TestTmHandler {
         addrs_to_send_to: Arc<Mutex<VecDeque<SocketAddr>>>,
@@ -141,7 +154,8 @@ mod tests {
     #[test]
     fn test_basic() {
         let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), 0);
-        let test_receiver = TmTcSender::Mock(MockSender::default());
+        let test_receiver = TestSender::default();
+        // let tc_queue = test_receiver.tc_vec.clone();
         let udp_tc_server =
             UdpTcServer::new(UDP_SERVER_ID, sock_addr, 2048, test_receiver).unwrap();
         let tm_handler = TestTmHandler::default();
@@ -151,13 +165,7 @@ mod tests {
             tm_handler,
         };
         udp_dyn_server.periodic_operation();
-        let queue = udp_dyn_server
-            .udp_tc_server
-            .tc_sender
-            .get_mock_sender()
-            .unwrap()
-            .0
-            .borrow();
+        let queue = udp_dyn_server.udp_tc_server.tc_sender.tc_vec.borrow();
         assert!(queue.is_empty());
         assert!(tm_handler_calls.lock().unwrap().is_empty());
     }
@@ -165,7 +173,8 @@ mod tests {
     #[test]
     fn test_transactions() {
         let sock_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0);
-        let test_receiver = TmTcSender::Mock(MockSender::default());
+        let test_receiver = TestSender::default();
+        // let tc_queue = test_receiver.tc_vec.clone();
         let udp_tc_server =
             UdpTcServer::new(UDP_SERVER_ID, sock_addr, 2048, test_receiver).unwrap();
         let server_addr = udp_tc_server.socket.local_addr().unwrap();
@@ -185,13 +194,7 @@ mod tests {
         client.send_to(&ping_tc, server_addr).unwrap();
         udp_dyn_server.periodic_operation();
         {
-            let mut queue = udp_dyn_server
-                .udp_tc_server
-                .tc_sender
-                .get_mock_sender()
-                .unwrap()
-                .0
-                .borrow_mut();
+            let mut queue = udp_dyn_server.udp_tc_server.tc_sender.tc_vec.borrow_mut();
             assert!(!queue.is_empty());
             let packet_with_sender = queue.pop_front().unwrap();
             assert_eq!(packet_with_sender.packet, ping_tc);
@@ -206,13 +209,7 @@ mod tests {
             assert_eq!(received_addr, client_addr);
         }
         udp_dyn_server.periodic_operation();
-        let queue = udp_dyn_server
-            .udp_tc_server
-            .tc_sender
-            .get_mock_sender()
-            .unwrap()
-            .0
-            .borrow();
+        let queue = udp_dyn_server.udp_tc_server.tc_sender.tc_vec.borrow();
         assert!(queue.is_empty());
         drop(queue);
         // Still tries to send to the same client.

satrs-example/src/main.rs

@@ -36,6 +36,7 @@ use satrs::{
     pus::{event_man::EventRequestWithToken, EcssTcInMemConverter, HandlingStatus},
     request::{GenericMessage, MessageMetadata},
     spacepackets::time::{cds::CdsTime, TimeWriter},
+    tmtc::TcSender,
 };
 use satrs_example::{
     config::{
@@ -46,7 +47,7 @@ use satrs_example::{
     },
     DeviceMode,
 };
-use tmtc::sender::TmTcSender;
+use tm_sender::TmSender;
 use tmtc::{tc_source::TcSourceTask, tm_sink::TmSink};
 
 cfg_if::cfg_if! {
@@ -76,6 +77,7 @@ mod logger;
 mod pus;
 mod requests;
 mod spi;
+mod tm_sender;
 mod tmtc;
 
 fn main() {
@@ -98,11 +100,11 @@ fn main() {
 
     cfg_if::cfg_if! {
         if #[cfg(not(feature = "heap_tmtc"))] {
-            let tm_sender = TmTcSender::Static(
+            let tm_sender = TmSender::Static(
                 PacketSenderWithSharedPool::new(tm_sink_tx.clone(), shared_tm_pool_wrapper.clone())
             );
         } else if #[cfg(feature = "heap_tmtc")] {
-            let tm_sender = TmTcSender::Heap(tm_sink_tx.clone());
+            let tm_sender = TmSender::Heap(tm_sink_tx.clone());
         }
     }
 
@@ -230,7 +232,7 @@ fn main() {
                 tc_source_rx,
                 PusTcDistributor::new(tm_sender.clone(), pus_router),
             ));
-            let tc_sender = TmTcSender::Static(tc_sender_with_shared_pool);
+            let tc_sender = TcSender::StaticStore(tc_sender_with_shared_pool);
             let udp_tm_handler = StaticUdpTmHandler {
                 tm_rx: tm_server_rx,
                 tm_store: shared_tm_pool.clone(),
@@ -240,7 +242,7 @@ fn main() {
                 tc_source_rx,
                 PusTcDistributor::new(tm_sender.clone(), pus_router),
             ));
-            let tc_sender = TmTcSender::Heap(tc_source_tx.clone());
+            let tc_sender = TcSender::HeapStore(tc_source_tx.clone());
             let udp_tm_handler = DynamicUdpTmHandler {
                 tm_rx: tm_server_rx,
             };

satrs-example/src/pus/action.rs

@@ -22,7 +22,7 @@ use std::sync::mpsc;
 use std::time::Duration;
 
 use crate::requests::GenericRequestRouter;
-use crate::tmtc::sender::TmTcSender;
+use crate::tm_sender::TmSender;
 
 use super::{
     create_verification_reporter, generic_pus_request_timeout_handler, HandlingStatus,
@@ -206,7 +206,7 @@ impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequest> for Actio
 }
 
 pub fn create_action_service(
-    tm_sender: TmTcSender,
+    tm_sender: TmSender,
     tc_in_mem_converter: EcssTcInMemConverter,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     action_router: GenericRequestRouter,
@@ -236,7 +236,7 @@ pub fn create_action_service(
 pub struct ActionServiceWrapper {
     pub(crate) service: PusTargetedRequestService<
         MpscTcReceiver,
-        TmTcSender,
+        TmSender,
         EcssTcInMemConverter,
         VerificationReporter,
         ActionRequestConverter,

satrs-example/src/pus/event.rs

@@ -1,7 +1,7 @@
 use std::sync::mpsc;
 
 use crate::pus::create_verification_reporter;
-use crate::tmtc::sender::TmTcSender;
+use crate::tm_sender::TmSender;
 use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::event_srv::PusEventServiceHandler;
 use satrs::pus::verification::VerificationReporter;
@@ -15,7 +15,7 @@ use satrs_example::config::components::PUS_EVENT_MANAGEMENT;
 use super::{DirectPusService, HandlingStatus};
 
 pub fn create_event_service(
-    tm_sender: TmTcSender,
+    tm_sender: TmSender,
     tm_in_pool_converter: EcssTcInMemConverter,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
@@ -38,7 +38,7 @@ pub fn create_event_service(
 pub struct EventServiceWrapper {
     pub handler: PusEventServiceHandler<
         MpscTcReceiver,
-        TmTcSender,
+        TmSender,
         EcssTcInMemConverter,
         VerificationReporter,
     >,

satrs-example/src/pus/hk.rs

@@ -20,7 +20,7 @@ use std::time::Duration;
 
 use crate::pus::{create_verification_reporter, generic_pus_request_timeout_handler};
 use crate::requests::GenericRequestRouter;
-use crate::tmtc::sender::TmTcSender;
+use crate::tm_sender::TmSender;
 
 use super::{HandlingStatus, PusTargetedRequestService, TargetedPusService};
 
@@ -241,7 +241,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConver
 }
 
 pub fn create_hk_service(
-    tm_sender: TmTcSender,
+    tm_sender: TmSender,
     tc_in_mem_converter: EcssTcInMemConverter,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
@@ -269,7 +269,7 @@ pub fn create_hk_service(
 pub struct HkServiceWrapper {
     pub(crate) service: PusTargetedRequestService<
         MpscTcReceiver,
-        TmTcSender,
+        TmSender,
         EcssTcInMemConverter,
         VerificationReporter,
         HkRequestConverter,

satrs-example/src/pus/mod.rs

@@ -1,5 +1,5 @@
 use crate::requests::GenericRequestRouter;
-use crate::tmtc::sender::TmTcSender;
+use crate::tm_sender::TmSender;
 use log::warn;
 use satrs::pool::PoolAddr;
 use satrs::pus::verification::{
@@ -53,14 +53,14 @@ pub struct PusTcMpscRouter {
 pub struct PusTcDistributor {
     #[allow(dead_code)]
     pub id: ComponentId,
-    pub tm_sender: TmTcSender,
+    pub tm_sender: TmSender,
     pub verif_reporter: VerificationReporter,
     pub pus_router: PusTcMpscRouter,
     stamp_helper: TimestampHelper,
 }
 
 impl PusTcDistributor {
-    pub fn new(tm_sender: TmTcSender, pus_router: PusTcMpscRouter) -> Self {
+    pub fn new(tm_sender: TmSender, pus_router: PusTcMpscRouter) -> Self {
         Self {
             id: PUS_ROUTING_SERVICE.raw(),
             tm_sender,

satrs-example/src/pus/mode.rs

@@ -4,7 +4,7 @@ use std::sync::mpsc;
 use std::time::Duration;
 
 use crate::requests::GenericRequestRouter;
-use crate::tmtc::sender::TmTcSender;
+use crate::tm_sender::TmSender;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
     DefaultActiveRequestMap, EcssTcAndToken, EcssTcInMemConverter, MpscTcReceiver,
@@ -209,7 +209,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, ModeRequest> for ModeRequestCo
 }
 
 pub fn create_mode_service(
-    tm_sender: TmTcSender,
+    tm_sender: TmSender,
     tc_in_mem_converter: EcssTcInMemConverter,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     mode_router: GenericRequestRouter,
@@ -237,7 +237,7 @@ pub fn create_mode_service(
 pub struct ModeServiceWrapper {
     pub(crate) service: PusTargetedRequestService<
         MpscTcReceiver,
-        TmTcSender,
+        TmSender,
         EcssTcInMemConverter,
         VerificationReporter,
         ModeRequestConverter,

satrs-example/src/pus/scheduler.rs

@@ -2,7 +2,7 @@ use std::sync::mpsc;
 use std::time::Duration;
 
 use crate::pus::create_verification_reporter;
-use crate::tmtc::sender::TmTcSender;
+use crate::tm_sender::TmSender;
 use log::info;
 use satrs::pool::{PoolProvider, StaticMemoryPool};
 use satrs::pus::scheduler::{PusScheduler, TcInfo};
@@ -83,7 +83,7 @@ impl TcReleaseProvider for TcReleaser {
 pub struct SchedulingServiceWrapper {
     pub pus_11_handler: PusSchedServiceHandler<
         MpscTcReceiver,
-        TmTcSender,
+        TmSender,
         EcssTcInMemConverter,
         VerificationReporter,
         PusScheduler,
@@ -173,7 +173,7 @@ impl SchedulingServiceWrapper {
 }
 
 pub fn create_scheduler_service(
-    tm_sender: TmTcSender,
+    tm_sender: TmSender,
     tc_in_mem_converter: EcssTcInMemConverter,
     tc_releaser: TcReleaser,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,

satrs-example/src/pus/test.rs

@@ -1,5 +1,5 @@
 use crate::pus::create_verification_reporter;
-use crate::tmtc::sender::TmTcSender;
+use crate::tm_sender::TmSender;
 use log::info;
 use satrs::event_man::{EventMessage, EventMessageU32};
 use satrs::pus::test::PusService17TestHandler;
@@ -18,7 +18,7 @@ use std::sync::mpsc;
 use super::{DirectPusService, HandlingStatus};
 
 pub fn create_test_service(
-    tm_sender: TmTcSender,
+    tm_sender: TmSender,
     tc_in_mem_converter: EcssTcInMemConverter,
     event_sender: mpsc::SyncSender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
@@ -39,7 +39,7 @@ pub fn create_test_service(
 pub struct TestCustomServiceWrapper {
     pub handler: PusService17TestHandler<
         MpscTcReceiver,
-        TmTcSender,
+        TmSender,
         EcssTcInMemConverter,
         VerificationReporter,
     >,

satrs-example/src/tm_sender.rs

@@ -0,0 +1,33 @@
+use std::sync::mpsc;
+
+use satrs::{
+    pus::EcssTmSender,
+    queue::GenericSendError,
+    spacepackets::ecss::WritablePusPacket,
+    tmtc::{PacketAsVec, PacketSenderWithSharedPool},
+};
+
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub enum TmSender {
+    Static(PacketSenderWithSharedPool),
+    Heap(mpsc::SyncSender<PacketAsVec>),
+}
+
+impl EcssTmSender for TmSender {
+    fn send_tm(
+        &self,
+        sender_id: satrs::ComponentId,
+        tm: satrs::pus::PusTmVariant,
+    ) -> Result<(), satrs::pus::EcssTmtcError> {
+        match self {
+            TmSender::Static(sync_sender) => sync_sender.send_tm(sender_id, tm),
+            TmSender::Heap(sync_sender) => match tm {
+                satrs::pus::PusTmVariant::InStore(_) => panic!("can not send TM in store"),
+                satrs::pus::PusTmVariant::Direct(pus_tm_creator) => sync_sender
+                    .send(PacketAsVec::new(sender_id, pus_tm_creator.to_vec()?))
+                    .map_err(|_| GenericSendError::RxDisconnected.into()),
+            },
+        }
+    }
+}

satrs-example/src/tmtc/mod.rs

@@ -1,3 +1,2 @@
-pub mod sender;
 pub mod tc_source;
 pub mod tm_sink;

satrs-example/src/tmtc/sender.rs

@@ -1,75 +0,0 @@
-use std::{cell::RefCell, collections::VecDeque, sync::mpsc};
-
-use satrs::{
-    pus::EcssTmSender,
-    queue::GenericSendError,
-    spacepackets::ecss::WritablePusPacket,
-    tmtc::{PacketAsVec, PacketSenderRaw, PacketSenderWithSharedPool, StoreAndSendError},
-    ComponentId,
-};
-
-#[derive(Default, Debug, Clone)]
-pub struct MockSender(pub RefCell<VecDeque<PacketAsVec>>);
-
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
-pub enum TmTcSender {
-    Static(PacketSenderWithSharedPool),
-    Heap(mpsc::SyncSender<PacketAsVec>),
-    Mock(MockSender),
-}
-
-impl TmTcSender {
-    #[allow(dead_code)]
-    pub fn get_mock_sender(&mut self) -> Option<&mut MockSender> {
-        match self {
-            TmTcSender::Mock(sender) => Some(sender),
-            _ => None,
-        }
-    }
-}
-
-impl EcssTmSender for TmTcSender {
-    fn send_tm(
-        &self,
-        sender_id: satrs::ComponentId,
-        tm: satrs::pus::PusTmVariant,
-    ) -> Result<(), satrs::pus::EcssTmtcError> {
-        match self {
-            TmTcSender::Static(sync_sender) => sync_sender.send_tm(sender_id, tm),
-            TmTcSender::Heap(sync_sender) => match tm {
-                satrs::pus::PusTmVariant::InStore(_) => panic!("can not send TM in store"),
-                satrs::pus::PusTmVariant::Direct(pus_tm_creator) => sync_sender
-                    .send(PacketAsVec::new(sender_id, pus_tm_creator.to_vec()?))
-                    .map_err(|_| GenericSendError::RxDisconnected.into()),
-            },
-            TmTcSender::Mock(_) => Ok(()),
-        }
-    }
-}
-
-impl PacketSenderRaw for TmTcSender {
-    type Error = StoreAndSendError;
-
-    fn send_packet(&self, sender_id: ComponentId, packet: &[u8]) -> Result<(), Self::Error> {
-        match self {
-            TmTcSender::Static(packet_sender_with_shared_pool) => {
-                packet_sender_with_shared_pool.send_packet(sender_id, packet)
-            }
-            TmTcSender::Heap(sync_sender) => sync_sender
-                .send_packet(sender_id, packet)
-                .map_err(StoreAndSendError::Send),
-            TmTcSender::Mock(sender) => sender.send_packet(sender_id, packet),
-        }
-    }
-}
-
-impl PacketSenderRaw for MockSender {
-    type Error = StoreAndSendError;
-
-    fn send_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
-        let mut mut_queue = self.0.borrow_mut();
-        mut_queue.push_back(PacketAsVec::new(sender_id, tc_raw.to_vec()));
-        Ok(())
-    }
-}

satrs/src/tmtc/mod.rs

@@ -477,6 +477,27 @@ pub mod std_mod {
             }
         }
     }
+
+    #[derive(Debug, Clone)]
+    pub enum TcSender {
+        StaticStore(PacketSenderWithSharedPool),
+        HeapStore(mpsc::SyncSender<PacketAsVec>),
+    }
+
+    impl PacketSenderRaw for TcSender {
+        type Error = StoreAndSendError;
+
+        fn send_packet(&self, sender_id: ComponentId, packet: &[u8]) -> Result<(), Self::Error> {
+            match self {
+                TcSender::StaticStore(packet_sender_with_shared_pool) => {
+                    packet_sender_with_shared_pool.send_packet(sender_id, packet)
+                }
+                TcSender::HeapStore(sync_sender) => sync_sender
+                    .send_packet(sender_id, packet)
+                    .map_err(StoreAndSendError::Send),
+            }
+        }
+    }
 }
 
 #[cfg(test)]