move PacketAsVec and PacketInPool

satrs-example/src/interface/udp.rs

@@ -3,8 +3,7 @@ use std::net::{SocketAddr, UdpSocket};
 use std::sync::mpsc;
 
 use log::{info, warn};
-use satrs::pus::{PacketAsVec, PacketInPool};
-use satrs::tmtc::PacketSenderRaw;
+use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderRaw};
 use satrs::{
     hal::std::udp_server::{ReceiveResult, UdpTcServer},
     pool::{PoolProviderWithGuards, SharedStaticMemoryPool},

satrs-example/src/pus/action.rs

@@ -12,13 +12,13 @@ use satrs::pus::verification::{
 use satrs::pus::{
     ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter,
     EcssTcInVecConverter, EcssTmSender, EcssTmtcError, GenericConversionError, MpscTcReceiver,
-    MpscTmAsVecSender, PacketAsVec, PusPacketHandlerResult, PusReplyHandler, PusServiceHelper,
+    MpscTmAsVecSender, PusPacketHandlerResult, PusReplyHandler, PusServiceHelper,
     PusTcToRequestConverter,
 };
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket};
-use satrs::tmtc::PacketSenderWithSharedPool;
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
 use satrs_example::config::components::PUS_ACTION_SERVICE;
 use satrs_example::config::tmtc_err;
 use std::sync::mpsc;

satrs-example/src/pus/event.rs

@@ -8,10 +8,9 @@ use satrs::pus::event_srv::PusEventServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PacketAsVec, PusPacketHandlerResult,
-    PusServiceHelper,
+    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PusPacketHandlerResult, PusServiceHelper,
 };
-use satrs::tmtc::PacketSenderWithSharedPool;
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
 use satrs_example::config::components::PUS_EVENT_MANAGEMENT;
 
 use super::HandlingStatus;

satrs-example/src/pus/hk.rs

@@ -9,13 +9,13 @@ use satrs::pus::verification::{
 use satrs::pus::{
     ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap, EcssTcAndToken,
     EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTmSender,
-    EcssTmtcError, GenericConversionError, MpscTcReceiver, MpscTmAsVecSender, PacketAsVec,
+    EcssTmtcError, GenericConversionError, MpscTcReceiver, MpscTmAsVecSender,
     PusPacketHandlerResult, PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
 };
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket};
-use satrs::tmtc::PacketSenderWithSharedPool;
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
 use satrs_example::config::components::PUS_HK_SERVICE;
 use satrs_example::config::{hk_err, tmtc_err};
 use std::sync::mpsc;

satrs-example/src/pus/mod.rs

@@ -1,5 +1,6 @@
 use crate::requests::GenericRequestRouter;
 use log::warn;
