rust/sat-rs
6
1
Fork 0
Code Issues 9 Pull Requests Projects Releases 24 Wiki Activity

improvements, start using in example

Browse Source
This commit is contained in:
Robin Müller
2025-02-05 16:02:04 +01:00
parent 474afc37ca
commit 8c2dfeea28
11 changed files with 240 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
satrs-example/src/acs/mgm.rs
View File

@ -1,7 +1,7 @@
use derive_new::new; use derive_new::new;
use satrs::hk::{HkRequest, HkRequestVariant}; use satrs::hk::{HkRequest, HkRequestVariant};
use satrs::mode_tree::{ModeChild, ModeNode};
use satrs::power::{PowerSwitchInfo, PowerSwitcherCommandSender}; use satrs::power::{PowerSwitchInfo, PowerSwitcherCommandSender};
use satrs::queue::{GenericSendError, GenericTargetedMessagingError};
use satrs_example::{DeviceMode, TimestampHelper}; use satrs_example::{DeviceMode, TimestampHelper};
use satrs_minisim::acs::lis3mdl::{ use satrs_minisim::acs::lis3mdl::{
MgmLis3MdlReply, MgmLis3RawValues, FIELD_LSB_PER_GAUSS_4_SENS, GAUSS_TO_MICROTESLA_FACTOR, MgmLis3MdlReply, MgmLis3RawValues, FIELD_LSB_PER_GAUSS_4_SENS, GAUSS_TO_MICROTESLA_FACTOR,
@ -16,6 +16,7 @@ use std::time::Duration;
use satrs::mode::{ use satrs::mode::{
ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeRequest, ModeRequestHandler, ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeRequest, ModeRequestHandler,
ModeRequestHandlerMpscBounded,
}; };
use satrs::pus::{EcssTmSender, PusTmVariant}; use satrs::pus::{EcssTmSender, PusTmVariant};
use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId}; use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
@ -171,7 +172,7 @@ pub struct MgmHandlerLis3Mdl<
> { > {
id: UniqueApidTargetId, id: UniqueApidTargetId,
dev_str: &'static str, dev_str: &'static str,
mode_interface: MpscModeLeafInterface, mode_node: ModeRequestHandlerMpscBounded,
composite_request_rx: mpsc::Receiver<GenericMessage<CompositeRequest>>, composite_request_rx: mpsc::Receiver<GenericMessage<CompositeRequest>>,
hk_reply_tx: mpsc::Sender<GenericMessage<HkReply>>, hk_reply_tx: mpsc::Sender<GenericMessage<HkReply>>,
switch_helper: SwitchHelper, switch_helper: SwitchHelper,
@ -275,8 +276,9 @@ impl<
pub fn handle_mode_requests(&mut self) { pub fn handle_mode_requests(&mut self) {
loop { loop {
// TODO: Only allow one set mode request per cycle? // TODO: Only allow one set mode request per cycle?
match self.mode_interface.request_rx.try_recv() { match self.mode_node.try_recv_mode_request() {
Ok(msg) => { Ok(opt_msg) => {
if let Some(msg) = opt_msg {
let result = self.handle_mode_request(msg); let result = self.handle_mode_request(msg);
// TODO: Trigger event? // TODO: Trigger event?
if result.is_err() { if result.is_err() {
@ -287,13 +289,13 @@ impl<
); );
} }
} }
Err(e) => { }
if e != mpsc::TryRecvError::Empty { Err(e) => match e {
satrs::queue::GenericReceiveError::Empty => (),
satrs::queue::GenericReceiveError::TxDisconnected(e) => {
log::warn!("{}: failed to receive mode request: {:?}", self.dev_str, e); log::warn!("{}: failed to receive mode request: {:?}", self.dev_str, e);
} else {
break;
}
} }
},
} }
} }
} }
@ -449,10 +451,9 @@ impl<
requestor.sender_id() requestor.sender_id()
); );
} }
self.mode_interface self.mode_node
.reply_to_pus_tx .send_mode_reply(requestor, reply)
.send(GenericMessage::new(requestor, reply)) .map_err(ModeError::Send)?;
.map_err(|_| GenericTargetedMessagingError::Send(GenericSendError::RxDisconnected))?;
Ok(()) Ok(())
} }
@ -465,17 +466,46 @@ impl<
} }
} }
impl<
ComInterface: SpiInterface,
TmSender: EcssTmSender,
SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>,
> ModeNode for MgmHandlerLis3Mdl<ComInterface, TmSender, SwitchHelper>
{
fn id(&self) -> satrs::ComponentId {
self.id.into()
}
}
impl<
ComInterface: SpiInterface,
TmSender: EcssTmSender,
SwitchHelper: PowerSwitchInfo<PcduSwitch> + PowerSwitcherCommandSender<PcduSwitch>,
> ModeChild for MgmHandlerLis3Mdl<ComInterface, TmSender, SwitchHelper>
{
type Sender = mpsc::SyncSender<GenericMessage<ModeReply>>;
fn add_mode_parent(&mut self, id: satrs::ComponentId, reply_sender: Self::Sender) {
self.mode_node.add_message_target(id, reply_sender);
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::sync::{mpsc, Arc}; use std::{
collections::HashMap,
sync::{mpsc, Arc},
};
use satrs::{ use satrs::{
mode::{ModeReply, ModeRequest}, mode::{ModeReply, ModeRequest},
mode_tree::ModeParent,
power::SwitchStateBinary, power::SwitchStateBinary,
request::{GenericMessage, UniqueApidTargetId}, request::{GenericMessage, UniqueApidTargetId},
tmtc::PacketAsVec, tmtc::PacketAsVec,
ComponentId,
}; };
use satrs_example::config::components::Apid; use satrs_example::config::components::{Apid, MGM_ASSEMBLY};
use satrs_minisim::acs::lis3mdl::MgmLis3RawValues; use satrs_minisim::acs::lis3mdl::MgmLis3RawValues;
use crate::{eps::TestSwitchHelper, pus::hk::HkReply, requests::CompositeRequest}; use crate::{eps::TestSwitchHelper, pus::hk::HkReply, requests::CompositeRequest};
@ -504,7 +534,7 @@ mod tests {
} }
pub struct MgmTestbench { pub struct MgmTestbench {
pub mode_request_tx: mpsc::Sender<GenericMessage<ModeRequest>>, pub mode_request_tx: mpsc::SyncSender<GenericMessage<ModeRequest>>,
pub mode_reply_rx_to_pus: mpsc::Receiver<GenericMessage<ModeReply>>, pub mode_reply_rx_to_pus: mpsc::Receiver<GenericMessage<ModeReply>>,
pub mode_reply_rx_to_parent: mpsc::Receiver<GenericMessage<ModeReply>>, pub mode_reply_rx_to_parent: mpsc::Receiver<GenericMessage<ModeReply>>,
pub composite_request_tx: mpsc::Sender<GenericMessage<CompositeRequest>>, pub composite_request_tx: mpsc::Sender<GenericMessage<CompositeRequest>>,
@ -514,38 +544,76 @@ mod tests {
MgmHandlerLis3Mdl<TestSpiInterface, mpsc::Sender<PacketAsVec>, TestSwitchHelper>, MgmHandlerLis3Mdl<TestSpiInterface, mpsc::Sender<PacketAsVec>, TestSwitchHelper>,
} }
#[derive(Default)]
pub struct MgmAssemblyMock(
pub HashMap<ComponentId, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
);
impl ModeNode for MgmAssemblyMock {
fn id(&self) -> satrs::ComponentId {
PUS_MODE_SERVICE.into()
}
}
impl ModeParent for MgmAssemblyMock {
type Sender = mpsc::SyncSender<GenericMessage<ModeRequest>>;
fn add_mode_child(&mut self, id: satrs::ComponentId, request_sender: Self::Sender) {
self.0.insert(id, request_sender);
}
}
#[derive(Default)]
pub struct PusMock {
pub request_sender_map: HashMap<ComponentId, mpsc::SyncSender<GenericMessage<ModeRequest>>>,
}
impl ModeNode for PusMock {
fn id(&self) -> satrs::ComponentId {
PUS_MODE_SERVICE.into()
}
}
impl ModeParent for PusMock {
type Sender = mpsc::SyncSender<GenericMessage<ModeRequest>>;
fn add_mode_child(&mut self, id: satrs::ComponentId, request_sender: Self::Sender) {
self.request_sender_map.insert(id, request_sender);
}
}
impl MgmTestbench { impl MgmTestbench {
pub fn new() -> Self { pub fn new() -> Self {
let (request_tx, request_rx) = mpsc::channel(); let (request_tx, request_rx) = mpsc::sync_channel(5);
let (reply_tx_to_pus, reply_rx_to_pus) = mpsc::channel(); let (reply_tx_to_pus, reply_rx_to_pus) = mpsc::sync_channel(5);
let (reply_tx_to_parent, reply_rx_to_parent) = mpsc::sync_channel(5); let (reply_tx_to_parent, reply_rx_to_parent) = mpsc::sync_channel(5);
let mode_interface = MpscModeLeafInterface { let id = UniqueApidTargetId::new(Apid::Acs as u16, 1);
request_rx, let mode_node = ModeRequestHandlerMpscBounded::new(id.into(), request_rx);
reply_to_pus_tx: reply_tx_to_pus,
reply_to_parent_tx: reply_tx_to_parent,
};
let (composite_request_tx, composite_request_rx) = mpsc::channel(); let (composite_request_tx, composite_request_rx) = mpsc::channel();
let (hk_reply_tx, hk_reply_rx) = mpsc::channel(); let (hk_reply_tx, hk_reply_rx) = mpsc::channel();
let (tm_tx, tm_rx) = mpsc::channel::<PacketAsVec>(); let (tm_tx, tm_rx) = mpsc::channel::<PacketAsVec>();
let shared_mgm_set = Arc::default(); let shared_mgm_set = Arc::default();
Self { let mut handler = MgmHandlerLis3Mdl::new(
mode_request_tx: request_tx, id,
mode_reply_rx_to_pus: reply_rx_to_pus,
mode_reply_rx_to_parent: reply_rx_to_parent,
composite_request_tx,
tm_rx,
hk_reply_rx,
handler: MgmHandlerLis3Mdl::new(
UniqueApidTargetId::new(Apid::Acs as u16, 1),
"TEST_MGM", "TEST_MGM",
mode_interface, mode_node,
composite_request_rx, composite_request_rx,
hk_reply_tx, hk_reply_tx,
TestSwitchHelper::default(), TestSwitchHelper::default(),
tm_tx, tm_tx,
TestSpiInterface::default(), TestSpiInterface::default(),
shared_mgm_set, shared_mgm_set,
), );
handler.add_mode_parent(PUS_MODE_SERVICE.into(), reply_tx_to_pus);
handler.add_mode_parent(MGM_ASSEMBLY.into(), reply_tx_to_parent);
Self {
mode_request_tx: request_tx,
mode_reply_rx_to_pus: reply_rx_to_pus,
mode_reply_rx_to_parent: reply_rx_to_parent,
composite_request_tx,
handler,
tm_rx,
hk_reply_rx,
} }
} }
} }

3
satrs-example/src/config.rs
View File

@ -149,6 +149,7 @@ pub mod components {
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq)]
pub enum AcsId { pub enum AcsId {
Mgm0 = 0, Mgm0 = 0,
Assembly = 1,
} }
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq)]
@ -176,6 +177,8 @@ pub mod components {
UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusHk as u32); UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusHk as u32);
pub const PUS_SCHED_SERVICE: UniqueApidTargetId = pub const PUS_SCHED_SERVICE: UniqueApidTargetId =
UniqueApidTargetId::new(Apid::Sched as u16, 0); UniqueApidTargetId::new(Apid::Sched as u16, 0);
pub const MGM_ASSEMBLY: UniqueApidTargetId =
UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Assembly as u32);
pub const MGM_HANDLER_0: UniqueApidTargetId = pub const MGM_HANDLER_0: UniqueApidTargetId =
UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32); UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32);
pub const PCDU_HANDLER: UniqueApidTargetId = pub const PCDU_HANDLER: UniqueApidTargetId =

