744 lines
28 KiB
Rust
744 lines
28 KiB
Rust
use crate::requests::GenericRequestRouter;
|
|
use log::warn;
|
|
use satrs::pool::PoolAddr;
|
|
use satrs::pus::verification::{
|
|
self, FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
|
|
VerificationReporterCfg, VerificationReportingProvider, VerificationToken,
|
|
};
|
|
use satrs::pus::{
|
|
ActiveRequestMapProvider, ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter,
|
|
EcssTcReceiver, EcssTmSender, EcssTmtcError, GenericConversionError, GenericRoutingError,
|
|
PusPacketHandlerResult, PusPacketHandlingError, PusReplyHandler, PusRequestRouter,
|
|
PusServiceHelper, PusTcToRequestConverter, TcInMemory,
|
|
};
|
|
use satrs::queue::{GenericReceiveError, GenericSendError};
|
|
use satrs::request::{Apid, GenericMessage, MessageMetadata};
|
|
use satrs::spacepackets::ecss::tc::PusTcReader;
|
|
use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
|
|
use satrs::tmtc::{PacketAsVec, PacketInPool};
|
|
use satrs::ComponentId;
|
|
use satrs_example::config::components::PUS_ROUTING_SERVICE;
|
|
use satrs_example::config::{tmtc_err, CustomPusServiceId};
|
|
use satrs_example::TimeStampHelper;
|
|
use std::fmt::Debug;
|
|
use std::sync::mpsc::{self, Sender};
|
|
|
|
pub mod action;
|
|
pub mod event;
|
|
pub mod hk;
|
|
pub mod mode;
|
|
pub mod scheduler;
|
|
pub mod stack;
|
|
pub mod test;
|
|
|
|
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
|
pub enum HandlingStatus {
|
|
Empty,
|
|
HandledOne,
|
|
}
|
|
|
|
pub fn create_verification_reporter(owner_id: ComponentId, apid: Apid) -> VerificationReporter {
|
|
let verif_cfg = VerificationReporterCfg::new(apid, 1, 2, 8).unwrap();
|
|
// Every software component which needs to generate verification telemetry, gets a cloned
|
|
// verification reporter.
|
|
VerificationReporter::new(owner_id, &verif_cfg)
|
|
}
|
|
|
|
/// Simple router structure which forwards PUS telecommands to dedicated handlers.
|
|
pub struct PusTcMpscRouter {
|
|
pub test_tc_sender: Sender<EcssTcAndToken>,
|
|
pub event_tc_sender: Sender<EcssTcAndToken>,
|
|
pub sched_tc_sender: Sender<EcssTcAndToken>,
|
|
pub hk_tc_sender: Sender<EcssTcAndToken>,
|
|
pub action_tc_sender: Sender<EcssTcAndToken>,
|
|
pub mode_tc_sender: Sender<EcssTcAndToken>,
|
|
}
|
|
|
|
pub struct PusTcDistributor<TmSender: EcssTmSender> {
|
|
pub id: ComponentId,
|
|
pub tm_sender: TmSender,
|
|
pub verif_reporter: VerificationReporter,
|
|
pub pus_router: PusTcMpscRouter,
|
|
stamp_helper: TimeStampHelper,
|
|
}
|
|
|
|
impl<TmSender: EcssTmSender> PusTcDistributor<TmSender> {
|
|
pub fn new(tm_sender: TmSender, pus_router: PusTcMpscRouter) -> Self {
|
|
Self {
|
|
id: PUS_ROUTING_SERVICE.raw(),
|
|
tm_sender,
|
|
verif_reporter: create_verification_reporter(
|
|
PUS_ROUTING_SERVICE.id(),
|
|
PUS_ROUTING_SERVICE.apid,
|
|
),
|
|
pus_router,
|
|
stamp_helper: TimeStampHelper::default(),
|
|
}
|
|
}
|
|
|
|
pub fn handle_tc_packet_vec(
|
|
&mut self,
|
|
packet_as_vec: PacketAsVec,
|
|
) -> Result<PusPacketHandlerResult, GenericSendError> {
|
|
self.handle_tc_generic(packet_as_vec.sender_id, None, &packet_as_vec.packet)
|
|
}
|
|
|
|
pub fn handle_tc_packet_in_store(
|
|
&mut self,
|
|
packet_in_pool: PacketInPool,
|
|
pus_tc_copy: &[u8],
|
|
) -> Result<PusPacketHandlerResult, GenericSendError> {
|
|
self.handle_tc_generic(
|
|
packet_in_pool.sender_id,
|
|
Some(packet_in_pool.store_addr),
|
|
pus_tc_copy,
|
|
)
|
|
}
|
|
|
|
pub fn handle_tc_generic(
|
|
&mut self,
|
|
sender_id: ComponentId,
|
|
addr_opt: Option<PoolAddr>,
|
|
raw_tc: &[u8],
|
|
) -> Result<PusPacketHandlerResult, GenericSendError> {
|
|
let pus_tc_result = PusTcReader::new(raw_tc);
|
|
if pus_tc_result.is_err() {
|
|
log::warn!(
|
|
"error creating PUS TC from raw data received from {}: {}",
|
|
sender_id,
|
|
pus_tc_result.unwrap_err()
|
|
);
|
|
log::warn!("raw data: {:x?}", raw_tc);
|
|
return Ok(PusPacketHandlerResult::RequestHandled);
|
|
}
|
|
let pus_tc = pus_tc_result.unwrap().0;
|
|
let init_token = self.verif_reporter.add_tc(&pus_tc);
|
|
self.stamp_helper.update_from_now();
|
|
let accepted_token = self
|
|
.verif_reporter
|
|
.acceptance_success(&self.tm_sender, init_token, self.stamp_helper.stamp())
|
|
.expect("Acceptance success failure");
|
|
let service = PusServiceId::try_from(pus_tc.service());
|
|
let tc_in_memory: TcInMemory = if let Some(store_addr) = addr_opt {
|
|
PacketInPool::new(sender_id, store_addr).into()
|
|
} else {
|
|
PacketAsVec::new(sender_id, Vec::from(raw_tc)).into()
|
|
};
|
|
match service {
|
|
Ok(standard_service) => match standard_service {
|
|
PusServiceId::Test => self.pus_router.test_tc_sender.send(EcssTcAndToken {
|
|
tc_in_memory,
|
|
token: Some(accepted_token.into()),
|
|
})?,
|
|
PusServiceId::Housekeeping => {
|
|
self.pus_router.hk_tc_sender.send(EcssTcAndToken {
|
|
tc_in_memory,
|
|
token: Some(accepted_token.into()),
|
|
})?
|
|
}
|
|
PusServiceId::Event => self.pus_router.event_tc_sender.send(EcssTcAndToken {
|
|
tc_in_memory,
|
|
token: Some(accepted_token.into()),
|
|
})?,
|
|
PusServiceId::Scheduling => {
|
|
self.pus_router.sched_tc_sender.send(EcssTcAndToken {
|
|
tc_in_memory,
|
|
token: Some(accepted_token.into()),
|
|
})?
|
|
}
|
|
_ => {
|
|
let result = self.verif_reporter.start_failure(
|
|
&self.tm_sender,
|
|
accepted_token,
|
|
FailParams::new(
|
|
self.stamp_helper.stamp(),
|
|
&tmtc_err::PUS_SERVICE_NOT_IMPLEMENTED,
|
|
&[standard_service as u8],
|
|
),
|
|
);
|
|
if result.is_err() {
|
|
warn!("Sending verification failure failed");
|
|
}
|
|
}
|
|
},
|
|
Err(e) => {
|
|
if let Ok(custom_service) = CustomPusServiceId::try_from(e.number) {
|
|
match custom_service {
|
|
CustomPusServiceId::Mode => self
|
|
.pus_router
|
|
.mode_tc_sender
|
|
.send(EcssTcAndToken {
|
|
tc_in_memory,
|
|
token: Some(accepted_token.into()),
|
|
})
|
|
.map_err(|_| GenericSendError::RxDisconnected)?,
|
|
CustomPusServiceId::Health => {}
|
|
}
|
|
} else {
|
|
self.verif_reporter
|
|
.start_failure(
|
|
&self.tm_sender,
|
|
accepted_token,
|
|
FailParams::new(
|
|
self.stamp_helper.stamp(),
|
|
&tmtc_err::INVALID_PUS_SUBSERVICE,
|
|
&[e.number],
|
|
),
|
|
)
|
|
.expect("Start failure verification failed")
|
|
}
|
|
}
|
|
}
|
|
Ok(PusPacketHandlerResult::RequestHandled)
|
|
}
|
|
}
|
|
|
|
pub trait TargetedPusService {
|
|
/// Returns [true] if the packet handling is finished.
|
|
fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus;
|
|
fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus;
|
|
fn check_for_request_timeouts(&mut self);
|
|
}
|
|
|
|
/// This is a generic handler class for all PUS services where a PUS telecommand is converted
|
|
/// to a targeted request.
|
|
///
|
|
/// The generic steps for this process are the following
|
|
///
|
|
/// 1. Poll for TC packets
|
|
/// 2. Convert the raw packets to a [PusTcReader].
|
|
/// 3. Convert the PUS TC to a typed request using the [PusTcToRequestConverter].
|
|
/// 4. Route the requests using the [GenericRequestRouter].
|
|
/// 5. Add the request to the active request map using the [ActiveRequestMapProvider] abstraction.
|
|
/// 6. Check for replies which complete the forwarded request. The handler takes care of
|
|
/// the verification process.
|
|
/// 7. Check for timeouts of active requests. Generally, the timeout on the service level should
|
|
/// be highest expected timeout for the given target.
|
|
///
|
|
/// The handler exposes the following API:
|
|
///
|
|
/// 1. [Self::poll_and_handle_next_tc] which tries to poll and handle one TC packet, covering
|
|
/// steps 1-5.
|
|
/// 2. [Self::poll_and_check_next_reply] which tries to poll and handle one reply, covering step 6.
|
|
/// 3. [Self::check_for_request_timeouts] which checks for request timeouts, covering step 7.
|
|
pub struct PusTargetedRequestService<
|
|
TcReceiver: EcssTcReceiver,
|
|
TmSender: EcssTmSender,
|
|
TcInMemConverter: EcssTcInMemConverter,
|
|
VerificationReporter: VerificationReportingProvider,
|
|
RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
|
|
ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
|
|
ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
|
|
ActiveRequestInfo: ActiveRequestProvider,
|
|
RequestType,
|
|
ReplyType,
|
|
> {
|
|
pub service_helper:
|
|
PusServiceHelper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
|
|
pub request_router: GenericRequestRouter,
|
|
pub request_converter: RequestConverter,
|
|
pub active_request_map: ActiveRequestMap,
|
|
pub reply_handler: ReplyHandler,
|
|
pub reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
|
|
phantom: std::marker::PhantomData<(RequestType, ActiveRequestInfo, ReplyType)>,
|
|
}
|
|
|
|
impl<
|
|
TcReceiver: EcssTcReceiver,
|
|
TmSender: EcssTmSender,
|
|
TcInMemConverter: EcssTcInMemConverter,
|
|
VerificationReporter: VerificationReportingProvider,
|
|
RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
|
|
ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
|
|
ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
|
|
ActiveRequestInfo: ActiveRequestProvider,
|
|
RequestType,
|
|
ReplyType,
|
|
>
|
|
PusTargetedRequestService<
|
|
TcReceiver,
|
|
TmSender,
|
|
TcInMemConverter,
|
|
VerificationReporter,
|
|
RequestConverter,
|
|
ReplyHandler,
|
|
ActiveRequestMap,
|
|
ActiveRequestInfo,
|
|
RequestType,
|
|
ReplyType,
|
|
>
|
|
where
|
|
GenericRequestRouter: PusRequestRouter<RequestType, Error = GenericRoutingError>,
|
|
{
|
|
pub fn new(
|
|
service_helper: PusServiceHelper<
|
|
TcReceiver,
|
|
TmSender,
|
|
TcInMemConverter,
|
|
VerificationReporter,
|
|
>,
|
|
request_converter: RequestConverter,
|
|
active_request_map: ActiveRequestMap,
|
|
reply_hook: ReplyHandler,
|
|
request_router: GenericRequestRouter,
|
|
reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
|
|
) -> Self {
|
|
Self {
|
|
service_helper,
|
|
request_converter,
|
|
active_request_map,
|
|
reply_handler: reply_hook,
|
|
request_router,
|
|
reply_receiver,
|
|
phantom: std::marker::PhantomData,
|
|
}
|
|
}
|
|
|
|
pub fn poll_and_handle_next_tc(
|
|
&mut self,
|
|
time_stamp: &[u8],
|
|
) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
|
|
let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
|
|
if possible_packet.is_none() {
|
|
return Ok(PusPacketHandlerResult::Empty);
|
|
}
|
|
let ecss_tc_and_token = possible_packet.unwrap();
|
|
self.service_helper
|
|
.tc_in_mem_converter_mut()
|
|
.cache(&ecss_tc_and_token.tc_in_memory)?;
|
|
let tc = self.service_helper.tc_in_mem_converter().convert()?;
|
|
let (mut request_info, request) = match self.request_converter.convert(
|
|
ecss_tc_and_token.token,
|
|
&tc,
|
|
self.service_helper.tm_sender(),
|
|
&self.service_helper.common.verif_reporter,
|
|
time_stamp,
|
|
) {
|
|
Ok((info, req)) => (info, req),
|
|
Err(e) => {
|
|
self.handle_conversion_to_request_error(&e, ecss_tc_and_token.token, time_stamp);
|
|
return Err(e.into());
|
|
}
|
|
};
|
|
let accepted_token: VerificationToken<TcStateAccepted> = request_info
|
|
.token()
|
|
.try_into()
|
|
.expect("token not in expected accepted state");
|
|
let verif_request_id = verification::RequestId::new(&tc).raw();
|
|
match self.request_router.route(
|
|
MessageMetadata::new(verif_request_id, self.service_helper.id()),
|
|
request_info.target_id(),
|
|
request,
|
|
) {
|
|
Ok(()) => {
|
|
let started_token = self
|
|
.service_helper
|
|
.verif_reporter()
|
|
.start_success(
|
|
&self.service_helper.common.tm_sender,
|
|
accepted_token,
|
|
time_stamp,
|
|
)
|
|
.expect("Start success failure");
|
|
request_info.set_token(started_token.into());
|
|
self.active_request_map
|
|
.insert(&verif_request_id, request_info);
|
|
}
|
|
Err(e) => {
|
|
self.request_router.handle_error_generic(
|
|
&request_info,
|
|
&tc,
|
|
e.clone(),
|
|
self.service_helper.tm_sender(),
|
|
self.service_helper.verif_reporter(),
|
|
time_stamp,
|
|
);
|
|
return Err(e.into());
|
|
}
|
|
}
|
|
Ok(PusPacketHandlerResult::RequestHandled)
|
|
}
|
|
|
|
fn handle_conversion_to_request_error(
|
|
&mut self,
|
|
error: &GenericConversionError,
|
|
token: VerificationToken<TcStateAccepted>,
|
|
time_stamp: &[u8],
|
|
) {
|
|
match error {
|
|
GenericConversionError::WrongService(service) => {
|
|
let service_slice: [u8; 1] = [*service];
|
|
self.service_helper
|
|
.verif_reporter()
|
|
.completion_failure(
|
|
self.service_helper.tm_sender(),
|
|
token,
|
|
FailParams::new(time_stamp, &tmtc_err::INVALID_PUS_SERVICE, &service_slice),
|
|
)
|
|
.expect("Sending completion failure failed");
|
|
}
|
|
GenericConversionError::InvalidSubservice(subservice) => {
|
|
let subservice_slice: [u8; 1] = [*subservice];
|
|
self.service_helper
|
|
.verif_reporter()
|
|
.completion_failure(
|
|
self.service_helper.tm_sender(),
|
|
token,
|
|
FailParams::new(
|
|
time_stamp,
|
|
&tmtc_err::INVALID_PUS_SUBSERVICE,
|
|
&subservice_slice,
|
|
),
|
|
)
|
|
.expect("Sending completion failure failed");
|
|
}
|
|
GenericConversionError::NotEnoughAppData { expected, found } => {
|
|
let mut context_info = (*found as u32).to_be_bytes().to_vec();
|
|
context_info.extend_from_slice(&(*expected as u32).to_be_bytes());
|
|
self.service_helper
|
|
.verif_reporter()
|
|
.completion_failure(
|
|
self.service_helper.tm_sender(),
|
|
token,
|
|
FailParams::new(time_stamp, &tmtc_err::NOT_ENOUGH_APP_DATA, &context_info),
|
|
)
|
|
.expect("Sending completion failure failed");
|
|
}
|
|
// Do nothing.. this is service-level and can not be handled generically here.
|
|
GenericConversionError::InvalidAppData(_) => (),
|
|
}
|
|
}
|
|
|
|
pub fn poll_and_check_next_reply(
|
|
&mut self,
|
|
time_stamp: &[u8],
|
|
) -> Result<HandlingStatus, EcssTmtcError> {
|
|
match self.reply_receiver.try_recv() {
|
|
Ok(reply) => {
|
|
self.handle_reply(&reply, time_stamp)?;
|
|
Ok(HandlingStatus::HandledOne)
|
|
}
|
|
Err(e) => match e {
|
|
mpsc::TryRecvError::Empty => Ok(HandlingStatus::Empty),
|
|
mpsc::TryRecvError::Disconnected => Err(EcssTmtcError::Receive(
|
|
GenericReceiveError::TxDisconnected(None),
|
|
)),
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn handle_reply(
|
|
&mut self,
|
|
reply: &GenericMessage<ReplyType>,
|
|
time_stamp: &[u8],
|
|
) -> Result<(), EcssTmtcError> {
|
|
let active_req_opt = self.active_request_map.get(reply.request_id());
|
|
if active_req_opt.is_none() {
|
|
self.reply_handler
|
|
.handle_unrequested_reply(reply, &self.service_helper.common.tm_sender)?;
|
|
return Ok(());
|
|
}
|
|
let active_request = active_req_opt.unwrap();
|
|
let request_finished = self
|
|
.reply_handler
|
|
.handle_reply(
|
|
reply,
|
|
active_request,
|
|
&self.service_helper.common.tm_sender,
|
|
&self.service_helper.common.verif_reporter,
|
|
time_stamp,
|
|
)
|
|
.unwrap_or(false);
|
|
if request_finished {
|
|
self.active_request_map.remove(reply.request_id());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn check_for_request_timeouts(&mut self) {
|
|
let mut requests_to_delete = Vec::new();
|
|
self.active_request_map
|
|
.for_each(|request_id, request_info| {
|
|
if request_info.has_timed_out() {
|
|
requests_to_delete.push(*request_id);
|
|
}
|
|
});
|
|
if !requests_to_delete.is_empty() {
|
|
for request_id in requests_to_delete {
|
|
self.active_request_map.remove(request_id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Generic timeout handling: Handle the verification failure with a dedicated return code
|
|
/// and also log the error.
|
|
pub fn generic_pus_request_timeout_handler(
|
|
sender: &(impl EcssTmSender + ?Sized),
|
|
active_request: &(impl ActiveRequestProvider + Debug),
|
|
verification_handler: &impl VerificationReportingProvider,
|
|
time_stamp: &[u8],
|
|
service_str: &'static str,
|
|
) -> Result<(), EcssTmtcError> {
|
|
log::warn!("timeout for active request {active_request:?} on {service_str} service");
|
|
let started_token: VerificationToken<TcStateStarted> = active_request
|
|
.token()
|
|
.try_into()
|
|
.expect("token not in expected started state");
|
|
verification_handler.completion_failure(
|
|
sender,
|
|
started_token,
|
|
FailParams::new(time_stamp, &tmtc_err::REQUEST_TIMEOUT, &[]),
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) mod tests {
|
|
use std::time::Duration;
|
|
|
|
use satrs::pus::test_util::TEST_COMPONENT_ID_0;
|
|
use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
|
|
use satrs::request::RequestId;
|
|
use satrs::{
|
|
pus::{
|
|
verification::test_util::TestVerificationReporter, ActivePusRequestStd,
|
|
ActiveRequestMapProvider, EcssTcInVecConverter, MpscTcReceiver,
|
|
},
|
|
request::UniqueApidTargetId,
|
|
spacepackets::{
|
|
ecss::{
|
|
tc::{PusTcCreator, PusTcSecondaryHeader},
|
|
WritablePusPacket,
|
|
},
|
|
SpHeader,
|
|
},
|
|
};
|
|
|
|
use crate::requests::CompositeRequest;
|
|
|
|
use super::*;
|
|
|
|
// Testbench dedicated to the testing of [PusReplyHandler]s
|
|
pub struct ReplyHandlerTestbench<
|
|
ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
|
|
ActiveRequestInfo: ActiveRequestProvider,
|
|
Reply,
|
|
> {
|
|
pub id: ComponentId,
|
|
pub verif_reporter: TestVerificationReporter,
|
|
pub reply_handler: ReplyHandler,
|
|
pub tm_receiver: mpsc::Receiver<PacketAsVec>,
|
|
pub default_timeout: Duration,
|
|
tm_sender: MpscTmAsVecSender,
|
|
phantom: std::marker::PhantomData<(ActiveRequestInfo, Reply)>,
|
|
}
|
|
|
|
impl<
|
|
ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
|
|
ActiveRequestInfo: ActiveRequestProvider,
|
|
Reply,
|
|
> ReplyHandlerTestbench<ReplyHandler, ActiveRequestInfo, Reply>
|
|
{
|
|
pub fn new(owner_id: ComponentId, reply_handler: ReplyHandler) -> Self {
|
|
let test_verif_reporter = TestVerificationReporter::new(owner_id);
|
|
let (tm_sender, tm_receiver) = mpsc::channel();
|
|
Self {
|
|
id: TEST_COMPONENT_ID_0.raw(),
|
|
verif_reporter: test_verif_reporter,
|
|
reply_handler,
|
|
default_timeout: Duration::from_secs(30),
|
|
tm_sender,
|
|
tm_receiver,
|
|
phantom: std::marker::PhantomData,
|
|
}
|
|
}
|
|
|
|
pub fn add_tc(
|
|
&mut self,
|
|
apid: u16,
|
|
apid_target: u32,
|
|
time_stamp: &[u8],
|
|
) -> (verification::RequestId, ActivePusRequestStd) {
|
|
let sp_header = SpHeader::new_from_apid(apid);
|
|
let sec_header_dummy = PusTcSecondaryHeader::new_simple(0, 0);
|
|
let init = self.verif_reporter.add_tc(&PusTcCreator::new(
|
|
sp_header,
|
|
sec_header_dummy,
|
|
&[],
|
|
true,
|
|
));
|
|
let accepted = self
|
|
.verif_reporter
|
|
.acceptance_success(&self.tm_sender, init, time_stamp)
|
|
.expect("acceptance failed");
|
|
let started = self
|
|
.verif_reporter
|
|
.start_success(&self.tm_sender, accepted, time_stamp)
|
|
.expect("start failed");
|
|
(
|
|
started.request_id(),
|
|
ActivePusRequestStd::new(
|
|
UniqueApidTargetId::new(apid, apid_target).raw(),
|
|
started,
|
|
self.default_timeout,
|
|
),
|
|
)
|
|
}
|
|
|
|
pub fn handle_reply(
|
|
&mut self,
|
|
reply: &GenericMessage<Reply>,
|
|
active_request: &ActiveRequestInfo,
|
|
time_stamp: &[u8],
|
|
) -> Result<bool, ReplyHandler::Error> {
|
|
self.reply_handler.handle_reply(
|
|
reply,
|
|
active_request,
|
|
&self.tm_sender,
|
|
&self.verif_reporter,
|
|
time_stamp,
|
|
)
|
|
}
|
|
|
|
pub fn handle_unrequested_reply(
|
|
&mut self,
|
|
reply: &GenericMessage<Reply>,
|
|
) -> Result<(), ReplyHandler::Error> {
|
|
self.reply_handler
|
|
.handle_unrequested_reply(reply, &self.tm_sender)
|
|
}
|
|
pub fn handle_request_timeout(
|
|
&mut self,
|
|
active_request_info: &ActiveRequestInfo,
|
|
time_stamp: &[u8],
|
|
) -> Result<(), ReplyHandler::Error> {
|
|
self.reply_handler.handle_request_timeout(
|
|
active_request_info,
|
|
&self.tm_sender,
|
|
&self.verif_reporter,
|
|
time_stamp,
|
|
)
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct DummySender {}
|
|
|
|
/// Dummy sender component which does nothing on the [Self::send_tm] call.
|
|
///
|
|
/// Useful for unit tests.
|
|
impl EcssTmSender for DummySender {
|
|
fn send_tm(&self, _source_id: ComponentId, _tm: PusTmVariant) -> Result<(), EcssTmtcError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// Testbench dedicated to the testing of [PusTcToRequestConverter]s
|
|
pub struct PusConverterTestbench<
|
|
Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
|
|
ActiveRequestInfo: ActiveRequestProvider,
|
|
Request,
|
|
> {
|
|
pub id: ComponentId,
|
|
pub verif_reporter: TestVerificationReporter,
|
|
pub converter: Converter,
|
|
dummy_sender: DummySender,
|
|
current_request_id: Option<verification::RequestId>,
|
|
current_packet: Option<Vec<u8>>,
|
|
phantom: std::marker::PhantomData<(ActiveRequestInfo, Request)>,
|
|
}
|
|
|
|
impl<
|
|
Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
|
|
ActiveRequestInfo: ActiveRequestProvider,
|
|
Request,
|
|
> PusConverterTestbench<Converter, ActiveRequestInfo, Request>
|
|
{
|
|
pub fn new(owner_id: ComponentId, converter: Converter) -> Self {
|
|
let test_verif_reporter = TestVerificationReporter::new(owner_id);
|
|
Self {
|
|
id: owner_id,
|
|
verif_reporter: test_verif_reporter,
|
|
converter,
|
|
dummy_sender: DummySender::default(),
|
|
current_request_id: None,
|
|
current_packet: None,
|
|
phantom: std::marker::PhantomData,
|
|
}
|
|
}
|
|
|
|
pub fn add_tc(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
|
|
let token = self.verif_reporter.add_tc(tc);
|
|
self.current_request_id = Some(verification::RequestId::new(tc));
|
|
self.current_packet = Some(tc.to_vec().unwrap());
|
|
self.verif_reporter
|
|
.acceptance_success(&self.dummy_sender, token, &[])
|
|
.expect("acceptance failed")
|
|
}
|
|
|
|
pub fn request_id(&self) -> Option<verification::RequestId> {
|
|
self.current_request_id
|
|
}
|
|
|
|
pub fn convert(
|
|
&mut self,
|
|
token: VerificationToken<TcStateAccepted>,
|
|
time_stamp: &[u8],
|
|
expected_apid: u16,
|
|
expected_apid_target: u32,
|
|
) -> Result<(ActiveRequestInfo, Request), Converter::Error> {
|
|
if self.current_packet.is_none() {
|
|
return Err(GenericConversionError::InvalidAppData(
|
|
"call add_tc first".to_string(),
|
|
));
|
|
}
|
|
let current_packet = self.current_packet.take().unwrap();
|
|
let tc_reader = PusTcReader::new(¤t_packet).unwrap();
|
|
let (active_info, request) = self.converter.convert(
|
|
token,
|
|
&tc_reader.0,
|
|
&self.dummy_sender,
|
|
&self.verif_reporter,
|
|
time_stamp,
|
|
)?;
|
|
assert_eq!(
|
|
active_info.token().request_id(),
|
|
self.request_id().expect("no request id is set")
|
|
);
|
|
assert_eq!(
|
|
active_info.target_id(),
|
|
UniqueApidTargetId::new(expected_apid, expected_apid_target).raw()
|
|
);
|
|
Ok((active_info, request))
|
|
}
|
|
}
|
|
|
|
pub struct TargetedPusRequestTestbench<
|
|
RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
|
|
ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
|
|
ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
|
|
ActiveRequestInfo: ActiveRequestProvider,
|
|
RequestType,
|
|
ReplyType,
|
|
> {
|
|
pub service: PusTargetedRequestService<
|
|
MpscTcReceiver,
|
|
MpscTmAsVecSender,
|
|
EcssTcInVecConverter,
|
|
TestVerificationReporter,
|
|
RequestConverter,
|
|
ReplyHandler,
|
|
ActiveRequestMap,
|
|
ActiveRequestInfo,
|
|
RequestType,
|
|
ReplyType,
|
|
>,
|
|
pub request_id: Option<RequestId>,
|
|
pub tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
|
|
pub pus_packet_tx: mpsc::Sender<EcssTcAndToken>,
|
|
pub reply_tx: mpsc::Sender<GenericMessage<ReplyType>>,
|
|
pub request_rx: mpsc::Receiver<GenericMessage<CompositeRequest>>,
|
|
}
|
|
}
|