+use satrs::pool::StoreAddr;
 use satrs::pus::verification::{
     self, FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
     VerificationReporterCfg, VerificationReportingProvider, VerificationToken,
@@ -13,7 +14,8 @@ use satrs::pus::{
 use satrs::queue::{GenericReceiveError, GenericSendError};
 use satrs::request::{Apid, GenericMessage, MessageMetadata};
 use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::PusServiceId;
+use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
+use satrs::tmtc::{PacketAsVec, PacketInPool};
 use satrs::ComponentId;
 use satrs_example::config::components::PUS_ROUTING_SERVICE;
 use satrs_example::config::{tmtc_err, CustomPusServiceId};
@@ -74,19 +76,54 @@ impl<TmSender: EcssTmSender> PusTcDistributor<TmSender> {
         }
     }
 
-    pub fn handle_tc_packet(
+    pub fn handle_tc_packet_vec(
         &mut self,
-        tc_in_memory: TcInMemory,
-        service: u8,
-        pus_tc: &PusTcReader,
+        packet_as_vec: PacketAsVec,
     ) -> Result<PusPacketHandlerResult, GenericSendError> {
-        let init_token = self.verif_reporter.add_tc(pus_tc);
+        self.handle_tc_generic(packet_as_vec.sender_id, None, &packet_as_vec.packet)
+    }
+
+    pub fn handle_tc_packet_in_store(
+        &mut self,
+        packet_in_pool: PacketInPool,
+        pus_tc_copy: &[u8],
+    ) -> Result<PusPacketHandlerResult, GenericSendError> {
+        self.handle_tc_generic(
+            packet_in_pool.sender_id,
+            Some(packet_in_pool.store_addr),
+            pus_tc_copy,
+        )
+    }
+
+    pub fn handle_tc_generic(
+        &mut self,
+        sender_id: ComponentId,
+        addr_opt: Option<StoreAddr>,
+        raw_tc: &[u8],
+    ) -> Result<PusPacketHandlerResult, GenericSendError> {
+        let pus_tc_result = PusTcReader::new(raw_tc);
+        if pus_tc_result.is_err() {
+            log::warn!(
+                "error creating PUS TC from raw data received from {}: {}",
+                sender_id,
+                pus_tc_result.unwrap_err()
+            );
+            log::warn!("raw data: {:x?}", raw_tc);
+            return Ok(PusPacketHandlerResult::RequestHandled);
+        }
+        let pus_tc = pus_tc_result.unwrap().0;
+        let init_token = self.verif_reporter.add_tc(&pus_tc);
         self.stamp_helper.update_from_now();
         let accepted_token = self
             .verif_reporter
             .acceptance_success(&self.tm_sender, init_token, self.stamp_helper.stamp())
             .expect("Acceptance success failure");
-        let service = PusServiceId::try_from(service);
+        let service = PusServiceId::try_from(pus_tc.service());
+        let tc_in_memory = if let Some(store_addr) = addr_opt {
+            TcInMemory::StoreAddr(store_addr)
+        } else {
+            TcInMemory::Vec(Vec::from(raw_tc))
+        };
         match service {
             Ok(standard_service) => match standard_service {
                 PusServiceId::Test => self.pus_router.test_tc_sender.send(EcssTcAndToken {
@@ -461,7 +498,7 @@ pub(crate) mod tests {
     use std::time::Duration;
 
     use satrs::pus::test_util::TEST_COMPONENT_ID_0;
-    use satrs::pus::{MpscTmAsVecSender, PacketAsVec, PusTmVariant};
+    use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
     use satrs::request::RequestId;
     use satrs::{
         pus::{

satrs-example/src/pus/mode.rs

@@ -1,6 +1,6 @@
 use derive_new::new;
 use log::{error, warn};
-use satrs::tmtc::PacketSenderWithSharedPool;
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
 use std::sync::mpsc;
 use std::time::Duration;
 
@@ -9,7 +9,7 @@ use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
     DefaultActiveRequestMap, EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter,
-    EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender, PacketAsVec, PusPacketHandlerResult,
+    EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender, PusPacketHandlerResult,
     PusServiceHelper,
 };
 use satrs::request::GenericMessage;

satrs-example/src/pus/scheduler.rs

@@ -9,10 +9,9 @@ use satrs::pus::scheduler_srv::PusSchedServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PacketAsVec, PacketInPool,
-    PusPacketHandlerResult, PusServiceHelper,
+    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PusPacketHandlerResult, PusServiceHelper,
 };
-use satrs::tmtc::PacketSenderWithSharedPool;
+use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool};
 use satrs::ComponentId;
 use satrs_example::config::components::PUS_SCHED_SERVICE;
 

satrs-example/src/pus/test.rs

@@ -7,13 +7,13 @@ use satrs::pus::verification::{FailParams, VerificationReporter, VerificationRep
 use satrs::pus::EcssTcInSharedStoreConverter;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, EcssTmSender, MpscTcReceiver,
-    MpscTmAsVecSender, PacketAsVec, PusPacketHandlerResult, PusServiceHelper,
+    MpscTmAsVecSender, PusPacketHandlerResult, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::spacepackets::time::cds::CdsTime;
 use satrs::spacepackets::time::TimeWriter;
-use satrs::tmtc::PacketSenderWithSharedPool;
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
 use satrs_example::config::components::PUS_TEST_SERVICE;
 use satrs_example::config::{tmtc_err, TEST_EVENT};
 use std::sync::mpsc;

satrs-example/src/tmtc/tc_source.rs

@@ -1,23 +1,19 @@
 use satrs::{
     pool::PoolProvider,
-    pus::{PacketAsVec, PacketInPool},
-    tmtc::{PacketSenderWithSharedPool, SharedPacketPool},
+    tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool, SharedPacketPool},
 };
 use std::sync::mpsc::{self, TryRecvError};
 
-use satrs::{
-    pus::MpscTmAsVecSender,
-    spacepackets::ecss::{tc::PusTcReader, PusPacket},
-};
+use satrs::pus::MpscTmAsVecSender;
 
-use crate::pus::PusTcDistributor;
+use crate::pus::{HandlingStatus, PusTcDistributor};
 
 // TC source components where static pools are the backing memory of the received telecommands.
 pub struct TcSourceTaskStatic {
     shared_tc_pool: SharedPacketPool,
     tc_receiver: mpsc::Receiver<PacketInPool>,
     tc_buf: [u8; 4096],
-    pus_receiver: PusTcDistributor<PacketSenderWithSharedPool>,
+    pus_distributor: PusTcDistributor<PacketSenderWithSharedPool>,
 }
 
 impl TcSourceTaskStatic {
@@ -30,7 +26,7 @@ impl TcSourceTaskStatic {
             shared_tc_pool,
             tc_receiver,
             tc_buf: [0; 4096],
-            pus_receiver,
+            pus_distributor: pus_receiver,
         }
     }
 
@@ -38,7 +34,9 @@ impl TcSourceTaskStatic {
         self.poll_tc();
     }
 
-    pub fn poll_tc(&mut self) -> bool {
+    pub fn poll_tc(&mut self) -> HandlingStatus {
+        // Right now, we only expect ECSS PUS packets.
+        // If packets like CFDP are expected, we might have to check the APID first.
         match self.tc_receiver.try_recv() {
             Ok(packet_in_pool) => {
                 let pool = self
@@ -49,29 +47,16 @@ impl TcSourceTaskStatic {
                 pool.read(&packet_in_pool.store_addr, &mut self.tc_buf)
                     .expect("reading pool failed");
                 drop(pool);
-                match PusTcReader::new(&self.tc_buf) {
-                    Ok((pus_tc, _)) => {
-                        self.pus_receiver
-                            .handle_tc_packet(
-                                satrs::pus::TcInMemory::StoreAddr(packet_in_pool.store_addr),
-                                pus_tc.service(),
-                                &pus_tc,
-                            )
-                            .ok();
-                        true
-                    }
-                    Err(e) => {
-                        log::warn!("error creating PUS TC from raw data: {e}");
-                        log::warn!("raw data: {:x?}", self.tc_buf);
-                        true
-                    }
-                }
+                self.pus_distributor
+                    .handle_tc_packet_in_store(packet_in_pool, &self.tc_buf)
+                    .ok();
+                HandlingStatus::HandledOne
             }
             Err(e) => match e {
-                TryRecvError::Empty => false,
+                TryRecvError::Empty => HandlingStatus::Empty,
                 TryRecvError::Disconnected => {
                     log::warn!("tmtc thread: sender disconnected");
-                    false
+                    HandlingStatus::Empty
                 }
             },
         }
@@ -81,7 +66,7 @@ impl TcSourceTaskStatic {
 // TC source components where the heap is the backing memory of the received telecommands.
 pub struct TcSourceTaskDynamic {
     pub tc_receiver: mpsc::Receiver<PacketAsVec>,
-    pus_receiver: PusTcDistributor<MpscTmAsVecSender>,
+    pus_distributor: PusTcDistributor<MpscTmAsVecSender>,
 }
 
 impl TcSourceTaskDynamic {
@@ -91,7 +76,7 @@ impl TcSourceTaskDynamic {
     ) -> Self {
         Self {
             tc_receiver,
-            pus_receiver,
+            pus_distributor: pus_receiver,
         }
     }
 
@@ -99,31 +84,21 @@ impl TcSourceTaskDynamic {
         self.poll_tc();
     }
 
-    pub fn poll_tc(&mut self) -> bool {
-        // Right now, we only expect PUS packets.
+    pub fn poll_tc(&mut self) -> HandlingStatus {
+        // Right now, we only expect ECSS PUS packets.
+        // If packets like CFDP are expected, we might have to check the APID first.
         match self.tc_receiver.try_recv() {
-            Ok(packet_as_vec) => match PusTcReader::new(&packet_as_vec.packet) {
-                Ok((pus_tc, _)) => {
-                    self.pus_receiver
-                        .handle_tc_packet(
-                            satrs::pus::TcInMemory::Vec(packet_as_vec.packet.clone()),
-                            pus_tc.service(),
-                            &pus_tc,
-                        )
-                        .ok();
-                    true
-                }
-                Err(e) => {
-                    log::warn!("error creating PUS TC from raw data: {e}");
-                    log::warn!("raw data: {:x?}", packet_as_vec.packet);
-                    true
-                }
-            },
+            Ok(packet_as_vec) => {
+                self.pus_distributor
+                    .handle_tc_packet_vec(packet_as_vec)
+                    .ok();
+                HandlingStatus::HandledOne
+            }
             Err(e) => match e {
-                TryRecvError::Empty => false,
+                TryRecvError::Empty => HandlingStatus::Empty,
                 TryRecvError::Disconnected => {
                     log::warn!("tmtc thread: sender disconnected");
-                    false
+                    HandlingStatus::Empty
                 }
             },
         }

satrs-example/src/tmtc/tm_sink.rs

@@ -4,6 +4,7 @@ use std::{
 };
 
 use log::info;
+use satrs::tmtc::{PacketAsVec, PacketInPool, SharedPacketPool};
 use satrs::{
     pool::PoolProvider,
     seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProviderCore},
@@ -13,10 +14,6 @@ use satrs::{
         CcsdsPacket,
     },
 };
-use satrs::{
-    pus::{PacketAsVec, PacketInPool},
-    tmtc::SharedPacketPool,
-};
 
 use crate::interface::tcp::SyncTcpTmSource;