4
satrs-example/src/eps/pcdu.rs
View File

@ -11,7 +11,7 @@ use satrs::{
mode::{ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeRequestHandler}, mode::{ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeRequestHandler},
power::SwitchRequest, power::SwitchRequest,
pus::{EcssTmSender, PusTmVariant}, pus::{EcssTmSender, PusTmVariant},
queue::{GenericSendError, GenericTargetedMessagingError}, queue::GenericSendError,
request::{GenericMessage, MessageMetadata, UniqueApidTargetId}, request::{GenericMessage, MessageMetadata, UniqueApidTargetId},
spacepackets::ByteConversionError, spacepackets::ByteConversionError,
}; };
@ -470,7 +470,7 @@ impl<ComInterface: SerialInterface, TmSender: EcssTmSender> ModeRequestHandler
self.mode_interface self.mode_interface
.reply_to_pus_tx .reply_to_pus_tx
.send(GenericMessage::new(requestor, reply)) .send(GenericMessage::new(requestor, reply))
.map_err(|_| GenericTargetedMessagingError::Send(GenericSendError::RxDisconnected))?; .map_err(|_| GenericSendError::RxDisconnected)?;
Ok(()) Ok(())
} }

44
satrs-example/src/main.rs
View File

@ -21,6 +21,7 @@ use log::info;
use pus::test::create_test_service_dynamic; use pus::test::create_test_service_dynamic;
use satrs::hal::std::tcp_server::ServerConfig; use satrs::hal::std::tcp_server::ServerConfig;
use satrs::hal::std::udp_server::UdpTcServer; use satrs::hal::std::udp_server::UdpTcServer;
use satrs::mode_tree::connect_mode_nodes;
use satrs::pus::HandlingStatus; use satrs::pus::HandlingStatus;
use satrs::request::{GenericMessage, MessageMetadata}; use satrs::request::{GenericMessage, MessageMetadata};
use satrs::tmtc::{PacketSenderWithSharedPool, SharedPacketPool}; use satrs::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
@ -47,7 +48,7 @@ use crate::pus::scheduler::{create_scheduler_service_dynamic, create_scheduler_s
use crate::pus::test::create_test_service_static; use crate::pus::test::create_test_service_static;
use crate::pus::{PusTcDistributor, PusTcMpscRouter}; use crate::pus::{PusTcDistributor, PusTcMpscRouter};
use crate::requests::{CompositeRequest, GenericRequestRouter}; use crate::requests::{CompositeRequest, GenericRequestRouter};
use satrs::mode::{Mode, ModeAndSubmode, ModeRequest}; use satrs::mode::{Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded};
use satrs::pus::event_man::EventRequestWithToken; use satrs::pus::event_man::EventRequestWithToken;
use satrs::spacepackets::{time::cds::CdsTime, time::TimeWriter}; use satrs::spacepackets::{time::cds::CdsTime, time::TimeWriter};
use satrs_example::config::components::{ use satrs_example::config::components::{
@ -93,9 +94,6 @@ fn static_tmtc_pool_main() {
request_map request_map
.composite_router_map .composite_router_map
.insert(MGM_HANDLER_0.id(), mgm_handler_composite_tx); .insert(MGM_HANDLER_0.id(), mgm_handler_composite_tx);
request_map
.mode_router_map
.insert(MGM_HANDLER_0.id(), mgm_handler_mode_tx);
request_map request_map
.composite_router_map .composite_router_map
.insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx); .insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx);
@ -232,12 +230,8 @@ fn static_tmtc_pool_main() {
let switch_helper = PowerSwitchHelper::new(switch_request_tx, shared_switch_set.clone()); let switch_helper = PowerSwitchHelper::new(switch_request_tx, shared_switch_set.clone());
let shared_mgm_set = Arc::default(); let shared_mgm_set = Arc::default();
let mgm_mode_leaf_interface = MpscModeLeafInterface { let mgm_mode_node =
request_rx: mgm_handler_mode_rx, ModeRequestHandlerMpscBounded::new(MGM_HANDLER_0.into(), mgm_handler_mode_rx);
reply_to_pus_tx: pus_mode_reply_tx.clone(),
reply_to_parent_tx: mgm_handler_mode_reply_to_parent_tx,
};
let mgm_spi_interface = if let Some(sim_client) = opt_sim_client.as_mut() { let mgm_spi_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
sim_client.add_reply_recipient(satrs_minisim::SimComponent::MgmLis3Mdl, mgm_sim_reply_tx); sim_client.add_reply_recipient(satrs_minisim::SimComponent::MgmLis3Mdl, mgm_sim_reply_tx);
SpiSimInterfaceWrapper::Sim(SpiSimInterface { SpiSimInterfaceWrapper::Sim(SpiSimInterface {
@ -250,7 +244,7 @@ fn static_tmtc_pool_main() {
let mut mgm_handler = MgmHandlerLis3Mdl::new( let mut mgm_handler = MgmHandlerLis3Mdl::new(
MGM_HANDLER_0, MGM_HANDLER_0,
"MGM_0", "MGM_0",
mgm_mode_leaf_interface, mgm_mode_node,
mgm_handler_composite_rx, mgm_handler_composite_rx,
pus_hk_reply_tx.clone(), pus_hk_reply_tx.clone(),
switch_helper.clone(), switch_helper.clone(),
@ -258,6 +252,13 @@ fn static_tmtc_pool_main() {
mgm_spi_interface, mgm_spi_interface,
shared_mgm_set, shared_mgm_set,
); );
// Connect PUS mode service to device handler.
connect_mode_nodes(
&mut pus_stack.mode_srv,
mgm_handler_mode_tx,
&mut mgm_handler,
mgm_handler_mode_reply_to_parent_tx,
);
let (pcdu_handler_mode_reply_to_parent_tx, _pcdu_handler_mode_reply_to_parent_rx) = let (pcdu_handler_mode_reply_to_parent_tx, _pcdu_handler_mode_reply_to_parent_rx) =
mpsc::sync_channel(10); mpsc::sync_channel(10);
@ -426,9 +427,9 @@ fn dyn_tmtc_pool_main() {
request_map request_map
.composite_router_map .composite_router_map
.insert(MGM_HANDLER_0.id(), mgm_handler_composite_tx); .insert(MGM_HANDLER_0.id(), mgm_handler_composite_tx);
request_map //request_map
.mode_router_map //.mode_router_map
.insert(MGM_HANDLER_0.id(), mgm_handler_mode_tx); //.insert(MGM_HANDLER_0.id(), mgm_handler_mode_tx);
request_map request_map
.composite_router_map .composite_router_map
.insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx); .insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx);
@ -543,11 +544,8 @@ fn dyn_tmtc_pool_main() {
let (mgm_handler_mode_reply_to_parent_tx, _mgm_handler_mode_reply_to_parent_rx) = let (mgm_handler_mode_reply_to_parent_tx, _mgm_handler_mode_reply_to_parent_rx) =
mpsc::sync_channel(5); mpsc::sync_channel(5);
let shared_mgm_set = Arc::default(); let shared_mgm_set = Arc::default();
let mode_leaf_interface = MpscModeLeafInterface { let mgm_mode_node =
request_rx: mgm_handler_mode_rx, ModeRequestHandlerMpscBounded::new(MGM_HANDLER_0.into(), mgm_handler_mode_rx);
reply_to_pus_tx: pus_mode_reply_tx.clone(),
reply_to_parent_tx: mgm_handler_mode_reply_to_parent_tx,
};
let mgm_spi_interface = if let Some(sim_client) = opt_sim_client.as_mut() { let mgm_spi_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
sim_client.add_reply_recipient(satrs_minisim::SimComponent::MgmLis3Mdl, mgm_sim_reply_tx); sim_client.add_reply_recipient(satrs_minisim::SimComponent::MgmLis3Mdl, mgm_sim_reply_tx);
@ -561,7 +559,7 @@ fn dyn_tmtc_pool_main() {
let mut mgm_handler = MgmHandlerLis3Mdl::new( let mut mgm_handler = MgmHandlerLis3Mdl::new(
MGM_HANDLER_0, MGM_HANDLER_0,
"MGM_0", "MGM_0",
mode_leaf_interface, mgm_mode_node,
mgm_handler_composite_rx, mgm_handler_composite_rx,
pus_hk_reply_tx.clone(), pus_hk_reply_tx.clone(),
switch_helper.clone(), switch_helper.clone(),
@ -569,6 +567,12 @@ fn dyn_tmtc_pool_main() {
mgm_spi_interface, mgm_spi_interface,
shared_mgm_set, shared_mgm_set,
); );
connect_mode_nodes(
&mut pus_stack.mode_srv,
mgm_handler_mode_tx,
&mut mgm_handler,
mgm_handler_mode_reply_to_parent_tx,
);
let (pcdu_handler_mode_reply_to_parent_tx, _pcdu_handler_mode_reply_to_parent_rx) = let (pcdu_handler_mode_reply_to_parent_tx, _pcdu_handler_mode_reply_to_parent_rx) =
mpsc::sync_channel(10); mpsc::sync_channel(10);

22
satrs-example/src/pus/mode.rs
View File

@ -1,4 +1,5 @@
use derive_new::new; use derive_new::new;
use satrs::mode_tree::{ModeNode, ModeParent};
use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool}; use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
use std::sync::mpsc; use std::sync::mpsc;
use std::time::Duration; use std::time::Duration;
@ -275,6 +276,27 @@ pub struct ModeServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcIn
>, >,
} }
impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> ModeNode
for ModeServiceWrapper<TmSender, TcInMemConverter>
{
fn id(&self) -> ComponentId {
self.service.service_helper.id()
}
}
impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> ModeParent
for ModeServiceWrapper<TmSender, TcInMemConverter>
{
type Sender = mpsc::SyncSender<GenericMessage<ModeRequest>>;
fn add_mode_child(&mut self, id: ComponentId, request_sender: Self::Sender) {
self.service
.request_router
.mode_router_map
.insert(id, request_sender);
}
}
impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> TargetedPusService impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> TargetedPusService
for ModeServiceWrapper<TmSender, TcInMemConverter> for ModeServiceWrapper<TmSender, TcInMemConverter>
{ {

12
satrs-example/src/pus/stack.rs
View File

@ -15,12 +15,12 @@ use super::{
// for targeted services.. // for targeted services..
#[derive(new)] #[derive(new)]
pub struct PusStack<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> { pub struct PusStack<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> {
test_srv: TestCustomServiceWrapper<TmSender, TcInMemConverter>, pub test_srv: TestCustomServiceWrapper<TmSender, TcInMemConverter>,
hk_srv_wrapper: HkServiceWrapper<TmSender, TcInMemConverter>, pub hk_srv_wrapper: HkServiceWrapper<TmSender, TcInMemConverter>,
event_srv: EventServiceWrapper<TmSender, TcInMemConverter>, pub event_srv: EventServiceWrapper<TmSender, TcInMemConverter>,
action_srv_wrapper: ActionServiceWrapper<TmSender, TcInMemConverter>, pub action_srv_wrapper: ActionServiceWrapper<TmSender, TcInMemConverter>,
schedule_srv: SchedulingServiceWrapper<TmSender, TcInMemConverter>, pub schedule_srv: SchedulingServiceWrapper<TmSender, TcInMemConverter>,
mode_srv: ModeServiceWrapper<TmSender, TcInMemConverter>, pub mode_srv: ModeServiceWrapper<TmSender, TcInMemConverter>,
} }
impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>

12
satrs/src/dev_mgmt.rs
View File

@ -35,7 +35,7 @@ pub trait DevManagerUserHook: Debug {
forced: bool, forced: bool,
children_mode_store: &mut ModeStoreVec, children_mode_store: &mut ModeStoreVec,
mode_req_sender: &impl ModeRequestSender, mode_req_sender: &impl ModeRequestSender,
) -> Result<(), GenericTargetedMessagingError>; ) -> Result<(), GenericSendError>;
fn send_mode_cmds_to_children( fn send_mode_cmds_to_children(
&self, &self,
@ -44,7 +44,7 @@ pub trait DevManagerUserHook: Debug {
forced: bool, forced: bool,
children_mode_store: &mut ModeStoreVec, children_mode_store: &mut ModeStoreVec,
mode_req_sender: &impl ModeRequestSender, mode_req_sender: &impl ModeRequestSender,
) -> Result<(), GenericTargetedMessagingError>; ) -> Result<(), GenericSendError>;
} }
#[derive(Debug, Default)] #[derive(Debug, Default)]
@ -58,7 +58,7 @@ impl DevManagerUserHook for TransparentDevManagerHook {
forced: bool, forced: bool,
children_mode_store: &mut ModeStoreVec, children_mode_store: &mut ModeStoreVec,
mode_req_sender: &impl ModeRequestSender, mode_req_sender: &impl ModeRequestSender,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
for child in children_mode_store { for child in children_mode_store {
mode_req_sender.send_mode_request( mode_req_sender.send_mode_request(
request_id, request_id,
@ -81,7 +81,7 @@ impl DevManagerUserHook for TransparentDevManagerHook {
forced: bool, forced: bool,
children_mode_store: &mut ModeStoreVec, children_mode_store: &mut ModeStoreVec,
mode_req_sender: &impl ModeRequestSender, mode_req_sender: &impl ModeRequestSender,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
let mut_val = children_mode_store let mut_val = children_mode_store
.get_mut(target_id) .get_mut(target_id)
.ok_or(GenericSendError::TargetDoesNotExist(target_id))?; .ok_or(GenericSendError::TargetDoesNotExist(target_id))?;
@ -144,7 +144,7 @@ impl<UserHook: DevManagerUserHook> DevManagerCommandingHelper<UserHook> {
mode_and_submode: ModeAndSubmode, mode_and_submode: ModeAndSubmode,
forced: bool, forced: bool,
mode_req_sender: &impl ModeRequestSender, mode_req_sender: &impl ModeRequestSender,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.state = DevManagerCommandingState::new_active_cmd(mode_and_submode, request_id); self.state = DevManagerCommandingState::new_active_cmd(mode_and_submode, request_id);
self.user_hook.send_mode_cmd_to_child( self.user_hook.send_mode_cmd_to_child(
request_id, request_id,
@ -163,7 +163,7 @@ impl<UserHook: DevManagerUserHook> DevManagerCommandingHelper<UserHook> {
mode_and_submode: ModeAndSubmode, mode_and_submode: ModeAndSubmode,
forced: bool, forced: bool,
mode_req_sender: &impl ModeRequestSender, mode_req_sender: &impl ModeRequestSender,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.state = DevManagerCommandingState::new_active_cmd(mode_and_submode, request_id); self.state = DevManagerCommandingState::new_active_cmd(mode_and_submode, request_id);
self.user_hook.send_mode_cmds_to_children( self.user_hook.send_mode_cmds_to_children(
request_id, request_id,

58
satrs/src/mode.rs
View File

@ -11,7 +11,7 @@ pub use alloc_mod::*;
pub use std_mod::*; pub use std_mod::*;
use crate::{ use crate::{
queue::GenericTargetedMessagingError, queue::{GenericReceiveError, GenericSendError},
request::{ request::{
GenericMessage, MessageMetadata, MessageReceiverProvider, MessageReceiverWithId, RequestId, GenericMessage, MessageMetadata, MessageReceiverProvider, MessageReceiverWithId, RequestId,
}, },
@ -159,13 +159,13 @@ pub trait ModeRequestSender {
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
request: ModeRequest, request: ModeRequest,
) -> Result<(), GenericTargetedMessagingError>; ) -> Result<(), GenericSendError>;
} }
pub trait ModeRequestReceiver { pub trait ModeRequestReceiver {
fn try_recv_mode_request( fn try_recv_mode_request(
&self, &self,
) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError>; ) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError>;
} }
impl<R: MessageReceiverProvider<ModeRequest>> ModeRequestReceiver impl<R: MessageReceiverProvider<ModeRequest>> ModeRequestReceiver
@ -173,15 +173,17 @@ impl<R: MessageReceiverProvider<ModeRequest>> ModeRequestReceiver
{ {
fn try_recv_mode_request( fn try_recv_mode_request(
&self, &self,
) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError> {
self.try_recv_message() self.try_recv_message()
} }
} }
#[derive(Debug, Clone, thiserror::Error)] #[derive(Debug, Clone, thiserror::Error)]
pub enum ModeError { pub enum ModeError {
#[error("Messaging error: {0}")] #[error("Messaging send error: {0}")]
Messaging(#[from] GenericTargetedMessagingError), Send(#[from] GenericSendError),
#[error("Messaging receive error: {0}")]
Receive(#[from] GenericReceiveError),
#[error("busy with other mode request")] #[error("busy with other mode request")]
Busy, Busy,
} }
@ -254,9 +256,8 @@ pub trait ModeRequestHandler: ModeProvider {
} }
pub trait ModeReplyReceiver { pub trait ModeReplyReceiver {
fn try_recv_mode_reply( fn try_recv_mode_reply(&self)
&self, -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError>;
) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError>;
} }
impl<R: MessageReceiverProvider<ModeReply>> ModeReplyReceiver impl<R: MessageReceiverProvider<ModeReply>> ModeReplyReceiver
@ -264,7 +265,7 @@ impl<R: MessageReceiverProvider<ModeReply>> ModeReplyReceiver
{ {
fn try_recv_mode_reply( fn try_recv_mode_reply(
&self, &self,
) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError> {
self.try_recv_message() self.try_recv_message()
} }
} }
@ -277,14 +278,17 @@ pub trait ModeReplySender {
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
reply: ModeReply, reply: ModeReply,
) -> Result<(), GenericTargetedMessagingError>; ) -> Result<(), GenericSendError>;
} }
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub mod alloc_mod { pub mod alloc_mod {
use crate::request::{ use crate::{
queue::{GenericReceiveError, GenericSendError},
request::{
MessageSenderAndReceiver, MessageSenderMap, MessageSenderProvider, MessageSenderAndReceiver, MessageSenderMap, MessageSenderProvider,
MessageSenderStoreProvider, RequestAndReplySenderAndReceiver, MessageSenderStoreProvider, RequestAndReplySenderAndReceiver,
},
}; };
use super::*; use super::*;
@ -295,7 +299,7 @@ pub mod alloc_mod {
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_id: ComponentId, target_id: ComponentId,
request: ModeReply, request: ModeReply,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.send_message(requestor_info, target_id, request) self.send_message(requestor_info, target_id, request)
} }
@ -320,7 +324,7 @@ pub mod alloc_mod {
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
request: ModeReply, request: ModeReply,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.message_sender_store.send_message( self.message_sender_store.send_message(
MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()), MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
requestor_info.sender_id(), requestor_info.sender_id(),
@ -339,7 +343,7 @@ pub mod alloc_mod {
{ {
fn try_recv_mode_reply( fn try_recv_mode_reply(
&self, &self,
) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError> {
self.message_receiver.try_recv_message() self.message_receiver.try_recv_message()
} }
} }
@ -399,7 +403,7 @@ pub mod alloc_mod {
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
reply: ModeReply, reply: ModeReply,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.reply_sender_store.send_message( self.reply_sender_store.send_message(
MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()), MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
requestor_info.sender_id(), requestor_info.sender_id(),
@ -430,7 +434,7 @@ pub mod alloc_mod {
{ {
fn try_recv_mode_reply( fn try_recv_mode_reply(
&self, &self,
) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError> {
self.reply_receiver.try_recv_message() self.reply_receiver.try_recv_message()
} }
} }
@ -447,7 +451,7 @@ pub mod alloc_mod {
{ {
pub fn try_recv_mode_request( pub fn try_recv_mode_request(
&self, &self,
) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError> {
self.try_recv_message() self.try_recv_message()
} }
@ -455,7 +459,7 @@ pub mod alloc_mod {
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
reply: ModeReply, reply: ModeReply,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.send_message( self.send_message(
requestor_info.request_id(), requestor_info.request_id(),
requestor_info.sender_id(), requestor_info.sender_id(),
@ -477,7 +481,7 @@ pub mod alloc_mod {
{ {
pub fn try_recv_mode_reply( pub fn try_recv_mode_reply(
&self, &self,
) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError> {
self.try_recv_message() self.try_recv_message()
} }
@ -486,7 +490,7 @@ pub mod alloc_mod {
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
reply: ModeRequest, reply: ModeRequest,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.send_message(request_id, target_id, reply) self.send_message(request_id, target_id, reply)
} }
} }
@ -517,7 +521,7 @@ pub mod alloc_mod {
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_id: ComponentId, target_id: ComponentId,
request: ModeRequest, request: ModeRequest,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.send_message(requestor_info, target_id, request) self.send_message(requestor_info, target_id, request)
} }
@ -536,7 +540,7 @@ pub mod alloc_mod {
{ {
fn try_recv_mode_request( fn try_recv_mode_request(
&self, &self,
) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError> {
self.message_receiver.try_recv_message() self.message_receiver.try_recv_message()
} }
} }
@ -558,7 +562,7 @@ pub mod alloc_mod {
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
request: ModeRequest, request: ModeRequest,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.message_sender_store.send_message( self.message_sender_store.send_message(
MessageMetadata::new(request_id, self.local_channel_id()), MessageMetadata::new(request_id, self.local_channel_id()),
target_id, target_id,
@ -622,7 +626,7 @@ pub mod alloc_mod {
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
request: ModeRequest, request: ModeRequest,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.request_sender_store.send_message( self.request_sender_store.send_message(
MessageMetadata::new(request_id, self.local_channel_id()), MessageMetadata::new(request_id, self.local_channel_id()),
target_id, target_id,
@ -653,7 +657,7 @@ pub mod alloc_mod {
{ {
fn try_recv_mode_request( fn try_recv_mode_request(
&self, &self,
) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeRequest>>, GenericReceiveError> {
self.request_receiver.try_recv_message() self.request_receiver.try_recv_message()
} }
} }
@ -747,7 +751,7 @@ pub(crate) mod tests {
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
request: ModeRequest, request: ModeRequest,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.requests.borrow_mut().push_back(ModeReqWrapper { self.requests.borrow_mut().push_back(ModeReqWrapper {
request_id, request_id,
target_id, target_id,

10
satrs/src/pus/action.rs
View File

@ -66,7 +66,7 @@ impl GenericActionReplyPus {
pub mod alloc_mod { pub mod alloc_mod {
use crate::{ use crate::{
action::ActionRequest, action::ActionRequest,
queue::GenericTargetedMessagingError, queue::{GenericReceiveError, GenericSendError},
request::{ request::{
GenericMessage, MessageReceiverProvider, MessageSenderAndReceiver, GenericMessage, MessageReceiverProvider, MessageSenderAndReceiver,
MessageSenderProvider, MessageSenderStoreProvider, RequestId, MessageSenderProvider, MessageSenderStoreProvider, RequestId,
@ -88,7 +88,7 @@ pub mod alloc_mod {
{ {
pub fn try_recv_action_request( pub fn try_recv_action_request(
&self, &self,
) -> Result<Option<GenericMessage<ActionRequest>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ActionRequest>>, GenericReceiveError> {
self.try_recv_message() self.try_recv_message()
} }
@ -97,7 +97,7 @@ pub mod alloc_mod {
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
reply: ActionReplyPus, reply: ActionReplyPus,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.send_message(request_id, target_id, reply) self.send_message(request_id, target_id, reply)
} }
} }
@ -121,7 +121,7 @@ pub mod alloc_mod {
{ {
pub fn try_recv_action_reply( pub fn try_recv_action_reply(
&self, &self,
) -> Result<Option<GenericMessage<ActionReplyPus>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ActionReplyPus>>, GenericReceiveError> {
self.try_recv_message() self.try_recv_message()
} }
@ -130,7 +130,7 @@ pub mod alloc_mod {
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
request: ActionRequest, request: ActionRequest,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.send_message(request_id, target_id, request) self.send_message(request_id, target_id, request)
} }
} }

63
satrs/src/request.rs
View File

@ -13,7 +13,10 @@ use spacepackets::{
ByteConversionError, ByteConversionError,
}; };
use crate::{queue::GenericTargetedMessagingError, ComponentId}; use crate::{
queue::{GenericReceiveError, GenericSendError},
ComponentId,
};
/// Generic request ID type. Requests can be associated with an ID to have a unique identifier /// Generic request ID type. Requests can be associated with an ID to have a unique identifier
/// for them. This can be useful for tasks like tracking their progress. /// for them. This can be useful for tasks like tracking their progress.
@ -141,12 +144,12 @@ impl<Message> GenericMessage<Message> {
/// Generic trait for objects which can send targeted messages. /// Generic trait for objects which can send targeted messages.
pub trait MessageSenderProvider<MSG>: Send { pub trait MessageSenderProvider<MSG>: Send {
fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError>; fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericSendError>;
} }
// Generic trait for objects which can receive targeted messages. // Generic trait for objects which can receive targeted messages.
pub trait MessageReceiverProvider<MSG> { pub trait MessageReceiverProvider<MSG> {
fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>; fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericReceiveError>;
} }
pub struct MessageWithSenderIdReceiver<Msg, Receiver: MessageReceiverProvider<Msg>>( pub struct MessageWithSenderIdReceiver<Msg, Receiver: MessageReceiverProvider<Msg>>(
@ -161,9 +164,7 @@ impl<MSG, R: MessageReceiverProvider<MSG>> From<R> for MessageWithSenderIdReceiv
} }
impl<MSG, R: MessageReceiverProvider<MSG>> MessageWithSenderIdReceiver<MSG, R> { impl<MSG, R: MessageReceiverProvider<MSG>> MessageWithSenderIdReceiver<MSG, R> {
pub fn try_recv_message( pub fn try_recv_message(&self) -> Result<Option<GenericMessage<MSG>>, GenericReceiveError> {
&self,
) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
self.0.try_recv() self.0.try_recv()
} }
} }
@ -187,9 +188,7 @@ impl<MSG, R: MessageReceiverProvider<MSG>> MessageReceiverWithId<MSG, R> {
} }
impl<MSG, R: MessageReceiverProvider<MSG>> MessageReceiverWithId<MSG, R> { impl<MSG, R: MessageReceiverProvider<MSG>> MessageReceiverWithId<MSG, R> {
pub fn try_recv_message( pub fn try_recv_message(&self) -> Result<Option<GenericMessage<MSG>>, GenericReceiveError> {
&self,
) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
self.reply_receiver.0.try_recv() self.reply_receiver.0.try_recv()
} }
} }
@ -202,7 +201,7 @@ pub trait MessageSenderStoreProvider<Message, Sender>: Default {
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_channel_id: ComponentId, target_channel_id: ComponentId,
message: Message, message: Message,
) -> Result<(), GenericTargetedMessagingError>; ) -> Result<(), GenericSendError>;
} }
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
@ -242,14 +241,14 @@ pub mod alloc_mod {
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_channel_id: ComponentId, target_channel_id: ComponentId,
message: Msg, message: Msg,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
if let Some((current_id, sender)) = &self.id_and_sender { if let Some((current_id, sender)) = &self.id_and_sender {
if *current_id == target_channel_id { if *current_id == target_channel_id {
sender.send(GenericMessage::new(requestor_info, message))?; sender.send(GenericMessage::new(requestor_info, message))?;
return Ok(()); return Ok(());
} }
} }
Err(GenericSendError::TargetDoesNotExist(target_channel_id).into()) Err(GenericSendError::TargetDoesNotExist(target_channel_id))
} }
} }
@ -276,14 +275,14 @@ pub mod alloc_mod {
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_channel_id: ComponentId, target_channel_id: ComponentId,
message: Msg, message: Msg,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
for (current_id, sender) in &self.0 { for (current_id, sender) in &self.0 {
if *current_id == target_channel_id { if *current_id == target_channel_id {
sender.send(GenericMessage::new(requestor_info, message))?; sender.send(GenericMessage::new(requestor_info, message))?;
return Ok(()); return Ok(());
} }
} }
Err(GenericSendError::TargetDoesNotExist(target_channel_id).into()) Err(GenericSendError::TargetDoesNotExist(target_channel_id))
} }
} }
@ -310,7 +309,7 @@ pub mod alloc_mod {
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_channel_id: ComponentId, target_channel_id: ComponentId,
message: Msg, message: Msg,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
if self.0.contains_key(&target_channel_id) { if self.0.contains_key(&target_channel_id) {
return self return self
.0 .0
@ -318,7 +317,7 @@ pub mod alloc_mod {
.unwrap() .unwrap()
.send(GenericMessage::new(requestor_info, message)); .send(GenericMessage::new(requestor_info, message));
} }
Err(GenericSendError::TargetDoesNotExist(target_channel_id).into()) Err(GenericSendError::TargetDoesNotExist(target_channel_id))
} }
} }
@ -367,7 +366,7 @@ pub mod alloc_mod {
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
message: To, message: To,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericSendError> {
self.message_sender_store.send_message( self.message_sender_store.send_message(
MessageMetadata::new(request_id, self.local_channel_id_generic()), MessageMetadata::new(request_id, self.local_channel_id_generic()),
target_id, target_id,
@ -378,7 +377,7 @@ pub mod alloc_mod {
/// Try to receive a message, which can be a reply or a request, depending on the generics. /// Try to receive a message, which can be a reply or a request, depending on the generics.
pub fn try_recv_message( pub fn try_recv_message(
&self, &self,
) -> Result<Option<GenericMessage<From>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<From>>, GenericReceiveError> {
self.message_receiver.try_recv_message() self.message_receiver.try_recv_message()
} }
} }
@ -454,20 +453,18 @@ pub mod std_mod {
use crate::queue::{GenericReceiveError, GenericSendError}; use crate::queue::{GenericReceiveError, GenericSendError};
impl<MSG: Send> MessageSenderProvider<MSG> for mpsc::Sender<GenericMessage<MSG>> { impl<MSG: Send> MessageSenderProvider<MSG> for mpsc::Sender<GenericMessage<MSG>> {
fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError> { fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericSendError> {
self.send(message) self.send(message)
.map_err(|_| GenericSendError::RxDisconnected)?; .map_err(|_| GenericSendError::RxDisconnected)?;
Ok(()) Ok(())
} }
} }
impl<MSG: Send> MessageSenderProvider<MSG> for mpsc::SyncSender<GenericMessage<MSG>> { impl<MSG: Send> MessageSenderProvider<MSG> for mpsc::SyncSender<GenericMessage<MSG>> {
fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError> { fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericSendError> {
if let Err(e) = self.try_send(message) { if let Err(e) = self.try_send(message) {
return match e { return match e {
mpsc::TrySendError::Full(_) => Err(GenericSendError::QueueFull(None).into()), mpsc::TrySendError::Full(_) => Err(GenericSendError::QueueFull(None)),
mpsc::TrySendError::Disconnected(_) => { mpsc::TrySendError::Disconnected(_) => Err(GenericSendError::RxDisconnected),
Err(GenericSendError::RxDisconnected.into())
}
}; };
} }
Ok(()) Ok(())
@ -478,13 +475,13 @@ pub mod std_mod {
pub type MessageSenderMapBoundedMpsc<MSG> = MessageReceiverWithId<MSG, mpsc::SyncSender<MSG>>; pub type MessageSenderMapBoundedMpsc<MSG> = MessageReceiverWithId<MSG, mpsc::SyncSender<MSG>>;
impl<MSG> MessageReceiverProvider<MSG> for mpsc::Receiver<GenericMessage<MSG>> { impl<MSG> MessageReceiverProvider<MSG> for mpsc::Receiver<GenericMessage<MSG>> {
fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> { fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericReceiveError> {
match self.try_recv() { match self.try_recv() {
Ok(msg) => Ok(Some(msg)), Ok(msg) => Ok(Some(msg)),
Err(e) => match e { Err(e) => match e {
mpsc::TryRecvError::Empty => Ok(None), mpsc::TryRecvError::Empty => Ok(None),
mpsc::TryRecvError::Disconnected => { mpsc::TryRecvError::Disconnected => {
Err(GenericReceiveError::TxDisconnected(None).into()) Err(GenericReceiveError::TxDisconnected(None))
} }
}, },
} }
@ -505,7 +502,7 @@ mod tests {
}; };
use crate::{ use crate::{
queue::{GenericReceiveError, GenericSendError, GenericTargetedMessagingError}, queue::{GenericReceiveError, GenericSendError},
request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider}, request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider},
}; };
@ -598,9 +595,7 @@ mod tests {
let reply = receiver.try_recv_message(); let reply = receiver.try_recv_message();
assert!(reply.is_err()); assert!(reply.is_err());
let error = reply.unwrap_err(); let error = reply.unwrap_err();
if let GenericTargetedMessagingError::Receive(GenericReceiveError::TxDisconnected(None)) = if let GenericReceiveError::TxDisconnected(None) = error {
error
{
} else { } else {
panic!("unexpected error type"); panic!("unexpected error type");
} }
@ -649,9 +644,7 @@ mod tests {
); );
assert!(result.is_err()); assert!(result.is_err());
let error = result.unwrap_err(); let error = result.unwrap_err();
if let GenericTargetedMessagingError::Send(GenericSendError::TargetDoesNotExist(target)) = if let GenericSendError::TargetDoesNotExist(target) = error {
error
{
assert_eq!(target, TEST_CHANNEL_ID_2); assert_eq!(target, TEST_CHANNEL_ID_2);
} else { } else {
panic!("Unexpected error type"); panic!("Unexpected error type");
@ -676,7 +669,7 @@ mod tests {
); );
assert!(result.is_err()); assert!(result.is_err());
let error = result.unwrap_err(); let error = result.unwrap_err();
if let GenericTargetedMessagingError::Send(GenericSendError::QueueFull(capacity)) = error { if let GenericSendError::QueueFull(capacity) = error {
assert!(capacity.is_none()); assert!(capacity.is_none());
} else { } else {
panic!("Unexpected error type {}", error); panic!("Unexpected error type {}", error);
@ -696,7 +689,7 @@ mod tests {
); );
assert!(result.is_err()); assert!(result.is_err());
let error = result.unwrap_err(); let error = result.unwrap_err();
if let GenericTargetedMessagingError::Send(GenericSendError::RxDisconnected) = error { if let GenericSendError::RxDisconnected = error {
} else { } else {
panic!("Unexpected error type {}", error); panic!("Unexpected error type {}", error);
} }

2
satrs/tests/mode_tree.rs
View File

@ -502,7 +502,7 @@ impl ModeRequestHandler for AcsSubsystem {
.unwrap(); .unwrap();
self.mode_node self.mode_node
.send_mode_reply(requestor_info, reply) .send_mode_reply(requestor_info, reply)
.map_err(ModeError::Messaging)?; .map_err(ModeError::Send)?;
Ok(()) Ok(())
} }
} }