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

generic shananigans

Browse Source
This commit is contained in:
Robin Müller 2024-11-29 13:36:53 +01:00
parent db651ca06f
commit 5d8787b7fa
Signed by: muellerr
GPG Key ID: A649FB78196E3849
6 changed files with 454 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
satrs/src/mode.rs
View File

@ -12,7 +12,9 @@ pub use std_mod::*;
use crate::{ use crate::{
queue::GenericTargetedMessagingError, queue::GenericTargetedMessagingError,
request::{GenericMessage, MessageMetadata, MessageReceiver, MessageReceiverWithId, RequestId}, request::{
GenericMessage, MessageMetadata, MessageReceiverProvider, MessageReceiverWithId, RequestId,
},
ComponentId, ComponentId,
}; };
@ -156,7 +158,7 @@ pub trait ModeRequestReceiver {
) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError>; ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError>;
} }
impl<R: MessageReceiver<ModeRequest>> ModeRequestReceiver impl<R: MessageReceiverProvider<ModeRequest>> ModeRequestReceiver
for MessageReceiverWithId<ModeRequest, R> for MessageReceiverWithId<ModeRequest, R>
{ {
fn try_recv_mode_request( fn try_recv_mode_request(
@ -248,7 +250,9 @@ pub trait ModeReplyReceiver {
) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError>; ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError>;
} }
impl<R: MessageReceiver<ModeReply>> ModeReplyReceiver for MessageReceiverWithId<ModeReply, R> { impl<R: MessageReceiverProvider<ModeReply>> ModeReplyReceiver
for MessageReceiverWithId<ModeReply, R>
{
fn try_recv_mode_reply( fn try_recv_mode_reply(
&self, &self,
) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
@ -270,12 +274,13 @@ pub trait ModeReplySender {
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub mod alloc_mod { pub mod alloc_mod {
use crate::request::{ use crate::request::{
MessageSender, MessageSenderAndReceiver, MessageSenderMap, RequestAndReplySenderAndReceiver, MessageSenderAndReceiver, MessageSenderMap, MessageSenderProvider,
MessageSenderStoreProvider, RequestAndReplySenderAndReceiver,
}; };
use super::*; use super::*;
impl<S: MessageSender<ModeReply>> MessageSenderMap<ModeReply, S> { impl<S: MessageSenderProvider<ModeReply>> MessageSenderMap<ModeReply, S> {
pub fn send_mode_reply( pub fn send_mode_reply(
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
@ -290,8 +295,13 @@ pub mod alloc_mod {
} }
} }
impl<FROM, S: MessageSender<ModeReply>, R: MessageReceiver<FROM>> ModeReplySender impl<
for MessageSenderAndReceiver<ModeReply, FROM, S, R> From,
Sender: MessageSenderProvider<ModeReply>,
Receiver: MessageReceiverProvider<From>,
SenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
> ModeReplySender
for MessageSenderAndReceiver<ModeReply, From, Sender, Receiver, SenderStore>
{ {
fn local_channel_id(&self) -> ComponentId { fn local_channel_id(&self) -> ComponentId {
self.local_channel_id_generic() self.local_channel_id_generic()
@ -302,7 +312,7 @@ pub mod alloc_mod {
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
request: ModeReply, request: ModeReply,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericTargetedMessagingError> {
self.message_sender_map.send_mode_reply( 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(),
request, request,
@ -310,8 +320,13 @@ pub mod alloc_mod {
} }
} }
impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeReply>> ModeReplyReceiver impl<
for MessageSenderAndReceiver<TO, ModeReply, S, R> To,
Sender: MessageSenderProvider<To>,
Receiver: MessageReceiverProvider<ModeReply>,
SenderStore: MessageSenderStoreProvider<To, Sender>,
> ModeReplyReceiver
for MessageSenderAndReceiver<To, ModeReply, Sender, Receiver, SenderStore>
{ {
fn try_recv_mode_reply( fn try_recv_mode_reply(
&self, &self,
@ -322,10 +337,10 @@ pub mod alloc_mod {
impl< impl<
REQUEST, REQUEST,
S0: MessageSender<REQUEST>, S0: MessageSenderProvider<REQUEST>,
R0: MessageReceiver<ModeReply>, R0: MessageReceiverProvider<ModeReply>,
S1: MessageSender<ModeReply>, S1: MessageSenderProvider<ModeReply>,
R1: MessageReceiver<REQUEST>, R1: MessageReceiverProvider<REQUEST>,
> RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1> > RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
{ {
pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: S1) { pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: S1) {
@ -336,10 +351,10 @@ pub mod alloc_mod {
impl< impl<
REQUEST, REQUEST,
S0: MessageSender<REQUEST>, S0: MessageSenderProvider<REQUEST>,
R0: MessageReceiver<ModeReply>, R0: MessageReceiverProvider<ModeReply>,
S1: MessageSender<ModeReply>, S1: MessageSenderProvider<ModeReply>,
R1: MessageReceiver<REQUEST>, R1: MessageReceiverProvider<REQUEST>,
> ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1> > ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
{ {
fn local_channel_id(&self) -> ComponentId { fn local_channel_id(&self) -> ComponentId {
@ -361,10 +376,10 @@ pub mod alloc_mod {
impl< impl<
REQUEST, REQUEST,
S0: MessageSender<REQUEST>, S0: MessageSenderProvider<REQUEST>,
R0: MessageReceiver<ModeReply>, R0: MessageReceiverProvider<ModeReply>,
S1: MessageSender<ModeReply>, S1: MessageSenderProvider<ModeReply>,
R1: MessageReceiver<REQUEST>, R1: MessageReceiverProvider<REQUEST>,
> ModeReplyReceiver > ModeReplyReceiver
for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1> for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
{ {
@ -376,11 +391,14 @@ pub mod alloc_mod {
} }
/// Helper type definition for a mode handler which can handle mode requests. /// Helper type definition for a mode handler which can handle mode requests.
pub type ModeRequestHandlerInterface<S, R> = pub type ModeRequestHandlerInterface<Sender, Receiver, ReplySenderStore> =
MessageSenderAndReceiver<ModeReply, ModeRequest, S, R>; MessageSenderAndReceiver<ModeReply, ModeRequest, Sender, Receiver, ReplySenderStore>;
impl<S: MessageSender<ModeReply>, R: MessageReceiver<ModeRequest>> impl<
ModeRequestHandlerInterface<S, R> Sender: MessageSenderProvider<ModeReply>,
Receiver: MessageReceiverProvider<ModeRequest>,
ReplySenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
> ModeRequestHandlerInterface<Sender, Receiver, ReplySenderStore>
{ {
pub fn try_recv_mode_request( pub fn try_recv_mode_request(
&self, &self,
@ -403,9 +421,15 @@ pub mod alloc_mod {
/// Helper type defintion for a mode handler object which can send mode requests and receive /// Helper type defintion for a mode handler object which can send mode requests and receive
/// mode replies. /// mode replies.
pub type ModeRequestorInterface<S, R> = MessageSenderAndReceiver<ModeRequest, ModeReply, S, R>; pub type ModeRequestorInterface<Sender, Receiver, RequestSenderStore> =
MessageSenderAndReceiver<ModeRequest, ModeReply, Sender, Receiver, RequestSenderStore>;
impl<S: MessageSender<ModeRequest>, R: MessageReceiver<ModeReply>> ModeRequestorInterface<S, R> { impl<
Sender: MessageSenderProvider<ModeRequest>,
Receiver: MessageReceiverProvider<ModeReply>,
RequestSenderStore: MessageSenderStoreProvider<ModeRequest, Sender>,
> ModeRequestorInterface<Sender, Receiver, RequestSenderStore>
{
pub fn try_recv_mode_reply( pub fn try_recv_mode_reply(
&self, &self,
) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
@ -427,7 +451,7 @@ pub mod alloc_mod {
pub type ModeInterface<S0, R0, S1, R1> = pub type ModeInterface<S0, R0, S1, R1> =
RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>; RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>;
impl<S: MessageSender<ModeRequest>> MessageSenderMap<ModeRequest, S> { impl<S: MessageSenderProvider<ModeRequest>> MessageSenderMap<ModeRequest, S> {
pub fn send_mode_request( pub fn send_mode_request(
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
@ -442,25 +466,13 @@ pub mod alloc_mod {
} }
} }
/* impl<
impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId<ModeRequest, S> { To,
fn local_channel_id(&self) -> ComponentId { Sender: MessageSenderProvider<To>,
self.local_channel_id Receiver: MessageReceiverProvider<ModeRequest>,
} SenderStore: MessageSenderStoreProvider<To, Sender>,
> ModeRequestReceiver
fn send_mode_request( for MessageSenderAndReceiver<To, ModeRequest, Sender, Receiver, SenderStore>
&self,
request_id: RequestId,
target_id: ComponentId,
request: ModeRequest,
) -> Result<(), GenericTargetedMessagingError> {
self.send_message(request_id, target_id, request)
}
}
*/
impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestReceiver
for MessageSenderAndReceiver<TO, ModeRequest, S, R>
{ {
fn try_recv_mode_request( fn try_recv_mode_request(
&self, &self,
@ -469,8 +481,13 @@ pub mod alloc_mod {
} }
} }
impl<FROM, S: MessageSender<ModeRequest>, R: MessageReceiver<FROM>> ModeRequestSender impl<
for MessageSenderAndReceiver<ModeRequest, FROM, S, R> From,
Sender: MessageSenderProvider<ModeRequest>,
Receiver: MessageReceiverProvider<From>,
SenderStore: MessageSenderStoreProvider<ModeRequest, Sender>,
> ModeRequestSender
for MessageSenderAndReceiver<ModeRequest, From, Sender, Receiver, SenderStore>
{ {
fn local_channel_id(&self) -> ComponentId { fn local_channel_id(&self) -> ComponentId {
self.local_channel_id_generic() self.local_channel_id_generic()
@ -482,7 +499,7 @@ pub mod alloc_mod {
target_id: ComponentId, target_id: ComponentId,
request: ModeRequest, request: ModeRequest,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericTargetedMessagingError> {
self.message_sender_map.send_mode_request( 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,
request, request,
@ -492,10 +509,10 @@ pub mod alloc_mod {
impl< impl<
REPLY, REPLY,
S0: MessageSender<ModeRequest>, S0: MessageSenderProvider<ModeRequest>,
R0: MessageReceiver<REPLY>, R0: MessageReceiverProvider<REPLY>,
S1: MessageSender<REPLY>, S1: MessageSenderProvider<REPLY>,
R1: MessageReceiver<ModeRequest>, R1: MessageReceiverProvider<ModeRequest>,
> RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1> > RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
{ {
pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S0) { pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S0) {
@ -506,10 +523,10 @@ pub mod alloc_mod {
impl< impl<
REPLY, REPLY,
S0: MessageSender<ModeRequest>, S0: MessageSenderProvider<ModeRequest>,
R0: MessageReceiver<REPLY>, R0: MessageReceiverProvider<REPLY>,
S1: MessageSender<REPLY>, S1: MessageSenderProvider<REPLY>,
R1: MessageReceiver<ModeRequest>, R1: MessageReceiverProvider<ModeRequest>,
> ModeRequestSender > ModeRequestSender
for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1> for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
{ {
@ -533,10 +550,10 @@ pub mod alloc_mod {
impl< impl<
REPLY, REPLY,
S0: MessageSender<ModeRequest>, S0: MessageSenderProvider<ModeRequest>,
R0: MessageReceiver<REPLY>, R0: MessageReceiverProvider<REPLY>,
S1: MessageSender<REPLY>, S1: MessageSenderProvider<REPLY>,
R1: MessageReceiver<ModeRequest>, R1: MessageReceiverProvider<ModeRequest>,
> ModeRequestReceiver > ModeRequestReceiver
for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1> for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
{ {
@ -552,33 +569,55 @@ pub mod alloc_mod {
pub mod std_mod { pub mod std_mod {
use std::sync::mpsc; use std::sync::mpsc;
use crate::request::{MessageSenderList, OneMessageSender};
use super::*; use super::*;
pub type ModeRequestHandlerMpsc = ModeRequestHandlerInterface< pub type ModeRequestHandlerOneParentMpsc = ModeRequestHandlerInterface<
mpsc::Sender<GenericMessage<ModeReply>>, mpsc::Sender<GenericMessage<ModeReply>>,
mpsc::Receiver<GenericMessage<ModeRequest>>, mpsc::Receiver<GenericMessage<ModeRequest>>,
OneMessageSender<ModeReply, mpsc::Sender<GenericMessage<ModeReply>>>,
>; >;
pub type ModeRequestHandlerMpscBounded = ModeRequestHandlerInterface< pub type ModeRequestHandlerOneParentMpscBounded = ModeRequestHandlerInterface<
mpsc::SyncSender<GenericMessage<ModeReply>>, mpsc::SyncSender<GenericMessage<ModeReply>>,
mpsc::Receiver<GenericMessage<ModeRequest>>, mpsc::Receiver<GenericMessage<ModeRequest>>,
OneMessageSender<ModeReply, mpsc::SyncSender<GenericMessage<ModeReply>>>,
>; >;
pub type ModeRequestorMpsc = ModeRequestorInterface< pub type ModeRequestorOneChildMpsc = ModeRequestorInterface<
mpsc::Sender<GenericMessage<ModeRequest>>, mpsc::Sender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeReply>>,
OneMessageSender<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
>; >;
pub type ModeRequestorBoundedMpsc = ModeRequestorInterface< pub type ModeRequestorOneChildBoundedMpsc = ModeRequestorInterface<
mpsc::SyncSender<GenericMessage<ModeRequest>>, mpsc::SyncSender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeReply>>,
OneMessageSender<
ModeRequest,
mpsc::SyncSender<GenericMessage<ModeRequest>>,
>,
>;
pub type ModeRequestorMultiChildListMpsc = ModeRequestorInterface<
mpsc::Sender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>,
MessageSenderList<ModeRequest, mpsc::Sender<GenericMessage<ModeRequest>>>,
>;
pub type ModeRequestorMultiChildListBoundedMpsc = ModeRequestorInterface<
mpsc::SyncSender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>,
MessageSenderList<
ModeRequest,
mpsc::SyncSender<GenericMessage<ModeRequest>>,
>,
>; >;
pub type ModeRequestorAndHandlerMpsc = ModeInterface< pub type ModeRequestorAndHandlerOneParentMpsc = ModeInterface<
mpsc::Sender<GenericMessage<ModeRequest>>, mpsc::Sender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeReply>>,
mpsc::Sender<GenericMessage<ModeReply>>, mpsc::Sender<GenericMessage<ModeReply>>,
mpsc::Receiver<GenericMessage<ModeRequest>>, mpsc::Receiver<GenericMessage<ModeRequest>>,
>; >;
pub type ModeRequestorAndHandlerMpscBounded = ModeInterface< pub type ModeRequestorAndHandlerOneParentMpscBounded = ModeInterface<
mpsc::SyncSender<GenericMessage<ModeRequest>>, mpsc::SyncSender<GenericMessage<ModeRequest>>,
mpsc::Receiver<GenericMessage<ModeReply>>, mpsc::Receiver<GenericMessage<ModeReply>>,
mpsc::SyncSender<GenericMessage<ModeReply>>, mpsc::SyncSender<GenericMessage<ModeReply>>,

6
satrs/src/mode_tree.rs
View File

@ -3,7 +3,7 @@ use hashbrown::HashMap;
use crate::{ use crate::{
mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode}, mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode},
request::MessageSender, request::MessageSenderProvider,
ComponentId, ComponentId,
}; };
@ -19,7 +19,7 @@ pub trait ModeNode {
/// A mode parent is capable of sending mode requests to child objects and has a unique component /// A mode parent is capable of sending mode requests to child objects and has a unique component
/// ID. /// ID.
pub trait ModeParent: ModeNode { pub trait ModeParent: ModeNode {
type Sender: MessageSender<ModeRequest>; type Sender: MessageSenderProvider<ModeRequest>;
fn add_mode_child(&mut self, id: ComponentId, request_sender: Self::Sender); fn add_mode_child(&mut self, id: ComponentId, request_sender: Self::Sender);
} }
@ -28,7 +28,7 @@ pub trait ModeParent: ModeNode {
/// ///
/// A child is capable of sending mode replies to parent objects and has a unique component ID. /// A child is capable of sending mode replies to parent objects and has a unique component ID.
pub trait ModeChild: ModeNode { pub trait ModeChild: ModeNode {
type Sender: MessageSender<ModeReply>; type Sender: MessageSenderProvider<ModeReply>;
fn add_mode_parent(&mut self, id: ComponentId, reply_sender: Self::Sender); fn add_mode_parent(&mut self, id: ComponentId, reply_sender: Self::Sender);
} }

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

@ -68,7 +68,8 @@ pub mod alloc_mod {
action::ActionRequest, action::ActionRequest,
queue::GenericTargetedMessagingError, queue::GenericTargetedMessagingError,
request::{ request::{
GenericMessage, MessageReceiver, MessageSender, MessageSenderAndReceiver, RequestId, GenericMessage, MessageReceiverProvider, MessageSenderAndReceiver,
MessageSenderProvider, MessageSenderStoreProvider, RequestId,
}, },
ComponentId, ComponentId,
}; };
@ -76,11 +77,14 @@ pub mod alloc_mod {
use super::ActionReplyPus; use super::ActionReplyPus;
/// Helper type definition for a mode handler which can handle mode requests. /// Helper type definition for a mode handler which can handle mode requests.
pub type ActionRequestHandlerInterface<S, R> = pub type ActionRequestHandlerInterface<Sender, Receiver, ReplySenderStore> =
MessageSenderAndReceiver<ActionReplyPus, ActionRequest, S, R>; MessageSenderAndReceiver<ActionReplyPus, ActionRequest, Sender, Receiver, ReplySenderStore>;
impl<S: MessageSender<ActionReplyPus>, R: MessageReceiver<ActionRequest>> impl<
ActionRequestHandlerInterface<S, R> Sender: MessageSenderProvider<ActionReplyPus>,
Receiver: MessageReceiverProvider<ActionRequest>,
ReplySender: MessageSenderStoreProvider<ActionReplyPus, Sender>,
> ActionRequestHandlerInterface<Sender, Receiver, ReplySender>
{ {
pub fn try_recv_action_request( pub fn try_recv_action_request(
&self, &self,
@ -100,11 +104,20 @@ pub mod alloc_mod {
/// Helper type defintion for a mode handler object which can send mode requests and receive /// Helper type defintion for a mode handler object which can send mode requests and receive
/// mode replies. /// mode replies.
pub type ActionRequestorInterface<S, R> = pub type ActionRequestorInterface<Sender, Receiver, RequestSenderStore> =
MessageSenderAndReceiver<ActionRequest, ActionReplyPus, S, R>; MessageSenderAndReceiver<
ActionRequest,
ActionReplyPus,
Sender,
Receiver,
RequestSenderStore,
>;
impl<S: MessageSender<ActionRequest>, R: MessageReceiver<ActionReplyPus>> impl<
ActionRequestorInterface<S, R> Sender: MessageSenderProvider<ActionRequest>,
Receiver: MessageReceiverProvider<ActionReplyPus>,
RequestSenderStore: MessageSenderStoreProvider<ActionRequest, Sender>,
> ActionRequestorInterface<Sender, Receiver, RequestSenderStore>
{ {
pub fn try_recv_action_reply( pub fn try_recv_action_reply(
&self, &self,
@ -132,6 +145,7 @@ pub mod std_mod {
verification::{self, TcStateToken}, verification::{self, TcStateToken},
ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap, ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap,
}, },
request::{MessageSenderMap, OneMessageSender},
ComponentId, ComponentId,
}; };
@ -174,22 +188,38 @@ pub mod std_mod {
} }
pub type DefaultActiveActionRequestMap = DefaultActiveRequestMap<ActivePusActionRequestStd>; pub type DefaultActiveActionRequestMap = DefaultActiveRequestMap<ActivePusActionRequestStd>;
pub type ActionRequestHandlerMpsc = ActionRequestHandlerInterface< pub type ActionRequestHandlerOneSenderMpsc = ActionRequestHandlerInterface<
mpsc::Sender<GenericMessage<ActionReplyPus>>, mpsc::Sender<GenericMessage<ActionReplyPus>>,
mpsc::Receiver<GenericMessage<ActionRequest>>, mpsc::Receiver<GenericMessage<ActionRequest>>,
OneMessageSender<
GenericMessage<ActionReplyPus>,
mpsc::Sender<GenericMessage<ActionReplyPus>>,
>,
>; >;
pub type ActionRequestHandlerMpscBounded = ActionRequestHandlerInterface< pub type ActionRequestHandlerOneSenderMpscBounded = ActionRequestHandlerInterface<
mpsc::SyncSender<GenericMessage<ActionReplyPus>>, mpsc::SyncSender<GenericMessage<ActionReplyPus>>,
mpsc::Receiver<GenericMessage<ActionRequest>>, mpsc::Receiver<GenericMessage<ActionRequest>>,
OneMessageSender<
GenericMessage<ActionReplyPus>,
mpsc::SyncSender<GenericMessage<ActionReplyPus>>,
>,
>; >;
pub type ActionRequestorMpsc = ActionRequestorInterface< pub type ActionRequestorWithSenderMapMpsc = ActionRequestorInterface<
mpsc::Sender<GenericMessage<ActionRequest>>, mpsc::Sender<GenericMessage<ActionRequest>>,
mpsc::Receiver<GenericMessage<ActionReplyPus>>, mpsc::Receiver<GenericMessage<ActionReplyPus>>,
MessageSenderMap<
GenericMessage<ActionRequest>,
mpsc::Sender<GenericMessage<ActionRequest>>,
>,
>; >;
pub type ActionRequestorBoundedMpsc = ActionRequestorInterface< pub type ActionRequestorWithSenderMapBoundedMpsc = ActionRequestorInterface<
mpsc::SyncSender<GenericMessage<ActionRequest>>, mpsc::SyncSender<GenericMessage<ActionRequest>>,
mpsc::Receiver<GenericMessage<ActionReplyPus>>, mpsc::Receiver<GenericMessage<ActionReplyPus>>,
MessageSenderMap<
GenericMessage<ActionRequest>,
mpsc::SyncSender<GenericMessage<ActionRequest>>,
>,
>; >;
} }

8
satrs/src/pus/mode.rs
View File

@ -39,7 +39,7 @@ mod tests {
use crate::{ use crate::{
mode::{ mode::{
ModeAndSubmode, ModeReply, ModeReplySender, ModeRequest, ModeRequestSender, ModeAndSubmode, ModeReply, ModeReplySender, ModeRequest, ModeRequestSender,
ModeRequestorAndHandlerMpsc, ModeRequestorMpsc, ModeRequestorAndHandlerOneParentMpsc, ModeRequestorOneChildMpsc,
}, },
request::{GenericMessage, MessageMetadata}, request::{GenericMessage, MessageMetadata},
}; };
@ -52,7 +52,7 @@ mod tests {
fn test_simple_mode_requestor() { fn test_simple_mode_requestor() {
let (reply_sender, reply_receiver) = mpsc::channel(); let (reply_sender, reply_receiver) = mpsc::channel();
let (request_sender, request_receiver) = mpsc::channel(); let (request_sender, request_receiver) = mpsc::channel();
let mut mode_requestor = ModeRequestorMpsc::new(TEST_COMPONENT_ID_0, reply_receiver); let mut mode_requestor = ModeRequestorOneChildMpsc::new(TEST_COMPONENT_ID_0, reply_receiver);
mode_requestor.add_message_target(TEST_COMPONENT_ID_1, request_sender); mode_requestor.add_message_target(TEST_COMPONENT_ID_1, request_sender);
// Send a request and verify it arrives at the receiver. // Send a request and verify it arrives at the receiver.
@ -89,7 +89,7 @@ mod tests {
let (request_sender_to_channel_1, request_receiver_channel_1) = mpsc::channel(); let (request_sender_to_channel_1, request_receiver_channel_1) = mpsc::channel();
//let (reply_sender_to_channel_2, reply_receiver_channel_2) = mpsc::channel(); //let (reply_sender_to_channel_2, reply_receiver_channel_2) = mpsc::channel();
let mut mode_connector = ModeRequestorAndHandlerMpsc::new( let mut mode_connector = ModeRequestorAndHandlerOneParentMpsc::new(
TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_0,
request_receiver_of_connector, request_receiver_of_connector,
reply_receiver_of_connector, reply_receiver_of_connector,
@ -128,7 +128,7 @@ mod tests {
let (_request_sender_to_connector, request_receiver_of_connector) = mpsc::channel(); let (_request_sender_to_connector, request_receiver_of_connector) = mpsc::channel();
let (reply_sender_to_channel_2, reply_receiver_channel_2) = mpsc::channel(); let (reply_sender_to_channel_2, reply_receiver_channel_2) = mpsc::channel();
let mut mode_connector = ModeRequestorAndHandlerMpsc::new( let mut mode_connector = ModeRequestorAndHandlerOneParentMpsc::new(
TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_0,
request_receiver_of_connector, request_receiver_of_connector,
reply_receiver_of_connector, reply_receiver_of_connector,

179
satrs/src/request.rs
View File

@ -140,24 +140,27 @@ impl<Message> GenericMessage<Message> {
} }
/// Generic trait for objects which can send targeted messages. /// Generic trait for objects which can send targeted messages.
pub trait MessageSender<MSG>: Send { pub trait MessageSenderProvider<MSG>: Send {
fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError>; fn send(&self, message: GenericMessage<MSG>) -> Result<(), GenericTargetedMessagingError>;
} }
// Generic trait for objects which can receive targeted messages. // Generic trait for objects which can receive targeted messages.
pub trait MessageReceiver<MSG> { pub trait MessageReceiverProvider<MSG> {
fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>; fn try_recv(&self) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError>;
} }
pub struct MessageWithSenderIdReceiver<MSG, R: MessageReceiver<MSG>>(pub R, PhantomData<MSG>); pub struct MessageWithSenderIdReceiver<MSG, R: MessageReceiverProvider<MSG>>(
pub R,
PhantomData<MSG>,
);
impl<MSG, R: MessageReceiver<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> { impl<MSG, R: MessageReceiverProvider<MSG>> From<R> for MessageWithSenderIdReceiver<MSG, R> {
fn from(receiver: R) -> Self { fn from(receiver: R) -> Self {
MessageWithSenderIdReceiver(receiver, PhantomData) MessageWithSenderIdReceiver(receiver, PhantomData)
} }
} }
impl<MSG, R: MessageReceiver<MSG>> MessageWithSenderIdReceiver<MSG, R> { impl<MSG, R: MessageReceiverProvider<MSG>> MessageWithSenderIdReceiver<MSG, R> {
pub fn try_recv_message( pub fn try_recv_message(
&self, &self,
) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
@ -165,12 +168,12 @@ impl<MSG, R: MessageReceiver<MSG>> MessageWithSenderIdReceiver<MSG, R> {
} }
} }
pub struct MessageReceiverWithId<MSG, R: MessageReceiver<MSG>> { pub struct MessageReceiverWithId<MSG, R: MessageReceiverProvider<MSG>> {
local_channel_id: ComponentId, local_channel_id: ComponentId,
reply_receiver: MessageWithSenderIdReceiver<MSG, R>, reply_receiver: MessageWithSenderIdReceiver<MSG, R>,
} }
impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> { impl<MSG, R: MessageReceiverProvider<MSG>> MessageReceiverWithId<MSG, R> {
pub fn new(local_channel_id: ComponentId, reply_receiver: R) -> Self { pub fn new(local_channel_id: ComponentId, reply_receiver: R) -> Self {
Self { Self {
local_channel_id, local_channel_id,
@ -183,7 +186,7 @@ impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
} }
} }
impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> { impl<MSG, R: MessageReceiverProvider<MSG>> MessageReceiverWithId<MSG, R> {
pub fn try_recv_message( pub fn try_recv_message(
&self, &self,
) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> { ) -> Result<Option<GenericMessage<MSG>>, GenericTargetedMessagingError> {
@ -191,6 +194,17 @@ impl<MSG, R: MessageReceiver<MSG>> MessageReceiverWithId<MSG, R> {
} }
} }
pub trait MessageSenderStoreProvider<Message, Sender>: Default {
fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender);
fn send_message(
&self,
requestor_info: MessageMetadata,
target_channel_id: ComponentId,
message: Message,
) -> Result<(), GenericTargetedMessagingError>;
}
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub mod alloc_mod { pub mod alloc_mod {
use crate::queue::GenericSendError; use crate::queue::GenericSendError;
@ -198,23 +212,99 @@ pub mod alloc_mod {
use super::*; use super::*;
use hashbrown::HashMap; use hashbrown::HashMap;
pub struct MessageSenderMap<MSG, S: MessageSender<MSG>>( pub struct OneMessageSender<Msg, S: MessageSenderProvider<Msg>> {
pub HashMap<ComponentId, S>, pub id_and_sender: Option<(ComponentId, S)>,
pub(crate) phantom: PhantomData<Msg>,
}
impl<Msg, S: MessageSenderProvider<Msg>> Default for OneMessageSender<Msg, S> {
fn default() -> Self {
Self {
id_and_sender: Default::default(),
phantom: Default::default(),
}
}
}
impl<Msg, S: MessageSenderProvider<Msg>> MessageSenderStoreProvider<Msg, S>
for OneMessageSender<Msg, S>
{
fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
if self.id_and_sender.is_some() {
return;
}
self.id_and_sender = Some((target_id, message_sender));
}
fn send_message(
&self,
requestor_info: MessageMetadata,
target_channel_id: ComponentId,
message: Msg,
) -> Result<(), GenericTargetedMessagingError> {
if let Some((current_id, sender)) = &self.id_and_sender {
if *current_id == target_channel_id {
sender.send(GenericMessage::new(requestor_info, message))?;
return Ok(());
}
}
Err(GenericSendError::TargetDoesNotExist(target_channel_id).into())
}
}
pub struct MessageSenderList<MSG, S: MessageSenderProvider<MSG>>(
pub alloc::vec::Vec<(ComponentId, S)>,
pub(crate) PhantomData<MSG>, pub(crate) PhantomData<MSG>,
); );
impl<MSG, S: MessageSender<MSG>> Default for MessageSenderMap<MSG, S> { impl<MSG, S: MessageSenderProvider<MSG>> Default for MessageSenderList<MSG, S> {
fn default() -> Self { fn default() -> Self {
Self(Default::default(), PhantomData) Self(Default::default(), PhantomData)
} }
} }
impl<MSG, S: MessageSender<MSG>> MessageSenderMap<MSG, S> { impl<MSG, S: MessageSenderProvider<MSG>> MessageSenderStoreProvider<MSG, S>
pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) { for MessageSenderList<MSG, S>
{
fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
self.0.push((target_id, message_sender));
}
fn send_message(
&self,
requestor_info: MessageMetadata,
target_channel_id: ComponentId,
message: MSG,
) -> Result<(), GenericTargetedMessagingError> {
for (current_id, sender) in &self.0 {
if *current_id == target_channel_id {
sender.send(GenericMessage::new(requestor_info, message))?;
return Ok(());
}
}
Err(GenericSendError::TargetDoesNotExist(target_channel_id).into())
}
}
pub struct MessageSenderMap<MSG, S: MessageSenderProvider<MSG>>(
pub HashMap<ComponentId, S>,
pub(crate) PhantomData<MSG>,
);
impl<MSG, S: MessageSenderProvider<MSG>> Default for MessageSenderMap<MSG, S> {
fn default() -> Self {
Self(Default::default(), PhantomData)
}
}
impl<MSG, S: MessageSenderProvider<MSG>> MessageSenderStoreProvider<MSG, S>
for MessageSenderMap<MSG, S>
{
fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) {
self.0.insert(target_id, message_sender); self.0.insert(target_id, message_sender);
} }
pub fn send_message( fn send_message(
&self, &self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
target_channel_id: ComponentId, target_channel_id: ComponentId,
@ -231,25 +321,38 @@ pub mod alloc_mod {
} }
} }
pub struct MessageSenderAndReceiver<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>> { pub struct MessageSenderAndReceiver<
To,
From,
Sender: MessageSenderProvider<To>,
Receiver: MessageReceiverProvider<From>,
SenderStore: MessageSenderStoreProvider<To, Sender>,
> {
pub local_channel_id: ComponentId, pub local_channel_id: ComponentId,
pub message_sender_map: MessageSenderMap<TO, S>, pub message_sender_store: SenderStore,
pub message_receiver: MessageWithSenderIdReceiver<FROM, R>, pub message_receiver: MessageWithSenderIdReceiver<From, Receiver>,
pub(crate) phantom: PhantomData<(To, Sender)>,
} }
impl<TO, FROM, S: MessageSender<TO>, R: MessageReceiver<FROM>> impl<
MessageSenderAndReceiver<TO, FROM, S, R> To,
From,
Sender: MessageSenderProvider<To>,
Receiver: MessageReceiverProvider<From>,
SenderStore: MessageSenderStoreProvider<To, Sender>,
> MessageSenderAndReceiver<To, From, Sender, Receiver, SenderStore>
{ {
pub fn new(local_channel_id: ComponentId, message_receiver: R) -> Self { pub fn new(local_channel_id: ComponentId, message_receiver: Receiver) -> Self {
Self { Self {
local_channel_id, local_channel_id,
message_sender_map: Default::default(), message_sender_store: Default::default(),
message_receiver: MessageWithSenderIdReceiver::from(message_receiver), message_receiver: MessageWithSenderIdReceiver::from(message_receiver),
phantom: PhantomData,
} }
} }
pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: S) { pub fn add_message_target(&mut self, target_id: ComponentId, message_sender: Sender) {
self.message_sender_map self.message_sender_store
.add_message_target(target_id, message_sender) .add_message_target(target_id, message_sender)
} }
@ -262,9 +365,9 @@ pub mod alloc_mod {
&self, &self,
request_id: RequestId, request_id: RequestId,
target_id: ComponentId, target_id: ComponentId,
message: TO, message: To,
) -> Result<(), GenericTargetedMessagingError> { ) -> Result<(), GenericTargetedMessagingError> {
self.message_sender_map.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,
message, message,
@ -274,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>>, GenericTargetedMessagingError> {
self.message_receiver.try_recv_message() self.message_receiver.try_recv_message()
} }
} }
@ -282,10 +385,10 @@ pub mod alloc_mod {
pub struct RequestAndReplySenderAndReceiver< pub struct RequestAndReplySenderAndReceiver<
REQUEST, REQUEST,
REPLY, REPLY,
S0: MessageSender<REQUEST>, S0: MessageSenderProvider<REQUEST>,
R0: MessageReceiver<REPLY>, R0: MessageReceiverProvider<REPLY>,
S1: MessageSender<REPLY>, S1: MessageSenderProvider<REPLY>,
R1: MessageReceiver<REQUEST>, R1: MessageReceiverProvider<REQUEST>,
> { > {
pub local_channel_id: ComponentId, pub local_channel_id: ComponentId,
// These 2 are a functional group. // These 2 are a functional group.
@ -299,10 +402,10 @@ pub mod alloc_mod {
impl< impl<
REQUEST, REQUEST,
REPLY, REPLY,
S0: MessageSender<REQUEST>, S0: MessageSenderProvider<REQUEST>,
R0: MessageReceiver<REPLY>, R0: MessageReceiverProvider<REPLY>,
S1: MessageSender<REPLY>, S1: MessageSenderProvider<REPLY>,
R1: MessageReceiver<REQUEST>, R1: MessageReceiverProvider<REQUEST>,
> RequestAndReplySenderAndReceiver<REQUEST, REPLY, S0, R0, S1, R1> > RequestAndReplySenderAndReceiver<REQUEST, REPLY, S0, R0, S1, R1>
{ {
pub fn new( pub fn new(
@ -333,14 +436,14 @@ pub mod std_mod {
use crate::queue::{GenericReceiveError, GenericSendError}; use crate::queue::{GenericReceiveError, GenericSendError};
impl<MSG: Send> MessageSender<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<(), GenericTargetedMessagingError> {
self.send(message) self.send(message)
.map_err(|_| GenericSendError::RxDisconnected)?; .map_err(|_| GenericSendError::RxDisconnected)?;
Ok(()) Ok(())
} }
} }
impl<MSG: Send> MessageSender<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<(), GenericTargetedMessagingError> {
if let Err(e) = self.try_send(message) { if let Err(e) = self.try_send(message) {
return match e { return match e {
@ -357,7 +460,7 @@ pub mod std_mod {
pub type MessageSenderMapMpsc<MSG> = MessageReceiverWithId<MSG, mpsc::Sender<MSG>>; pub type MessageSenderMapMpsc<MSG> = MessageReceiverWithId<MSG, mpsc::Sender<MSG>>;
pub type MessageSenderMapBoundedMpsc<MSG> = MessageReceiverWithId<MSG, mpsc::SyncSender<MSG>>; pub type MessageSenderMapBoundedMpsc<MSG> = MessageReceiverWithId<MSG, mpsc::SyncSender<MSG>>;
impl<MSG> MessageReceiver<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>>, GenericTargetedMessagingError> {
match self.try_recv() { match self.try_recv() {
Ok(msg) => Ok(Some(msg)), Ok(msg) => Ok(Some(msg)),
@ -386,7 +489,7 @@ mod tests {
use crate::{ use crate::{
queue::{GenericReceiveError, GenericSendError, GenericTargetedMessagingError}, queue::{GenericReceiveError, GenericSendError, GenericTargetedMessagingError},
request::{MessageMetadata, MessageSenderMap}, request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider},
}; };
use super::{GenericMessage, MessageReceiverWithId, UniqueApidTargetId}; use super::{GenericMessage, MessageReceiverWithId, UniqueApidTargetId};

233
satrs/tests/mode_tree.rs
View File

@ -1,9 +1,5 @@
use core::cell::Cell; use core::cell::Cell;
use satrs::mode::{ use satrs::mode::{Mode, ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, ModeRequestHandler, ModeRequestHandlerOneParentMpscBounded, ModeRequestReceiver, ModeRequestSender, ModeRequestorAndHandlerOneParentMpscBounded, ModeRequestorOneChildBoundedMpsc};
Mode, ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, ModeRequestHandler,
ModeRequestHandlerMpscBounded, ModeRequestReceiver, ModeRequestorAndHandlerMpscBounded,
ModeRequestorBoundedMpsc,
};
use satrs::mode_tree::{ use satrs::mode_tree::{
connect_mode_nodes, ModeChild, ModeNode, ModeParent, ModeStoreProvider, SequenceTableMapTable, connect_mode_nodes, ModeChild, ModeNode, ModeParent, ModeStoreProvider, SequenceTableMapTable,
TargetTableEntry, TargetTableEntry,
@ -159,7 +155,7 @@ impl ModeRequestHandler for ModeRequestHandlerMock {
struct PusModeService { struct PusModeService {
pub request_id_counter: Cell<u32>, pub request_id_counter: Cell<u32>,
pub mode_node: ModeRequestorBoundedMpsc, pub mode_node: ModeRequestorOneChildBoundedMpsc,
} }
impl PusModeService { impl PusModeService {
@ -191,16 +187,17 @@ impl ModeParent for PusModeService {
} }
struct AcsSubsystem { struct AcsSubsystem {
pub mode_node: ModeRequestorAndHandlerMpscBounded, pub mode_node: ModeRequestorAndHandlerOneParentMpscBounded,
pub mode_requestor_info: Option<MessageMetadata>, pub mode_requestor_info: Option<MessageMetadata>,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub target_mode_and_submode: Option<ModeAndSubmode>, pub target_mode_and_submode: Option<ModeAndSubmode>,
pub subsystem_helper: SubsystemHelper, pub subsystem_helper: SubsystemHelper,
pub mode_req_handler_mock: ModeRequestHandlerMock, pub mode_req_handler_mock: ModeRequestHandlerMock,
pub mode_msgs_recvd: u32,
} }
impl AcsSubsystem { impl AcsSubsystem {
pub fn new(mode_node: ModeRequestorAndHandlerMpscBounded) -> Self { pub fn new(mode_node: ModeRequestorAndHandlerOneParentMpscBounded) -> Self {
Self { Self {
mode_node, mode_node,
mode_requestor_info: None, mode_requestor_info: None,
@ -208,13 +205,25 @@ impl AcsSubsystem {
target_mode_and_submode: None, target_mode_and_submode: None,
subsystem_helper: Default::default(), subsystem_helper: Default::default(),
mode_req_handler_mock: Default::default(), mode_req_handler_mock: Default::default(),
mode_msgs_recvd: 0,
} }
} }
pub fn get_and_clear_num_mode_msgs(&mut self) -> u32 {
let tmp = self.mode_msgs_recvd;
self.mode_msgs_recvd = 0;
tmp
}
pub fn run(&mut self) { pub fn run(&mut self) {
if let Some(request) = self.mode_node.try_recv_mode_request().unwrap() { if let Some(request) = self.mode_node.try_recv_mode_request().unwrap() {
self.mode_msgs_recvd += 1;
self.handle_mode_request(request) self.handle_mode_request(request)
.expect("mode messaging error"); .expect("mode messaging error");
} }
if let Some(_reply) = self.mode_node.try_recv_mode_reply().unwrap(){
// TODO: Implementation.
}
} }
pub fn add_target_and_sequence_table( pub fn add_target_and_sequence_table(
&mut self, &mut self,
@ -345,20 +354,34 @@ impl ModeRequestHandler for AcsSubsystem {
} }
struct MgmAssembly { struct MgmAssembly {
pub mode_node: ModeRequestorAndHandlerMpscBounded, pub mode_node: ModeRequestorAndHandlerOneParentMpscBounded,
pub mode_requestor_info: Option<MessageMetadata>, pub mode_requestor_info: Option<MessageMetadata>,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub target_mode_and_submode: Option<ModeAndSubmode>, pub target_mode_and_submode: Option<ModeAndSubmode>,
pub mode_req_mock: ModeRequestHandlerMock, pub mode_req_mock: ModeRequestHandlerMock,
pub mode_msgs_recvd: u32,
} }
impl MgmAssembly { impl MgmAssembly {
pub fn new(mode_node: ModeRequestorAndHandlerOneParentMpscBounded) -> Self {
Self {
mode_node,
mode_requestor_info: None,
mode_and_submode: UNKNOWN_MODE,
target_mode_and_submode: None,
mode_req_mock: Default::default(),
mode_msgs_recvd: 0,
}
}
pub fn run(&mut self) { pub fn run(&mut self) {
self.check_mode_requests().expect("mode messaging error"); self.check_mode_requests().expect("mode messaging error");
self.check_mode_replies().expect("mode messaging error"); self.check_mode_replies().expect("mode messaging error");
} }
fn id(&self) -> ComponentId { pub fn get_and_clear_num_mode_msgs(&mut self) -> u32 {
TestComponentId::MagnetometerAssembly as u64 let tmp = self.mode_msgs_recvd;
self.mode_msgs_recvd = 0;
tmp
} }
pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> { pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
@ -395,7 +418,7 @@ impl MgmAssembly {
impl ModeNode for MgmAssembly { impl ModeNode for MgmAssembly {
fn id(&self) -> ComponentId { fn id(&self) -> ComponentId {
self.id() TestComponentId::MagnetometerAssembly as u64
} }
} }
impl ModeParent for MgmAssembly { impl ModeParent for MgmAssembly {
@ -473,18 +496,6 @@ impl ModeRequestHandler for MgmAssembly {
Ok(()) Ok(())
} }
fn send_mode_reply(
&self,
requestor: MessageMetadata,
reply: ModeReply,
) -> Result<(), Self::Error> {
self.mode_node.send_mode_reply(requestor, reply)?;
self.mode_req_mock
.send_mode_reply(requestor, reply)
.unwrap();
Ok(())
}
fn handle_mode_info( fn handle_mode_info(
&mut self, &mut self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
@ -496,21 +507,34 @@ impl ModeRequestHandler for MgmAssembly {
// TODO: A proper assembly must reach to mode changes of its children.. // TODO: A proper assembly must reach to mode changes of its children..
Ok(()) Ok(())
} }
fn send_mode_reply(
&self,
requestor: MessageMetadata,
reply: ModeReply,
) -> Result<(), Self::Error> {
self.mode_node.send_mode_reply(requestor, reply)?;
self.mode_req_mock
.send_mode_reply(requestor, reply)
.unwrap();
Ok(())
}
} }
struct DeviceManager { struct DeviceManager {
name: &'static str, name: &'static str,
pub id: ComponentId, pub id: ComponentId,
pub mode_node: ModeRequestorAndHandlerMpscBounded, pub mode_node: ModeRequestorAndHandlerOneParentMpscBounded,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub mode_req_mock: ModeRequestHandlerMock, pub mode_req_mock: ModeRequestHandlerMock,
pub mode_msgs_recvd: u32,
} }
impl DeviceManager { impl DeviceManager {
pub fn new( pub fn new(
name: &'static str, name: &'static str,
id: ComponentId, id: ComponentId,
mode_node: ModeRequestorAndHandlerMpscBounded, mode_node: ModeRequestorAndHandlerOneParentMpscBounded,
) -> Self { ) -> Self {
Self { Self {
name, name,
@ -518,8 +542,26 @@ impl DeviceManager {
mode_node, mode_node,
mode_and_submode: UNKNOWN_MODE, mode_and_submode: UNKNOWN_MODE,
mode_req_mock: Default::default(), mode_req_mock: Default::default(),
mode_msgs_recvd: 0,
} }
} }
pub fn get_and_clear_num_mode_msgs(&mut self) -> u32 {
let tmp = self.mode_msgs_recvd;
self.mode_msgs_recvd = 0;
tmp
}
pub fn run(&mut self) {
self.check_mode_requests().expect("mode messaging error");
}
pub fn check_mode_requests(&mut self) -> Result<(), ModeError> {
if let Some(request) = self.mode_node.try_recv_mode_request()? {
self.handle_mode_request(request)?
}
Ok(())
}
} }
impl ModeNode for DeviceManager { impl ModeNode for DeviceManager {
@ -571,6 +613,23 @@ impl ModeRequestHandler for DeviceManager {
"{}: announcing mode: {:?}", "{}: announcing mode: {:?}",
self.name, self.mode_and_submode self.name, self.mode_and_submode
); );
let mut mode_request = ModeRequest::AnnounceMode;
if recursive {
mode_request = ModeRequest::AnnounceModeRecursive;
}
let request_id = requestor_info.map_or(0, |info| info.request_id());
self.mode_node
.request_sender_map
.0
.iter()
.for_each(|(_, sender)| {
sender
.send(GenericMessage::new(
MessageMetadata::new(request_id, self.mode_node.local_channel_id_generic()),
mode_request,
))
.expect("sending mode request failed");
});
self.mode_req_mock.announce_mode(requestor_info, recursive); self.mode_req_mock.announce_mode(requestor_info, recursive);
} }
@ -581,18 +640,6 @@ impl ModeRequestHandler for DeviceManager {
self.mode_req_mock.handle_mode_reached(requestor).unwrap(); self.mode_req_mock.handle_mode_reached(requestor).unwrap();
Ok(()) Ok(())
} }
fn send_mode_reply(
&self,
requestor_info: MessageMetadata,
reply: ModeReply,
) -> Result<(), ModeError> {
self.mode_node.send_mode_reply(requestor_info, reply)?;
self.mode_req_mock
.send_mode_reply(requestor_info, reply)
.unwrap();
Ok(())
}
fn handle_mode_info( fn handle_mode_info(
&mut self, &mut self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
@ -610,21 +657,34 @@ impl ModeRequestHandler for DeviceManager {
.unwrap(); .unwrap();
Ok(()) Ok(())
} }
fn send_mode_reply(
&self,
requestor_info: MessageMetadata,
reply: ModeReply,
) -> Result<(), ModeError> {
self.mode_node.send_mode_reply(requestor_info, reply)?;
self.mode_req_mock
.send_mode_reply(requestor_info, reply)
.unwrap();
Ok(())
}
} }
struct CommonDevice { struct CommonDevice {
name: &'static str, name: &'static str,
pub id: ComponentId, pub id: ComponentId,
pub mode_node: ModeRequestHandlerMpscBounded, pub mode_node: ModeRequestHandlerOneParentMpscBounded,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub mode_req_mock: ModeRequestHandlerMock, pub mode_req_mock: ModeRequestHandlerMock,
pub num_mode_msgs_recvd: u32,
} }
impl CommonDevice { impl CommonDevice {
pub fn new( pub fn new(
name: &'static str, name: &'static str,
id: ComponentId, id: ComponentId,
mode_node: ModeRequestHandlerMpscBounded, mode_node: ModeRequestHandlerOneParentMpscBounded,
) -> Self { ) -> Self {
Self { Self {
name, name,
@ -632,6 +692,7 @@ impl CommonDevice {
mode_node, mode_node,
mode_and_submode: UNKNOWN_MODE, mode_and_submode: UNKNOWN_MODE,
mode_req_mock: Default::default(), mode_req_mock: Default::default(),
num_mode_msgs_recvd: 0,
} }
} }
@ -641,10 +702,17 @@ impl CommonDevice {
pub fn check_mode_requests(&mut self) -> Result<(), ModeError> { pub fn check_mode_requests(&mut self) -> Result<(), ModeError> {
if let Some(request) = self.mode_node.try_recv_mode_request()? { if let Some(request) = self.mode_node.try_recv_mode_request()? {
self.num_mode_msgs_recvd += 1;
self.handle_mode_request(request)? self.handle_mode_request(request)?
} }
Ok(()) Ok(())
} }
pub fn get_and_clear_num_mode_msgs(&mut self) -> u32 {
let tmp = self.num_mode_msgs_recvd;
self.num_mode_msgs_recvd = 0;
tmp
}
} }
impl ModeNode for CommonDevice { impl ModeNode for CommonDevice {
@ -698,18 +766,6 @@ impl ModeRequestHandler for CommonDevice {
self.mode_req_mock.handle_mode_reached(requestor).unwrap(); self.mode_req_mock.handle_mode_reached(requestor).unwrap();
Ok(()) Ok(())
} }
fn send_mode_reply(
&self,
requestor_info: MessageMetadata,
reply: ModeReply,
) -> Result<(), ModeError> {
self.mode_node.send_mode_reply(requestor_info, reply)?;
self.mode_req_mock
.send_mode_reply(requestor_info, reply)
.unwrap();
Ok(())
}
fn handle_mode_info( fn handle_mode_info(
&mut self, &mut self,
requestor_info: MessageMetadata, requestor_info: MessageMetadata,
@ -727,6 +783,18 @@ impl ModeRequestHandler for CommonDevice {
.unwrap(); .unwrap();
Ok(()) Ok(())
} }
fn send_mode_reply(
&self,
requestor_info: MessageMetadata,
reply: ModeReply,
) -> Result<(), ModeError> {
self.mode_node.send_mode_reply(requestor_info, reply)?;
self.mode_req_mock
.send_mode_reply(requestor_info, reply)
.unwrap();
Ok(())
}
} }
#[derive(Debug, Default)] #[derive(Debug, Default)]
@ -736,7 +804,7 @@ pub struct AnnounceModeInfo {
} }
pub struct AcsController { pub struct AcsController {
pub mode_node: ModeRequestHandlerMpscBounded, pub mode_node: ModeRequestHandlerOneParentMpscBounded,
pub mode_and_submode: ModeAndSubmode, pub mode_and_submode: ModeAndSubmode,
pub announce_mode_queue: RefCell<VecDeque<AnnounceModeInfo>>, pub announce_mode_queue: RefCell<VecDeque<AnnounceModeInfo>>,
pub mode_req_mock: ModeRequestHandlerMock, pub mode_req_mock: ModeRequestHandlerMock,
@ -879,42 +947,42 @@ impl TreeTestbench {
let (reply_sender_to_mgt_man, reply_receiver_mgt_man) = mpsc::sync_channel(10); let (reply_sender_to_mgt_man, reply_receiver_mgt_man) = mpsc::sync_channel(10);
// Mode requestors only. // Mode requestors only.
let mode_node_pus = ModeRequestorBoundedMpsc::new( let mode_node_pus = ModeRequestorOneChildBoundedMpsc::new(
TestComponentId::PusModeService as ComponentId, TestComponentId::PusModeService as ComponentId,
reply_receiver_pus, reply_receiver_pus,
); );
// Mode requestors and handlers. // Mode requestors and handlers.
let mut mgm_assy_node = ModeRequestorAndHandlerMpscBounded::new( let mgm_assy_node = ModeRequestorAndHandlerOneParentMpscBounded::new(
TestComponentId::MagnetometerAssembly as ComponentId, TestComponentId::MagnetometerAssembly as ComponentId,
request_receiver_mgm_assy, request_receiver_mgm_assy,
reply_receiver_mgm_assy, reply_receiver_mgm_assy,
); );
let mut mgt_dev_mgmt_node = ModeRequestorAndHandlerMpscBounded::new( let mgt_dev_mgmt_node = ModeRequestorAndHandlerOneParentMpscBounded::new(
TestComponentId::MgtDevManager as ComponentId, TestComponentId::MgtDevManager as ComponentId,
request_receiver_mgt_man, request_receiver_mgt_man,
reply_receiver_mgt_man, reply_receiver_mgt_man,
); );
let acs_subsystem_node = ModeRequestorAndHandlerMpscBounded::new( let acs_subsystem_node = ModeRequestorAndHandlerOneParentMpscBounded::new(
TestComponentId::AcsSubsystem as ComponentId, TestComponentId::AcsSubsystem as ComponentId,
request_receiver_acs_subsystem, request_receiver_acs_subsystem,
reply_receiver_acs_subsystem, reply_receiver_acs_subsystem,
); );
// Request handlers only. // Request handlers only.
let mut mgm_dev_node_0 = ModeRequestHandlerMpscBounded::new( let mgm_dev_node_0 = ModeRequestHandlerOneParentMpscBounded::new(
TestComponentId::MagnetometerDevice0 as ComponentId, TestComponentId::MagnetometerDevice0 as ComponentId,
request_receiver_mgm_dev_0, request_receiver_mgm_dev_0,
); );
let mut mgm_dev_node_1 = ModeRequestHandlerMpscBounded::new( let mgm_dev_node_1 = ModeRequestHandlerOneParentMpscBounded::new(
TestComponentId::MagnetometerDevice1 as ComponentId, TestComponentId::MagnetometerDevice1 as ComponentId,
request_receiver_mgm_dev_1, request_receiver_mgm_dev_1,
); );
let mut mgt_dev_node = ModeRequestHandlerMpscBounded::new( let mgt_dev_node = ModeRequestHandlerOneParentMpscBounded::new(
TestComponentId::MagnetorquerDevice as ComponentId, TestComponentId::MagnetorquerDevice as ComponentId,
request_receiver_mgt_dev, request_receiver_mgt_dev,
); );
let acs_ctrl_node = ModeRequestHandlerMpscBounded::new( let acs_ctrl_node = ModeRequestHandlerOneParentMpscBounded::new(
TestComponentId::AcsController as ComponentId, TestComponentId::AcsController as ComponentId,
request_receiver_acs_ctrl, request_receiver_acs_ctrl,
); );
@ -926,7 +994,7 @@ impl TreeTestbench {
); );
let mut mgm_dev_1 = CommonDevice::new( let mut mgm_dev_1 = CommonDevice::new(
"MGM_1", "MGM_1",
TestComponentId::MagnetometerDevice0 as u64, TestComponentId::MagnetometerDevice1 as u64,
mgm_dev_node_1, mgm_dev_node_1,
); );
let mut mgt_dev = CommonDevice::new( let mut mgt_dev = CommonDevice::new(
@ -939,13 +1007,7 @@ impl TreeTestbench {
TestComponentId::MgtDevManager as u64, TestComponentId::MgtDevManager as u64,
mgt_dev_mgmt_node, mgt_dev_mgmt_node,
); );
let mut mgm_assy = MgmAssembly { let mut mgm_assy = MgmAssembly::new(mgm_assy_node);
mode_node: mgm_assy_node,
mode_requestor_info: None,
mode_and_submode: UNKNOWN_MODE,
target_mode_and_submode: None,
mode_req_mock: ModeRequestHandlerMock::default(),
};
let mut acs_subsystem = AcsSubsystem::new(acs_subsystem_node); let mut acs_subsystem = AcsSubsystem::new(acs_subsystem_node);
let mut acs_ctrl = AcsController { let mut acs_ctrl = AcsController {
mode_node: acs_ctrl_node, mode_node: acs_ctrl_node,
@ -1042,8 +1104,8 @@ impl TreeTestbench {
); );
connect_mode_nodes( connect_mode_nodes(
&mut acs_subsystem, &mut acs_subsystem,
request_sender_to_mgt_dev.clone(), request_sender_to_mgt_man.clone(),
&mut mgt_dev, &mut mgt_manager,
reply_sender_to_acs_subsystem.clone(), reply_sender_to_acs_subsystem.clone(),
); );
@ -1059,6 +1121,7 @@ impl TreeTestbench {
&mut mgm_dev_1, &mut mgm_dev_1,
reply_sender_to_mgm_assy, reply_sender_to_mgm_assy,
); );
connect_mode_nodes( connect_mode_nodes(
&mut mgt_manager, &mut mgt_manager,
request_sender_to_mgt_dev, request_sender_to_mgt_dev,
@ -1081,12 +1144,16 @@ impl TreeTestbench {
fn announce_recursively() { fn announce_recursively() {
let mut tb = TreeTestbench::new(); let mut tb = TreeTestbench::new();
tb.pus.announce_modes_recursively(); tb.pus.announce_modes_recursively();
tb.subsystem.run(); // Run everything twice so the order does not matter.
tb.ctrl.run(); for _ in 0..2 {
tb.mgm_assy.run(); tb.subsystem.run();
tb.mgm_devs[0].run(); tb.ctrl.run();
tb.mgm_devs[1].run(); tb.mgt_manager.run();
tb.mgt_dev.run(); tb.mgm_assy.run();
tb.mgm_devs[0].run();
tb.mgm_devs[1].run();
tb.mgt_dev.run();
}
let mut announces = tb let mut announces = tb
.subsystem .subsystem
.mode_req_handler_mock .mode_req_handler_mock
@ -1101,17 +1168,27 @@ fn announce_recursively() {
assert_eq!(tb.mgm_assy.mode_req_mock.start_transition_calls.len(), 0); assert_eq!(tb.mgm_assy.mode_req_mock.start_transition_calls.len(), 0);
assert_eq!(tb.mgm_assy.mode_and_submode(), UNKNOWN_MODE); assert_eq!(tb.mgm_assy.mode_and_submode(), UNKNOWN_MODE);
assert_eq!(announces.len(), 1); assert_eq!(announces.len(), 1);
for mgm_dev in &tb.mgm_devs { for mgm_dev in &mut tb.mgm_devs {
assert_eq!(mgm_dev.get_and_clear_num_mode_msgs(), 1);
announces = mgm_dev.mode_req_mock.announce_mode_calls.borrow_mut(); announces = mgm_dev.mode_req_mock.announce_mode_calls.borrow_mut();
assert_eq!(mgm_dev.mode_req_mock.start_transition_calls.len(), 0); assert_eq!(mgm_dev.mode_req_mock.start_transition_calls.len(), 0);
assert_eq!(mgm_dev.mode_and_submode(), UNKNOWN_MODE); assert_eq!(mgm_dev.mode_and_submode(), UNKNOWN_MODE);
assert_eq!(announces.len(), 1); assert_eq!(announces.len(), 1);
} }
assert_eq!(announces.len(), 1); assert_eq!(announces.len(), 1);
assert_eq!(tb.mgt_dev.get_and_clear_num_mode_msgs(), 1);
announces = tb.mgt_dev.mode_req_mock.announce_mode_calls.borrow_mut(); announces = tb.mgt_dev.mode_req_mock.announce_mode_calls.borrow_mut();
assert_eq!(tb.mgt_dev.mode_req_mock.start_transition_calls.len(), 0); assert_eq!(tb.mgt_dev.mode_req_mock.start_transition_calls.len(), 0);
assert_eq!(tb.mgt_dev.mode_and_submode(), UNKNOWN_MODE); assert_eq!(tb.mgt_dev.mode_and_submode(), UNKNOWN_MODE);
assert_eq!(announces.len(), 1); assert_eq!(announces.len(), 1);
announces = tb
.mgt_manager
.mode_req_mock
.announce_mode_calls
.borrow_mut();
assert_eq!(tb.mgt_manager.mode_req_mock.start_transition_calls.len(), 0);
assert_eq!(tb.mgt_manager.mode_and_submode(), UNKNOWN_MODE);
assert_eq!(announces.len(), 1);
} }
#[test] #[test]