From abc145fb2d9c7a830e3c0550f5c05218e1c6d7ff Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 14 Aug 2025 14:10:00 +0200 Subject: [PATCH] edition bump to 2024 ald clippy --- satrs-example/src/interface/udp.rs | 1 + satrs/CHANGELOG.md | 2 + satrs/Cargo.toml | 4 +- satrs/src/dev_mgmt.rs | 4 +- satrs/src/encoding/ccsds.rs | 10 +- satrs/src/encoding/cobs.rs | 4 +- satrs/src/encoding/mod.rs | 2 +- satrs/src/event_man.rs | 72 ++--- satrs/src/events.rs | 2 +- satrs/src/executable.rs | 118 ++++---- satrs/src/hal/std/tcp_cobs_server.rs | 72 ++--- satrs/src/hal/std/tcp_server.rs | 18 +- satrs/src/hal/std/tcp_spacepackets_server.rs | 22 +- satrs/src/hal/std/udp_server.rs | 8 +- satrs/src/mode.rs | 162 +++++----- satrs/src/mode_tree.rs | 2 +- satrs/src/params.rs | 4 +- satrs/src/pool.rs | 300 +++++++++++-------- satrs/src/power.rs | 2 +- satrs/src/pus/action.rs | 22 +- satrs/src/pus/event.rs | 12 +- satrs/src/pus/event_man.rs | 16 +- satrs/src/pus/event_srv.rs | 20 +- satrs/src/pus/mod.rs | 34 +-- satrs/src/pus/scheduler.rs | 6 +- satrs/src/pus/scheduler_srv.rs | 36 +-- satrs/src/pus/test.rs | 22 +- satrs/src/pus/verification.rs | 26 +- satrs/src/request.rs | 36 +-- satrs/src/scheduling.rs | 2 +- satrs/src/subsystem.rs | 10 +- satrs/src/tmtc/mod.rs | 6 +- satrs/src/tmtc/tm_helper.rs | 8 +- satrs/tests/mode_tree.rs | 12 +- satrs/tests/pus_verification.rs | 4 +- satrs/tests/tcp_servers.rs | 6 +- 36 files changed, 567 insertions(+), 520 deletions(-) diff --git a/satrs-example/src/interface/udp.rs b/satrs-example/src/interface/udp.rs index f9c3c78..bfbee6f 100644 --- a/satrs-example/src/interface/udp.rs +++ b/satrs-example/src/interface/udp.rs @@ -15,6 +15,7 @@ pub trait UdpTmHandler { fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr); } +#[allow(dead_code)] pub struct StaticUdpTmHandler { pub tm_rx: mpsc::Receiver, pub tm_store: SharedStaticMemoryPool, diff --git a/satrs/CHANGELOG.md b/satrs/CHANGELOG.md index a40268e..7e8d095 100644 --- a/satrs/CHANGELOG.md +++ b/satrs/CHANGELOG.md @@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/). # [unreleased] +- Bump `sat-rs` edition to 2024. + # [v0.3.0-alpha.2] 2025-07-22 `satrs-shared` update diff --git a/satrs/Cargo.toml b/satrs/Cargo.toml index b6ede5a..9165b29 100644 --- a/satrs/Cargo.toml +++ b/satrs/Cargo.toml @@ -1,8 +1,8 @@ [package] name = "satrs" version = "0.3.0-alpha.2" -edition = "2021" -rust-version = "1.82.0" +edition = "2024" +rust-version = "1.85.0" authors = ["Robin Mueller "] description = "A library collection to build software for remote systems" homepage = "https://github.com/us-irs/sat-rs" diff --git a/satrs/src/dev_mgmt.rs b/satrs/src/dev_mgmt.rs index b9eca0a..7501e23 100644 --- a/satrs/src/dev_mgmt.rs +++ b/satrs/src/dev_mgmt.rs @@ -1,9 +1,9 @@ use crate::{ + ComponentId, mode::{ModeAndSubmode, ModeReply, ModeRequest, ModeRequestSender}, mode_tree::{ModeStoreProvider, ModeStoreVec}, queue::{GenericSendError, GenericTargetedMessagingError}, request::{GenericMessage, RequestId}, - ComponentId, }; use core::fmt::Debug; @@ -270,7 +270,7 @@ impl DevManagerCommandingHelper { #[cfg(test)] mod tests { use crate::{ - mode::{tests::ModeReqSenderMock, UNKNOWN_MODE}, + mode::{UNKNOWN_MODE, tests::ModeReqSenderMock}, request::MessageMetadata, }; diff --git a/satrs/src/encoding/ccsds.rs b/satrs/src/encoding/ccsds.rs index 0f8693a..d569a3a 100644 --- a/satrs/src/encoding/ccsds.rs +++ b/satrs/src/encoding/ccsds.rs @@ -1,6 +1,6 @@ use spacepackets::{CcsdsPacket, SpHeader}; -use crate::{tmtc::PacketSenderRaw, ComponentId}; +use crate::{ComponentId, tmtc::PacketSenderRaw}; #[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum SpValidity { @@ -90,13 +90,13 @@ pub fn parse_buffer_for_ccsds_space_packets( #[cfg(test)] mod tests { use spacepackets::{ - ecss::tc::PusTcCreator, CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType, - SequenceFlags, SpHeader, + CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader, + ecss::tc::PusTcCreator, }; - use crate::{encoding::tests::TcCacher, ComponentId}; + use crate::{ComponentId, encoding::tests::TcCacher}; - use super::{parse_buffer_for_ccsds_space_packets, SpValidity, SpacePacketValidator}; + use super::{SpValidity, SpacePacketValidator, parse_buffer_for_ccsds_space_packets}; const PARSER_ID: ComponentId = 0x05; const TEST_APID_0: u16 = 0x02; diff --git a/satrs/src/encoding/cobs.rs b/satrs/src/encoding/cobs.rs index 749d1bc..c4f2d9e 100644 --- a/satrs/src/encoding/cobs.rs +++ b/satrs/src/encoding/cobs.rs @@ -1,4 +1,4 @@ -use crate::{tmtc::PacketSenderRaw, ComponentId}; +use crate::{ComponentId, tmtc::PacketSenderRaw}; use cobs::{decode_in_place, encode, max_encoding_length}; /// This function encodes the given packet with COBS and also wraps the encoded packet with @@ -104,8 +104,8 @@ pub(crate) mod tests { use cobs::encode; use crate::{ - encoding::tests::{encode_simple_packet, TcCacher, INVERTED_PACKET, SIMPLE_PACKET}, ComponentId, + encoding::tests::{INVERTED_PACKET, SIMPLE_PACKET, TcCacher, encode_simple_packet}, }; use super::parse_buffer_for_cobs_encoded_packets; diff --git a/satrs/src/encoding/mod.rs b/satrs/src/encoding/mod.rs index 99ce51d..e97fe95 100644 --- a/satrs/src/encoding/mod.rs +++ b/satrs/src/encoding/mod.rs @@ -11,8 +11,8 @@ pub(crate) mod tests { use alloc::collections::VecDeque; use crate::{ - tmtc::{PacketAsVec, PacketSenderRaw}, ComponentId, + tmtc::{PacketAsVec, PacketSenderRaw}, }; use super::cobs::encode_packet_with_cobs; diff --git a/satrs/src/event_man.rs b/satrs/src/event_man.rs index 74d889f..e7a7c9b 100644 --- a/satrs/src/event_man.rs +++ b/satrs/src/event_man.rs @@ -136,7 +136,7 @@ pub trait ListenerMapProvider { #[cfg(feature = "alloc")] fn get_listeners(&self) -> alloc::vec::Vec; fn contains_listener(&self, key: &ListenerKey) -> bool; - fn get_listener_ids(&self, key: &ListenerKey) -> Option>; + fn get_listener_ids(&self, key: &ListenerKey) -> Option>; fn add_listener(&mut self, key: ListenerKey, listener_id: ComponentId) -> bool; fn remove_duplicates(&mut self, key: &ListenerKey); } @@ -198,13 +198,13 @@ pub enum EventRoutingError { } impl< - EventReceiver: EventReceiveProvider, - SenderMap: SenderMapProvider, - ListenerMap: ListenerMapProvider, - EventSender: EventSendProvider, - Event: GenericEvent + Copy, - ParamProvider: Debug, - > EventManager + EventReceiver: EventReceiveProvider, + SenderMap: SenderMapProvider, + ListenerMap: ListenerMapProvider, + EventSender: EventSendProvider, + Event: GenericEvent + Copy, + ParamProvider: Debug, +> EventManager { pub fn remove_duplicates(&mut self, key: &ListenerKey) { self.listener_map.remove_duplicates(key) @@ -229,13 +229,13 @@ impl< } } impl< - EventReceiver: EventReceiveProvider, - SenderMap: SenderMapProvider, - ListenerMap: ListenerMapProvider, - EventSenderMap: EventSendProvider, - Event: GenericEvent + Copy, - ParamProvider: Debug, - > EventManager + EventReceiver: EventReceiveProvider, + SenderMap: SenderMapProvider, + ListenerMap: ListenerMapProvider, + EventSenderMap: EventSendProvider, + Event: GenericEvent + Copy, + ParamProvider: Debug, +> EventManager { pub fn new_with_custom_maps( event_receiver: EventReceiver, @@ -267,13 +267,13 @@ impl< } impl< - EventReceiver: EventReceiveProvider, - SenderMap: SenderMapProvider, - ListenerMap: ListenerMapProvider, - EventSenderMap: EventSendProvider, - Event: GenericEvent + Copy, - ParamProvider: Clone + Debug, - > EventManager + EventReceiver: EventReceiveProvider, + SenderMap: SenderMapProvider, + ListenerMap: ListenerMapProvider, + EventSenderMap: EventSendProvider, + Event: GenericEvent + Copy, + ParamProvider: Clone + Debug, +> EventManager { /// This function will use the cached event receiver and try to receive one event. /// If an event was received, it will try to route that event to all subscribed event listeners. @@ -355,11 +355,11 @@ pub mod alloc_mod { >; impl< - EventReceiver: EventReceiveProvider, - EventSender: EventSendProvider, - Event: GenericEvent + Copy, - ParamProvider: 'static + Debug, - > + EventReceiver: EventReceiveProvider, + EventSender: EventSendProvider, + Event: GenericEvent + Copy, + ParamProvider: 'static + Debug, + > EventManager< EventReceiver, DefaultSenderMap, @@ -402,7 +402,7 @@ pub mod alloc_mod { self.listeners.contains_key(key) } - fn get_listener_ids(&self, key: &ListenerKey) -> Option> { + fn get_listener_ids(&self, key: &ListenerKey) -> Option> { self.listeners.get(key).map(|vec| vec.iter()) } @@ -437,10 +437,10 @@ pub mod alloc_mod { } impl< - EventSender: EventSendProvider, - Event: GenericEvent, - ParamProvider: Debug, - > Default for DefaultSenderMap + EventSender: EventSendProvider, + Event: GenericEvent, + ParamProvider: Debug, + > Default for DefaultSenderMap { fn default() -> Self { Self { @@ -451,10 +451,10 @@ pub mod alloc_mod { } impl< - EventSender: EventSendProvider, - Event: GenericEvent, - ParamProvider: Debug, - > SenderMapProvider + EventSender: EventSendProvider, + Event: GenericEvent, + ParamProvider: Debug, + > SenderMapProvider for DefaultSenderMap { fn contains_send_event_provider(&self, id: &ComponentId) -> bool { diff --git a/satrs/src/events.rs b/satrs/src/events.rs index 4bc493c..1194087 100644 --- a/satrs/src/events.rs +++ b/satrs/src/events.rs @@ -31,9 +31,9 @@ use core::fmt::Debug; use core::hash::Hash; use core::marker::PhantomData; use delegate::delegate; +use spacepackets::ByteConversionError; use spacepackets::ecss::EcssEnumeration; use spacepackets::util::{ToBeBytes, UnsignedEnum}; -use spacepackets::ByteConversionError; /// Using a type definition allows to change this to u64 in the future more easily pub type LargestEventRaw = u32; diff --git a/satrs/src/executable.rs b/satrs/src/executable.rs index e753b00..0aa3215 100644 --- a/satrs/src/executable.rs +++ b/satrs/src/executable.rs @@ -55,33 +55,35 @@ pub fn exec_sched_single< let mut cycle_count = 0; thread::Builder::new() .name(String::from(executable.task_name())) - .spawn(move || loop { - if let Some(ref mut terminator) = termination { - match terminator.try_recv() { - Ok(_) | Err(TryRecvError::Disconnected) => { - return Ok(OpResult::Ok); - } - Err(TryRecvError::Empty) => (), - } - } - match executable.exec_type() { - ExecutionType::OneShot => { - executable.periodic_op(op_code)?; - return Ok(OpResult::Ok); - } - ExecutionType::Infinite => { - executable.periodic_op(op_code)?; - } - ExecutionType::Cycles(cycles) => { - executable.periodic_op(op_code)?; - cycle_count += 1; - if cycle_count == cycles { - return Ok(OpResult::Ok); + .spawn(move || { + loop { + if let Some(ref mut terminator) = termination { + match terminator.try_recv() { + Ok(_) | Err(TryRecvError::Disconnected) => { + return Ok(OpResult::Ok); + } + Err(TryRecvError::Empty) => (), } } - } - if let Some(freq) = task_freq { - thread::sleep(freq); + match executable.exec_type() { + ExecutionType::OneShot => { + executable.periodic_op(op_code)?; + return Ok(OpResult::Ok); + } + ExecutionType::Infinite => { + executable.periodic_op(op_code)?; + } + ExecutionType::Cycles(cycles) => { + executable.periodic_op(op_code)?; + cycle_count += 1; + if cycle_count == cycles { + return Ok(OpResult::Ok); + } + } + } + if let Some(freq) = task_freq { + thread::sleep(freq); + } } }) } @@ -110,51 +112,53 @@ pub fn exec_sched_multi< thread::Builder::new() .name(String::from(task_name)) - .spawn(move || loop { - if let Some(ref mut terminator) = termination { - match terminator.try_recv() { - Ok(_) | Err(TryRecvError::Disconnected) => { - removal_flags.iter_mut().for_each(|x| *x = true); + .spawn(move || { + loop { + if let Some(ref mut terminator) = termination { + match terminator.try_recv() { + Ok(_) | Err(TryRecvError::Disconnected) => { + removal_flags.iter_mut().for_each(|x| *x = true); + } + Err(TryRecvError::Empty) => (), } - Err(TryRecvError::Empty) => (), } - } - for (idx, executable) in executable_vec.iter_mut().enumerate() { - match executable.exec_type() { - ExecutionType::OneShot => { - executable.periodic_op(op_code)?; - removal_flags[idx] = true; - } - ExecutionType::Infinite => { - executable.periodic_op(op_code)?; - } - ExecutionType::Cycles(cycles) => { - executable.periodic_op(op_code)?; - cycle_counts[idx] += 1; - if cycle_counts[idx] == cycles { + for (idx, executable) in executable_vec.iter_mut().enumerate() { + match executable.exec_type() { + ExecutionType::OneShot => { + executable.periodic_op(op_code)?; removal_flags[idx] = true; } + ExecutionType::Infinite => { + executable.periodic_op(op_code)?; + } + ExecutionType::Cycles(cycles) => { + executable.periodic_op(op_code)?; + cycle_counts[idx] += 1; + if cycle_counts[idx] == cycles { + removal_flags[idx] = true; + } + } } } + let mut removal_iter = removal_flags.iter(); + executable_vec.retain(|_| !*removal_iter.next().unwrap()); + removal_iter = removal_flags.iter(); + cycle_counts.retain(|_| !*removal_iter.next().unwrap()); + removal_flags.retain(|&i| !i); + if executable_vec.is_empty() { + return Ok(OpResult::Ok); + } + let freq = task_freq.unwrap_or_else(|| panic!("No task frequency specified")); + thread::sleep(freq); } - let mut removal_iter = removal_flags.iter(); - executable_vec.retain(|_| !*removal_iter.next().unwrap()); - removal_iter = removal_flags.iter(); - cycle_counts.retain(|_| !*removal_iter.next().unwrap()); - removal_flags.retain(|&i| !i); - if executable_vec.is_empty() { - return Ok(OpResult::Ok); - } - let freq = task_freq.unwrap_or_else(|| panic!("No task frequency specified")); - thread::sleep(freq); }) } #[cfg(test)] mod tests { use super::{ - exec_sched_multi, exec_sched_single, Executable, ExecutableWithType, ExecutionType, - OpResult, + Executable, ExecutableWithType, ExecutionType, OpResult, exec_sched_multi, + exec_sched_single, }; use bus::Bus; use std::boxed::Box; diff --git a/satrs/src/hal/std/tcp_cobs_server.rs b/satrs/src/hal/std/tcp_cobs_server.rs index c4758b6..67e7d0e 100644 --- a/satrs/src/hal/std/tcp_cobs_server.rs +++ b/satrs/src/hal/std/tcp_cobs_server.rs @@ -13,10 +13,10 @@ use crate::encoding::parse_buffer_for_cobs_encoded_packets; use crate::tmtc::PacketSenderRaw; use crate::tmtc::PacketSource; +use crate::ComponentId; use crate::hal::std::tcp_server::{ ConnectionResult, ServerConfig, TcpTcParser, TcpTmSender, TcpTmtcError, TcpTmtcGenericServer, }; -use crate::ComponentId; use super::tcp_server::HandledConnectionHandler; use super::tcp_server::HandledConnectionInfo; @@ -136,12 +136,12 @@ pub struct TcpTmtcInCobsServer< } impl< - TmSource: PacketSource, - TcReceiver: PacketSenderRaw, - HandledConnection: HandledConnectionHandler, - TmError: 'static, - TcError: 'static, - > TcpTmtcInCobsServer + TmSource: PacketSource, + TcReceiver: PacketSenderRaw, + HandledConnection: HandledConnectionHandler, + TmError: 'static, + TcError: 'static, +> TcpTmtcInCobsServer { /// Create a new TCP TMTC server which exchanges TMTC packets encoded with /// [COBS protocol](https://en.wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing). @@ -206,14 +206,14 @@ mod tests { }; use crate::{ + ComponentId, encoding::tests::{INVERTED_PACKET, SIMPLE_PACKET}, hal::std::tcp_server::{ - tests::{ConnectionFinishedHandler, SyncTmSource}, ConnectionResult, ServerConfig, + tests::{ConnectionFinishedHandler, SyncTmSource}, }, queue::GenericSendError, tmtc::PacketAsVec, - ComponentId, }; use alloc::sync::Arc; use cobs::encode; @@ -435,17 +435,19 @@ mod tests { generic_tmtc_server(&auto_port_addr, tc_sender.clone(), tm_source, None); let start = Instant::now(); // Call the connection handler in separate thread, does block. - let thread_jh = thread::spawn(move || loop { - let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20))); - if result.is_err() { - panic!("handling connection failed: {:?}", result.unwrap_err()); - } - let result = result.unwrap(); - if result == ConnectionResult::AcceptTimeout { - break; - } - if Instant::now() - start > Duration::from_millis(100) { - panic!("regular stop signal handling failed"); + let thread_jh = thread::spawn(move || { + loop { + let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20))); + if result.is_err() { + panic!("handling connection failed: {:?}", result.unwrap_err()); + } + let result = result.unwrap(); + if result == ConnectionResult::AcceptTimeout { + break; + } + if Instant::now() - start > Duration::from_millis(100) { + panic!("regular stop signal handling failed"); + } } }); thread_jh.join().expect("thread join failed"); @@ -469,20 +471,22 @@ mod tests { let stop_signal_copy = stop_signal.clone(); let start = Instant::now(); // Call the connection handler in separate thread, does block. - let thread_jh = thread::spawn(move || loop { - let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20))); - if result.is_err() { - panic!("handling connection failed: {:?}", result.unwrap_err()); - } - let result = result.unwrap(); - if result == ConnectionResult::AcceptTimeout { - panic!("unexpected accept timeout"); - } - if stop_signal_copy.load(Ordering::Relaxed) { - break; - } - if Instant::now() - start > Duration::from_millis(100) { - panic!("regular stop signal handling failed"); + let thread_jh = thread::spawn(move || { + loop { + let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20))); + if result.is_err() { + panic!("handling connection failed: {:?}", result.unwrap_err()); + } + let result = result.unwrap(); + if result == ConnectionResult::AcceptTimeout { + panic!("unexpected accept timeout"); + } + if stop_signal_copy.load(Ordering::Relaxed) { + break; + } + if Instant::now() - start > Duration::from_millis(100) { + panic!("regular stop signal handling failed"); + } } }); // We connect but do not do anything. diff --git a/satrs/src/hal/std/tcp_server.rs b/satrs/src/hal/std/tcp_server.rs index d111409..ba5300c 100644 --- a/satrs/src/hal/std/tcp_server.rs +++ b/satrs/src/hal/std/tcp_server.rs @@ -11,8 +11,8 @@ use std::io::{self, Read}; use std::net::SocketAddr; use std::thread; -use crate::tmtc::{PacketSenderRaw, PacketSource}; use crate::ComponentId; +use crate::tmtc::{PacketSenderRaw, PacketSource}; use thiserror::Error; // Re-export the TMTC in COBS server. @@ -187,14 +187,14 @@ pub struct TcpTmtcGenericServer< } impl< - TmSource: PacketSource, - TcSender: PacketSenderRaw, - TmSender: TcpTmSender, - TcParser: TcpTcParser, - HandledConnection: HandledConnectionHandler, - TmError: 'static, - TcSendError: 'static, - > + TmSource: PacketSource, + TcSender: PacketSenderRaw, + TmSender: TcpTmSender, + TcParser: TcpTcParser, + HandledConnection: HandledConnectionHandler, + TmError: 'static, + TcSendError: 'static, +> TcpTmtcGenericServer< TmSource, TcSender, diff --git a/satrs/src/hal/std/tcp_spacepackets_server.rs b/satrs/src/hal/std/tcp_spacepackets_server.rs index bbcf802..f049e3e 100644 --- a/satrs/src/hal/std/tcp_spacepackets_server.rs +++ b/satrs/src/hal/std/tcp_spacepackets_server.rs @@ -5,9 +5,9 @@ use mio::net::{TcpListener, TcpStream}; use std::{io::Write, net::SocketAddr}; use crate::{ + ComponentId, encoding::{ccsds::SpacePacketValidator, parse_buffer_for_ccsds_space_packets}, tmtc::{PacketSenderRaw, PacketSource}, - ComponentId, }; use super::tcp_server::{ @@ -107,13 +107,13 @@ pub struct TcpSpacepacketsServer< } impl< - TmSource: PacketSource, - TcSender: PacketSenderRaw, - Validator: SpacePacketValidator, - HandledConnection: HandledConnectionHandler, - TmError: 'static, - TcError: 'static, - > TcpSpacepacketsServer + TmSource: PacketSource, + TcSender: PacketSenderRaw, + Validator: SpacePacketValidator, + HandledConnection: HandledConnectionHandler, + TmError: 'static, + TcError: 'static, +> TcpSpacepacketsServer { /// /// ## Parameter @@ -185,19 +185,19 @@ mod tests { use alloc::sync::Arc; use hashbrown::HashSet; use spacepackets::{ - ecss::{tc::PusTcCreator, WritablePusPacket}, CcsdsPacket, PacketId, SpHeader, + ecss::{WritablePusPacket, tc::PusTcCreator}, }; use crate::{ + ComponentId, encoding::ccsds::{SpValidity, SpacePacketValidator}, hal::std::tcp_server::{ - tests::{ConnectionFinishedHandler, SyncTmSource}, ConnectionResult, ServerConfig, + tests::{ConnectionFinishedHandler, SyncTmSource}, }, queue::GenericSendError, tmtc::PacketAsVec, - ComponentId, }; use super::TcpSpacepacketsServer; diff --git a/satrs/src/hal/std/udp_server.rs b/satrs/src/hal/std/udp_server.rs index 5db42fa..cbb54c0 100644 --- a/satrs/src/hal/std/udp_server.rs +++ b/satrs/src/hal/std/udp_server.rs @@ -1,6 +1,6 @@ //! Generic UDP TC server. -use crate::tmtc::PacketSenderRaw; use crate::ComponentId; +use crate::tmtc::PacketSenderRaw; use core::fmt::Debug; use std::io::{self, ErrorKind}; use std::net::{SocketAddr, ToSocketAddrs, UdpSocket}; @@ -105,7 +105,7 @@ impl, SendError: Debug + 'static> Err(ReceiveResult::NothingReceived) } else { Err(e.into()) - } + }; } }; let (num_bytes, from) = res; @@ -123,13 +123,13 @@ impl, SendError: Debug + 'static> #[cfg(test)] mod tests { + use crate::ComponentId; use crate::hal::std::udp_server::{ReceiveResult, UdpTcServer}; use crate::queue::GenericSendError; use crate::tmtc::PacketSenderRaw; - use crate::ComponentId; use core::cell::RefCell; - use spacepackets::ecss::tc::PusTcCreator; use spacepackets::SpHeader; + use spacepackets::ecss::tc::PusTcCreator; use std::collections::VecDeque; use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket}; use std::vec::Vec; diff --git a/satrs/src/mode.rs b/satrs/src/mode.rs index b9bfa84..c5679ff 100644 --- a/satrs/src/mode.rs +++ b/satrs/src/mode.rs @@ -11,11 +11,11 @@ pub use alloc_mod::*; pub use std_mod::*; use crate::{ + ComponentId, queue::{GenericReceiveError, GenericSendError}, request::{ GenericMessage, MessageMetadata, MessageReceiverProvider, MessageReceiverWithId, RequestId, }, - ComponentId, }; pub type Mode = u32; @@ -257,7 +257,7 @@ pub trait ModeRequestHandler: ModeProvider { pub trait ModeReplyReceiver { fn try_recv_mode_reply(&self) - -> Result>, GenericReceiveError>; + -> Result>, GenericReceiveError>; } impl> ModeReplyReceiver @@ -309,12 +309,11 @@ pub mod alloc_mod { } impl< - From, - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - SenderStore: MessageSenderStoreProvider, - > ModeReplySender - for MessageSenderAndReceiver + From, + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + SenderStore: MessageSenderStoreProvider, + > ModeReplySender for MessageSenderAndReceiver { fn local_channel_id(&self) -> ComponentId { self.local_channel_id_generic() @@ -334,12 +333,11 @@ pub mod alloc_mod { } impl< - To, - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - SenderStore: MessageSenderStoreProvider, - > ModeReplyReceiver - for MessageSenderAndReceiver + To, + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + SenderStore: MessageSenderStoreProvider, + > ModeReplyReceiver for MessageSenderAndReceiver { fn try_recv_mode_reply( &self, @@ -349,15 +347,15 @@ pub mod alloc_mod { } impl< - Request, - ReqSender: MessageSenderProvider, - ReqReceiver: MessageReceiverProvider, - ReqSenderStore: MessageSenderStoreProvider, - Reply, - ReplySender: MessageSenderProvider, - ReplyReceiver: MessageReceiverProvider, - ReplySenderStore: MessageSenderStoreProvider, - > + Request, + ReqSender: MessageSenderProvider, + ReqReceiver: MessageReceiverProvider, + ReqSenderStore: MessageSenderStoreProvider, + Reply, + ReplySender: MessageSenderProvider, + ReplyReceiver: MessageReceiverProvider, + ReplySenderStore: MessageSenderStoreProvider, + > RequestAndReplySenderAndReceiver< Request, ReqSender, @@ -376,14 +374,14 @@ pub mod alloc_mod { } impl< - Request, - ReqSender: MessageSenderProvider, - ReqReceiver: MessageReceiverProvider, - ReqSenderStore: MessageSenderStoreProvider, - ReplySender: MessageSenderProvider, - ReplyReceiver: MessageReceiverProvider, - ReplySenderStore: MessageSenderStoreProvider, - > ModeReplySender + Request, + ReqSender: MessageSenderProvider, + ReqReceiver: MessageReceiverProvider, + ReqSenderStore: MessageSenderStoreProvider, + ReplySender: MessageSenderProvider, + ReplyReceiver: MessageReceiverProvider, + ReplySenderStore: MessageSenderStoreProvider, + > ModeReplySender for RequestAndReplySenderAndReceiver< Request, ReqSender, @@ -413,14 +411,14 @@ pub mod alloc_mod { } impl< - Request, - ReqSender: MessageSenderProvider, - ReqReceiver: MessageReceiverProvider, - ReqSenderStore: MessageSenderStoreProvider, - ReplySender: MessageSenderProvider, - ReplyReceiver: MessageReceiverProvider, - ReplySenderStore: MessageSenderStoreProvider, - > ModeReplyReceiver + Request, + ReqSender: MessageSenderProvider, + ReqReceiver: MessageReceiverProvider, + ReqSenderStore: MessageSenderStoreProvider, + ReplySender: MessageSenderProvider, + ReplyReceiver: MessageReceiverProvider, + ReplySenderStore: MessageSenderStoreProvider, + > ModeReplyReceiver for RequestAndReplySenderAndReceiver< Request, ReqSender, @@ -444,10 +442,10 @@ pub mod alloc_mod { MessageSenderAndReceiver; impl< - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - ReplySenderStore: MessageSenderStoreProvider, - > ModeRequestHandlerInterface + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + ReplySenderStore: MessageSenderStoreProvider, + > ModeRequestHandlerInterface { pub fn try_recv_mode_request( &self, @@ -474,10 +472,10 @@ pub mod alloc_mod { MessageSenderAndReceiver; impl< - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - RequestSenderStore: MessageSenderStoreProvider, - > ModeRequestorInterface + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + RequestSenderStore: MessageSenderStoreProvider, + > ModeRequestorInterface { pub fn try_recv_mode_reply( &self, @@ -531,11 +529,11 @@ pub mod alloc_mod { } impl< - To, - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - SenderStore: MessageSenderStoreProvider, - > ModeRequestReceiver + To, + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + SenderStore: MessageSenderStoreProvider, + > ModeRequestReceiver for MessageSenderAndReceiver { fn try_recv_mode_request( @@ -546,11 +544,11 @@ pub mod alloc_mod { } impl< - From, - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - SenderStore: MessageSenderStoreProvider, - > ModeRequestSender + From, + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + SenderStore: MessageSenderStoreProvider, + > ModeRequestSender for MessageSenderAndReceiver { fn local_channel_id(&self) -> ComponentId { @@ -572,14 +570,14 @@ pub mod alloc_mod { } impl< - ReqSender: MessageSenderProvider, - ReqReceiver: MessageReceiverProvider, - ReqSenderStore: MessageSenderStoreProvider, - Reply, - ReplySender: MessageSenderProvider, - ReplyReceiver: MessageReceiverProvider, - ReplySenderStore: MessageSenderStoreProvider, - > + ReqSender: MessageSenderProvider, + ReqReceiver: MessageReceiverProvider, + ReqSenderStore: MessageSenderStoreProvider, + Reply, + ReplySender: MessageSenderProvider, + ReplyReceiver: MessageReceiverProvider, + ReplySenderStore: MessageSenderStoreProvider, + > RequestAndReplySenderAndReceiver< ModeRequest, ReqSender, @@ -598,14 +596,14 @@ pub mod alloc_mod { } impl< - ReqSender: MessageSenderProvider, - ReqReceiver: MessageReceiverProvider, - ReqSenderStore: MessageSenderStoreProvider, - Reply, - ReplySender: MessageSenderProvider, - ReplyReceiver: MessageReceiverProvider, - ReplySenderStore: MessageSenderStoreProvider, - > ModeRequestSender + ReqSender: MessageSenderProvider, + ReqReceiver: MessageReceiverProvider, + ReqSenderStore: MessageSenderStoreProvider, + Reply, + ReplySender: MessageSenderProvider, + ReplyReceiver: MessageReceiverProvider, + ReplySenderStore: MessageSenderStoreProvider, + > ModeRequestSender for RequestAndReplySenderAndReceiver< ModeRequest, ReqSender, @@ -636,14 +634,14 @@ pub mod alloc_mod { } impl< - ReqSender: MessageSenderProvider, - ReqReceiver: MessageReceiverProvider, - ReqSenderStore: MessageSenderStoreProvider, - Reply, - ReplySender: MessageSenderProvider, - ReplyReceiver: MessageReceiverProvider, - ReplySenderStore: MessageSenderStoreProvider, - > ModeRequestReceiver + ReqSender: MessageSenderProvider, + ReqReceiver: MessageReceiverProvider, + ReqSenderStore: MessageSenderStoreProvider, + Reply, + ReplySender: MessageSenderProvider, + ReplyReceiver: MessageReceiverProvider, + ReplySenderStore: MessageSenderStoreProvider, + > ModeRequestReceiver for RequestAndReplySenderAndReceiver< ModeRequest, ReqSender, @@ -726,7 +724,7 @@ pub(crate) mod tests { use core::cell::RefCell; use std::collections::VecDeque; - use crate::{request::RequestId, ComponentId}; + use crate::{ComponentId, request::RequestId}; use super::*; diff --git a/satrs/src/mode_tree.rs b/satrs/src/mode_tree.rs index e058378..883ef21 100644 --- a/satrs/src/mode_tree.rs +++ b/satrs/src/mode_tree.rs @@ -2,9 +2,9 @@ use alloc::vec::Vec; use hashbrown::HashMap; use crate::{ + ComponentId, mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode}, request::MessageSenderProvider, - ComponentId, }; #[cfg(feature = "alloc")] diff --git a/satrs/src/params.rs b/satrs/src/params.rs index 63135c5..c9d4280 100644 --- a/satrs/src/params.rs +++ b/satrs/src/params.rs @@ -47,10 +47,10 @@ use crate::pool::PoolAddr; use core::fmt::Debug; use core::mem::size_of; use paste::paste; -use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8}; +use spacepackets::ByteConversionError; +use spacepackets::ecss::{EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumU64}; pub use spacepackets::util::ToBeBytes; use spacepackets::util::UnsignedEnum; -use spacepackets::ByteConversionError; #[cfg(feature = "alloc")] use alloc::string::{String, ToString}; diff --git a/satrs/src/pool.rs b/satrs/src/pool.rs index bc944a9..576b445 100644 --- a/satrs/src/pool.rs +++ b/satrs/src/pool.rs @@ -250,7 +250,7 @@ pub trait PoolProvider { /// call the user-provided closure and pass a mutable reference to the memory block /// to the closure. This allows the user to modify the memory block. fn modify(&mut self, addr: &PoolAddr, updater: U) - -> Result<(), PoolError>; + -> Result<(), PoolError>; /// The provider should copy the data from the memory block to the user-provided buffer if /// it exists. @@ -281,7 +281,7 @@ pub trait PoolProviderWithGuards: PoolProvider { /// This can prevent memory leaks. Users can read the data and release the guard /// if the data in the store is valid for further processing. If the data is faulty, no /// manual deletion is necessary when returning from a processing function prematurely. - fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard; + fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<'_, Self>; /// This function behaves like [PoolProvider::modify], but consumes the provided /// address and returns a RAII conformant guard object. @@ -291,7 +291,7 @@ pub trait PoolProviderWithGuards: PoolProvider { /// This can prevent memory leaks. Users can read (and modify) the data and release the guard /// if the data in the store is valid for further processing. If the data is faulty, no /// manual deletion is necessary when returning from a processing function prematurely. - fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard; + fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<'_, Self>; } pub struct PoolGuard<'a, MemProvider: PoolProvider + ?Sized> { @@ -510,11 +510,11 @@ pub mod heapless_mod { /// /// * `subpool_memory` - Static memory for a particular subpool to store the actual data. /// * `sizes_list` - Static sizes list structure to store the size of the data which is - /// actually stored. + /// actually stored. /// * `num_blocks ` - The number of memory blocks inside the subpool. /// * `set_sizes_list_to_all_free` - If this is set to true, the method will take care - /// of setting all values in the sizes list to [super::STORE_FREE]. This does not have - /// to be done if the user initializes the sizes list to that value themselves. + /// of setting all values in the sizes list to [super::STORE_FREE]. This does not have + /// to be done if the user initializes the sizes list to that value themselves. pub fn grow( &mut self, subpool_memory: &'static mut [u8], @@ -602,7 +602,7 @@ pub mod heapless_mod { if i < start_at_subpool as usize { continue; } - if pool_cfg.block_size as usize >= req_size { + if pool_cfg.block_size >= req_size { return Ok(i as u16); } } @@ -638,7 +638,7 @@ pub mod heapless_mod { fn raw_pos(&self, addr: &StaticPoolAddr) -> Option { let (pool_cfg, _) = self.pool.get(addr.pool_idx as usize)?; - Some(addr.packet_idx as usize * pool_cfg.block_size as usize) + Some(addr.packet_idx as usize * pool_cfg.block_size) } } @@ -707,7 +707,7 @@ pub mod heapless_mod { let subpool_cfg = self.pool.get(addr.pool_idx as usize).unwrap().0; let raw_pos = self.raw_pos(&addr).unwrap(); let block = &mut self.pool.get_mut(addr.pool_idx as usize).unwrap().1 - [raw_pos..raw_pos + subpool_cfg.block_size as usize]; + [raw_pos..raw_pos + subpool_cfg.block_size]; let size_list = self.sizes_lists.get_mut(addr.pool_idx as usize).unwrap(); size_list[addr.packet_idx as usize] = STORE_FREE; block.fill(0); @@ -742,11 +742,11 @@ pub mod heapless_mod { impl PoolProviderWithGuards for StaticHeaplessMemoryPool { - fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard { + fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<'_, Self> { PoolRwGuard::new(self, addr) } - fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard { + fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<'_, Self> { PoolGuard::new(self, addr) } } @@ -1058,11 +1058,11 @@ mod alloc_mod { } impl PoolProviderWithGuards for StaticMemoryPool { - fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard { + fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<'_, Self> { PoolRwGuard::new(self, addr) } - fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard { + fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<'_, Self> { PoolGuard::new(self, addr) } } @@ -1307,9 +1307,11 @@ mod tests { let addr = pool_provider.add(&test_buf).expect("Adding data failed"); let read_guard = PoolGuard::new(pool_provider, addr); drop(read_guard); - assert!(!pool_provider - .has_element_at(&addr) - .expect("Invalid address")); + assert!( + !pool_provider + .has_element_at(&addr) + .expect("Invalid address") + ); } fn generic_test_pool_guard_deletion(pool_provider: &mut impl PoolProviderWithGuards) { @@ -1317,9 +1319,11 @@ mod tests { let addr = pool_provider.add(&test_buf).expect("Adding data failed"); let read_guard = pool_provider.read_with_guard(addr); drop(read_guard); - assert!(!pool_provider - .has_element_at(&addr) - .expect("Invalid address")); + assert!( + !pool_provider + .has_element_at(&addr) + .expect("Invalid address") + ); } fn generic_test_pool_guard_with_release(pool_provider: &mut impl PoolProviderWithGuards) { @@ -1328,9 +1332,11 @@ mod tests { let mut read_guard = PoolGuard::new(pool_provider, addr); read_guard.release(); drop(read_guard); - assert!(pool_provider - .has_element_at(&addr) - .expect("Invalid address")); + assert!( + pool_provider + .has_element_at(&addr) + .expect("Invalid address") + ); } fn generic_test_pool_modify_guard_man_creation( @@ -1341,9 +1347,11 @@ mod tests { let mut rw_guard = PoolRwGuard::new(pool_provider, addr); rw_guard.update(&mut |_| {}).expect("modify failed"); drop(rw_guard); - assert!(!pool_provider - .has_element_at(&addr) - .expect("Invalid address")); + assert!( + !pool_provider + .has_element_at(&addr) + .expect("Invalid address") + ); } fn generic_test_pool_modify_guard(pool_provider: &mut impl PoolProviderWithGuards) { @@ -1352,9 +1360,11 @@ mod tests { let mut rw_guard = pool_provider.modify_with_guard(addr); rw_guard.update(&mut |_| {}).expect("modify failed"); drop(rw_guard); - assert!(!pool_provider - .has_element_at(&addr) - .expect("Invalid address")); + assert!( + !pool_provider + .has_element_at(&addr) + .expect("Invalid address") + ); } fn generic_modify_pool_index_above_0(pool_provider: &mut impl PoolProvider) { @@ -1654,30 +1664,36 @@ mod tests { fn small_heapless_pool() -> StaticHeaplessMemoryPool<3> { let mut heapless_pool: StaticHeaplessMemoryPool<3> = StaticHeaplessMemoryPool::new(false); - assert!(heapless_pool - .grow( - SUBPOOL_1.take(), - unsafe { &mut *SUBPOOL_1_SIZES.lock().unwrap().get() }, - SUBPOOL_1_NUM_ELEMENTS, - true - ) - .is_ok()); - assert!(heapless_pool - .grow( - SUBPOOL_2.take(), - SUBPOOL_2_SIZES.take(), - SUBPOOL_2_NUM_ELEMENTS, - true - ) - .is_ok()); - assert!(heapless_pool - .grow( - SUBPOOL_3.take(), - SUBPOOL_3_SIZES.take(), - SUBPOOL_3_NUM_ELEMENTS, - true - ) - .is_ok()); + assert!( + heapless_pool + .grow( + SUBPOOL_1.take(), + unsafe { &mut *SUBPOOL_1_SIZES.lock().unwrap().get() }, + SUBPOOL_1_NUM_ELEMENTS, + true + ) + .is_ok() + ); + assert!( + heapless_pool + .grow( + SUBPOOL_2.take(), + SUBPOOL_2_SIZES.take(), + SUBPOOL_2_NUM_ELEMENTS, + true + ) + .is_ok() + ); + assert!( + heapless_pool + .grow( + SUBPOOL_3.take(), + SUBPOOL_3_SIZES.take(), + SUBPOOL_3_NUM_ELEMENTS, + true + ) + .is_ok() + ); heapless_pool } @@ -1793,22 +1809,26 @@ mod tests { fn test_spills_to_higher_subpools() { let mut heapless_pool: StaticHeaplessMemoryPool<2> = StaticHeaplessMemoryPool::new(true); - assert!(heapless_pool - .grow( - SUBPOOL_2.take(), - SUBPOOL_2_SIZES.take(), - SUBPOOL_2_NUM_ELEMENTS, - true - ) - .is_ok()); - assert!(heapless_pool - .grow( - SUBPOOL_4.take(), - SUBPOOL_4_SIZES.take(), - SUBPOOL_4_NUM_ELEMENTS, - true - ) - .is_ok()); + assert!( + heapless_pool + .grow( + SUBPOOL_2.take(), + SUBPOOL_2_SIZES.take(), + SUBPOOL_2_NUM_ELEMENTS, + true + ) + .is_ok() + ); + assert!( + heapless_pool + .grow( + SUBPOOL_4.take(), + SUBPOOL_4_SIZES.take(), + SUBPOOL_4_NUM_ELEMENTS, + true + ) + .is_ok() + ); generic_test_spills_to_higher_subpools(&mut heapless_pool); } @@ -1816,22 +1836,26 @@ mod tests { fn test_spillage_fails_as_well() { let mut heapless_pool: StaticHeaplessMemoryPool<2> = StaticHeaplessMemoryPool::new(true); - assert!(heapless_pool - .grow( - SUBPOOL_5.take(), - SUBPOOL_5_SIZES.take(), - SUBPOOL_5_NUM_ELEMENTS, - true - ) - .is_ok()); - assert!(heapless_pool - .grow( - SUBPOOL_3.take(), - SUBPOOL_3_SIZES.take(), - SUBPOOL_3_NUM_ELEMENTS, - true - ) - .is_ok()); + assert!( + heapless_pool + .grow( + SUBPOOL_5.take(), + SUBPOOL_5_SIZES.take(), + SUBPOOL_5_NUM_ELEMENTS, + true + ) + .is_ok() + ); + assert!( + heapless_pool + .grow( + SUBPOOL_3.take(), + SUBPOOL_3_SIZES.take(), + SUBPOOL_3_NUM_ELEMENTS, + true + ) + .is_ok() + ); generic_test_spillage_fails_as_well(&mut heapless_pool); } @@ -1839,30 +1863,36 @@ mod tests { fn test_spillage_works_across_multiple_subpools() { let mut heapless_pool: StaticHeaplessMemoryPool<3> = StaticHeaplessMemoryPool::new(true); - assert!(heapless_pool - .grow( - SUBPOOL_5.take(), - SUBPOOL_5_SIZES.take(), - SUBPOOL_5_NUM_ELEMENTS, - true - ) - .is_ok()); - assert!(heapless_pool - .grow( - SUBPOOL_6.take(), - SUBPOOL_6_SIZES.take(), - SUBPOOL_6_NUM_ELEMENTS, - true - ) - .is_ok()); - assert!(heapless_pool - .grow( - SUBPOOL_3.take(), - SUBPOOL_3_SIZES.take(), - SUBPOOL_3_NUM_ELEMENTS, - true - ) - .is_ok()); + assert!( + heapless_pool + .grow( + SUBPOOL_5.take(), + SUBPOOL_5_SIZES.take(), + SUBPOOL_5_NUM_ELEMENTS, + true + ) + .is_ok() + ); + assert!( + heapless_pool + .grow( + SUBPOOL_6.take(), + SUBPOOL_6_SIZES.take(), + SUBPOOL_6_NUM_ELEMENTS, + true + ) + .is_ok() + ); + assert!( + heapless_pool + .grow( + SUBPOOL_3.take(), + SUBPOOL_3_SIZES.take(), + SUBPOOL_3_NUM_ELEMENTS, + true + ) + .is_ok() + ); generic_test_spillage_works_across_multiple_subpools(&mut heapless_pool); } @@ -1870,30 +1900,36 @@ mod tests { fn test_spillage_fails_across_multiple_subpools() { let mut heapless_pool: StaticHeaplessMemoryPool<3> = StaticHeaplessMemoryPool::new(true); - assert!(heapless_pool - .grow( - SUBPOOL_5.take(), - SUBPOOL_5_SIZES.take(), - SUBPOOL_5_NUM_ELEMENTS, - true - ) - .is_ok()); - assert!(heapless_pool - .grow( - SUBPOOL_6.take(), - SUBPOOL_6_SIZES.take(), - SUBPOOL_6_NUM_ELEMENTS, - true - ) - .is_ok()); - assert!(heapless_pool - .grow( - SUBPOOL_3.take(), - SUBPOOL_3_SIZES.take(), - SUBPOOL_3_NUM_ELEMENTS, - true - ) - .is_ok()); + assert!( + heapless_pool + .grow( + SUBPOOL_5.take(), + SUBPOOL_5_SIZES.take(), + SUBPOOL_5_NUM_ELEMENTS, + true + ) + .is_ok() + ); + assert!( + heapless_pool + .grow( + SUBPOOL_6.take(), + SUBPOOL_6_SIZES.take(), + SUBPOOL_6_NUM_ELEMENTS, + true + ) + .is_ok() + ); + assert!( + heapless_pool + .grow( + SUBPOOL_3.take(), + SUBPOOL_3_SIZES.take(), + SUBPOOL_3_NUM_ELEMENTS, + true + ) + .is_ok() + ); generic_test_spillage_fails_across_multiple_subpools(&mut heapless_pool); } } diff --git a/satrs/src/power.rs b/satrs/src/power.rs index cb2648a..3872a9f 100644 --- a/satrs/src/power.rs +++ b/satrs/src/power.rs @@ -190,7 +190,7 @@ mod tests { use std::sync::mpsc::{self, TryRecvError}; - use crate::{queue::GenericSendError, request::GenericMessage, ComponentId}; + use crate::{ComponentId, queue::GenericSendError, request::GenericMessage}; use super::*; diff --git a/satrs/src/pus/action.rs b/satrs/src/pus/action.rs index 7a048b1..24dbaac 100644 --- a/satrs/src/pus/action.rs +++ b/satrs/src/pus/action.rs @@ -65,13 +65,13 @@ impl GenericActionReplyPus { #[cfg(feature = "alloc")] pub mod alloc_mod { use crate::{ + ComponentId, action::ActionRequest, queue::{GenericReceiveError, GenericSendError}, request::{ GenericMessage, MessageReceiverProvider, MessageSenderAndReceiver, MessageSenderProvider, MessageSenderStoreProvider, RequestId, }, - ComponentId, }; use super::ActionReplyPus; @@ -81,10 +81,10 @@ pub mod alloc_mod { MessageSenderAndReceiver; impl< - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - ReplySender: MessageSenderStoreProvider, - > ActionRequestHandlerInterface + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + ReplySender: MessageSenderStoreProvider, + > ActionRequestHandlerInterface { pub fn try_recv_action_request( &self, @@ -114,10 +114,10 @@ pub mod alloc_mod { >; impl< - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - RequestSenderStore: MessageSenderStoreProvider, - > ActionRequestorInterface + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + RequestSenderStore: MessageSenderStoreProvider, + > ActionRequestorInterface { pub fn try_recv_action_reply( &self, @@ -141,12 +141,12 @@ pub mod std_mod { use std::sync::mpsc; use crate::{ + ComponentId, pus::{ - verification::{self, TcStateToken}, ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap, + verification::{self, TcStateToken}, }, request::{MessageSenderMap, OneMessageSender}, - ComponentId, }; use super::*; diff --git a/satrs/src/pus/event.rs b/satrs/src/pus/event.rs index a6301e2..08b57bc 100644 --- a/satrs/src/pus/event.rs +++ b/satrs/src/pus/event.rs @@ -1,9 +1,9 @@ use crate::pus::source_buffer_large_enough; +use spacepackets::ByteConversionError; +use spacepackets::ecss::EcssEnumeration; use spacepackets::ecss::tm::PusTmCreator; use spacepackets::ecss::tm::PusTmSecondaryHeader; -use spacepackets::ecss::EcssEnumeration; -use spacepackets::ByteConversionError; -use spacepackets::{SpHeader, MAX_APID}; +use spacepackets::{MAX_APID, SpHeader}; #[cfg(feature = "alloc")] pub use alloc_mod::*; @@ -132,8 +132,8 @@ impl EventReportCreator { #[cfg(feature = "alloc")] mod alloc_mod { use super::*; - use crate::pus::{EcssTmSender, EcssTmtcError}; use crate::ComponentId; + use crate::pus::{EcssTmSender, EcssTmtcError}; use alloc::vec; use alloc::vec::Vec; use core::cell::RefCell; @@ -265,13 +265,13 @@ mod alloc_mod { #[cfg(test)] mod tests { use super::*; + use crate::ComponentId; use crate::events::{EventU32, Severity}; use crate::pus::test_util::TEST_COMPONENT_ID_0; use crate::pus::tests::CommonTmInfo; use crate::pus::{ChannelWithId, EcssTmSender, EcssTmtcError, PusTmVariant}; - use crate::ComponentId; - use spacepackets::ecss::PusError; use spacepackets::ByteConversionError; + use spacepackets::ecss::PusError; use std::cell::RefCell; use std::collections::VecDeque; use std::vec::Vec; diff --git a/satrs/src/pus/event_man.rs b/satrs/src/pus/event_man.rs index 5eddbe4..15e1ffa 100644 --- a/satrs/src/pus/event_man.rs +++ b/satrs/src/pus/event_man.rs @@ -6,13 +6,13 @@ use core::hash::Hash; #[cfg(feature = "alloc")] use hashbrown::HashSet; -#[cfg(feature = "alloc")] -pub use crate::pus::event::EventReporter; -use crate::pus::verification::TcStateToken; #[cfg(feature = "alloc")] use crate::pus::EcssTmSender; use crate::pus::EcssTmtcError; #[cfg(feature = "alloc")] +pub use crate::pus::event::EventReporter; +use crate::pus::verification::TcStateToken; +#[cfg(feature = "alloc")] pub use alloc_mod::*; #[cfg(feature = "heapless")] pub use heapless_mod::*; @@ -159,10 +159,10 @@ pub mod alloc_mod { } impl< - ReportingMap: PusEventReportingMapProvider, - Event: GenericEvent, - EventTmHook: EventTmHookProvider, - > PusEventTmCreatorWithMap + ReportingMap: PusEventReportingMapProvider, + Event: GenericEvent, + EventTmHook: EventTmHookProvider, + > PusEventTmCreatorWithMap { pub fn new(reporter: EventReporter, backend: ReportingMap) -> Self { Self { @@ -311,9 +311,9 @@ pub mod alloc_mod { mod tests { use alloc::string::{String, ToString}; use alloc::vec; + use spacepackets::ecss::PusPacket; use spacepackets::ecss::event::Subservice; use spacepackets::ecss::tm::PusTmReader; - use spacepackets::ecss::PusPacket; use super::*; use crate::request::UniqueApidTargetId; diff --git a/satrs/src/pus/event_srv.rs b/satrs/src/pus/event_srv.rs index a3378fa..d669388 100644 --- a/satrs/src/pus/event_srv.rs +++ b/satrs/src/pus/event_srv.rs @@ -3,8 +3,8 @@ use crate::pus::event_man::{EventRequest, EventRequestWithToken}; use crate::pus::verification::TcStateToken; use crate::pus::{DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError}; use crate::queue::GenericSendError; -use spacepackets::ecss::event::Subservice; use spacepackets::ecss::PusPacket; +use spacepackets::ecss::event::Subservice; use std::sync::mpsc::Sender; use super::verification::VerificationReportingProvider; @@ -25,11 +25,11 @@ pub struct PusEventServiceHandler< } impl< - TcReceiver: EcssTcReceiver, - TmSender: EcssTmSender, - TcInMemConverter: EcssTcInMemConversionProvider, - VerificationReporter: VerificationReportingProvider, - > PusEventServiceHandler + TcReceiver: EcssTcReceiver, + TmSender: EcssTmSender, + TcInMemConverter: EcssTcInMemConversionProvider, + VerificationReporter: VerificationReportingProvider, +> PusEventServiceHandler { pub fn new( service_helper: PusServiceHelper< @@ -122,7 +122,7 @@ impl< | Subservice::TmHighSeverityReport => { return Err(PusPacketHandlingError::RequestConversion( GenericConversionError::WrongService(tc.subservice()), - )) + )); } Subservice::TcEnableEventGeneration => { handle_enable_disable_request(true)?; @@ -146,14 +146,14 @@ impl< mod tests { use delegate::delegate; use spacepackets::ecss::event::Subservice; - use spacepackets::time::{cds, TimeWriter}; + use spacepackets::time::{TimeWriter, cds}; use spacepackets::util::UnsignedEnum; use spacepackets::{ + SpHeader, ecss::{ tc::{PusTcCreator, PusTcSecondaryHeader}, tm::PusTmReader, }, - SpHeader, }; use std::sync::mpsc::{self, Sender}; @@ -167,10 +167,10 @@ mod tests { use crate::{ events::EventU32, pus::{ + DirectPusPacketHandlerResult, EcssTcInSharedPoolConverter, PusPacketHandlingError, event_man::EventRequestWithToken, tests::PusServiceHandlerWithSharedStoreCommon, verification::{TcStateAccepted, VerificationToken}, - DirectPusPacketHandlerResult, EcssTcInSharedPoolConverter, PusPacketHandlingError, }, }; diff --git a/satrs/src/pus/mod.rs b/satrs/src/pus/mod.rs index 43d2629..fa4021d 100644 --- a/satrs/src/pus/mod.rs +++ b/satrs/src/pus/mod.rs @@ -2,6 +2,7 @@ //! //! This module contains structures to make working with the PUS C standard easier. //! The satrs-example application contains various usage examples of these components. +use crate::ComponentId; use crate::pool::{PoolAddr, PoolError}; use crate::pus::verification::{TcStateAccepted, TcStateToken, VerificationToken}; use crate::queue::{GenericReceiveError, GenericSendError}; @@ -9,19 +10,18 @@ use crate::request::{GenericMessage, MessageMetadata, RequestId}; #[cfg(feature = "alloc")] use crate::tmtc::PacketAsVec; use crate::tmtc::PacketInPool; -use crate::ComponentId; use core::fmt::{Display, Formatter}; use core::time::Duration; #[cfg(feature = "alloc")] -use downcast_rs::{impl_downcast, Downcast}; +use downcast_rs::{Downcast, impl_downcast}; #[cfg(feature = "alloc")] use dyn_clone::DynClone; #[cfg(feature = "std")] use std::error::Error; +use spacepackets::ecss::PusError; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader}; use spacepackets::ecss::tm::PusTmCreator; -use spacepackets::ecss::PusError; use spacepackets::{ByteConversionError, SpHeader}; pub mod action; @@ -659,18 +659,18 @@ pub mod alloc_mod { #[cfg(feature = "std")] pub mod std_mod { use super::*; + use crate::ComponentId; use crate::pool::{ PoolAddr, PoolError, PoolProvider, PoolProviderWithGuards, SharedStaticMemoryPool, }; use crate::pus::verification::{TcStateAccepted, VerificationToken}; use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool}; - use crate::ComponentId; use alloc::vec::Vec; use core::time::Duration; - use spacepackets::ecss::tc::PusTcReader; - use spacepackets::ecss::WritablePusPacket; - use spacepackets::time::StdTimestampError; use spacepackets::ByteConversionError; + use spacepackets::ecss::WritablePusPacket; + use spacepackets::ecss::tc::PusTcReader; + use spacepackets::time::StdTimestampError; use std::string::String; use std::sync::mpsc; use std::sync::mpsc::TryRecvError; @@ -1137,11 +1137,11 @@ pub mod std_mod { } impl< - TcReceiver: EcssTcReceiver, - TmSender: EcssTmSender, - TcInMemConverter: EcssTcInMemConversionProvider, - VerificationReporter: VerificationReportingProvider, - > PusServiceHelper + TcReceiver: EcssTcReceiver, + TmSender: EcssTmSender, + TcInMemConverter: EcssTcInMemConversionProvider, + VerificationReporter: VerificationReportingProvider, + > PusServiceHelper { pub fn new( id: ComponentId, @@ -1261,8 +1261,8 @@ pub mod test_util { use crate::request::UniqueApidTargetId; use super::{ - verification::{self, TcStateAccepted, VerificationToken}, DirectPusPacketHandlerResult, PusPacketHandlingError, + verification::{self, TcStateAccepted, VerificationToken}, }; pub const TEST_APID: u16 = 0x101; @@ -1288,7 +1288,7 @@ pub mod test_util { pub trait SimplePusPacketHandler { fn handle_one_tc(&mut self) - -> Result; + -> Result; } } @@ -1296,21 +1296,21 @@ pub mod test_util { pub mod tests { use core::cell::RefCell; use std::sync::mpsc::TryRecvError; - use std::sync::{mpsc, RwLock}; + use std::sync::{RwLock, mpsc}; use alloc::collections::VecDeque; use alloc::vec::Vec; use satrs_shared::res_code::ResultU16; + use spacepackets::CcsdsPacket; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader}; use spacepackets::ecss::tm::{GenericPusTmSecondaryHeader, PusTmCreator, PusTmReader}; use spacepackets::ecss::{PusPacket, WritablePusPacket}; - use spacepackets::CcsdsPacket; use test_util::{TEST_APID, TEST_COMPONENT_ID_0}; + use crate::ComponentId; use crate::pool::{PoolProvider, SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig}; use crate::pus::verification::{RequestId, VerificationReporter}; use crate::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool, SharedPacketPool}; - use crate::ComponentId; use super::verification::test_util::TestVerificationReporter; use super::verification::{ diff --git a/satrs/src/pus/scheduler.rs b/satrs/src/pus/scheduler.rs index 6c57102..9509892 100644 --- a/satrs/src/pus/scheduler.rs +++ b/satrs/src/pus/scheduler.rs @@ -340,8 +340,8 @@ pub fn generate_insert_telecommand_app_data( pub mod alloc_mod { use alloc::{ collections::{ - btree_map::{Entry, Range}, BTreeMap, + btree_map::{Entry, Range}, }, vec::Vec, }; @@ -855,9 +855,9 @@ mod tests { PoolAddr, PoolError, PoolProvider, StaticMemoryPool, StaticPoolAddr, StaticPoolConfig, }; use alloc::collections::btree_map::Range; - use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; use spacepackets::ecss::WritablePusPacket; - use spacepackets::time::{cds, TimeWriter, UnixTime}; + use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; + use spacepackets::time::{TimeWriter, UnixTime, cds}; use spacepackets::{PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader}; use std::time::Duration; use std::vec::Vec; diff --git a/satrs/src/pus/scheduler_srv.rs b/satrs/src/pus/scheduler_srv.rs index 0b12394..ccef475 100644 --- a/satrs/src/pus/scheduler_srv.rs +++ b/satrs/src/pus/scheduler_srv.rs @@ -9,7 +9,7 @@ use crate::pool::PoolProvider; use crate::pus::PusPacketHandlingError; use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool}; use alloc::string::ToString; -use spacepackets::ecss::{scheduling, PusPacket}; +use spacepackets::ecss::{PusPacket, scheduling}; use spacepackets::time::cds::CdsTime; use std::sync::mpsc; @@ -34,13 +34,12 @@ pub struct PusSchedServiceHandler< } impl< - TcReceiver: EcssTcReceiver, - TmSender: EcssTmSender, - TcInMemConverter: EcssTcInMemConversionProvider, - VerificationReporter: VerificationReportingProvider, - Scheduler: PusSchedulerProvider, - > - PusSchedServiceHandler + TcReceiver: EcssTcReceiver, + TmSender: EcssTmSender, + TcInMemConverter: EcssTcInMemConversionProvider, + VerificationReporter: VerificationReportingProvider, + Scheduler: PusSchedulerProvider, +> PusSchedServiceHandler { pub fn new( service_helper: PusServiceHelper< @@ -102,11 +101,12 @@ impl< } }; self.scheduler.enable(); - - if self.scheduler.is_enabled() && opt_started_token.is_some() { + if self.scheduler.is_enabled() + && let Some(started_token) = opt_started_token + { if let Err(e) = self.service_helper.verif_reporter().completion_success( &self.service_helper.common.tm_sender, - opt_started_token.unwrap(), + started_token, time_stamp, ) { error_callback(&PartialPusHandlingError::Verification(e)); @@ -131,10 +131,12 @@ impl< }; self.scheduler.disable(); - if !self.scheduler.is_enabled() && opt_started_token.is_some() { + if !self.scheduler.is_enabled() + && let Some(started_token) = opt_started_token + { if let Err(e) = self.service_helper.verif_reporter().completion_success( &self.service_helper.common.tm_sender, - opt_started_token.unwrap(), + started_token, time_stamp, ) { error_callback(&PartialPusHandlingError::Verification(e)); @@ -249,21 +251,21 @@ mod tests { use crate::pus::test_util::{PusTestHarness, TEST_APID}; use crate::pus::verification::{VerificationReporter, VerificationReportingProvider}; + use crate::pus::{DirectPusPacketHandlerResult, MpscTcReceiver, PusPacketHandlingError}; use crate::pus::{ + EcssTcInSharedPoolConverter, scheduler::{self, PusSchedulerProvider, TcInfo}, tests::PusServiceHandlerWithSharedStoreCommon, verification::{RequestId, TcStateAccepted, VerificationToken}, - EcssTcInSharedPoolConverter, }; - use crate::pus::{DirectPusPacketHandlerResult, MpscTcReceiver, PusPacketHandlingError}; use crate::tmtc::PacketSenderWithSharedPool; use alloc::collections::VecDeque; use delegate::delegate; + use spacepackets::SpHeader; + use spacepackets::ecss::WritablePusPacket; use spacepackets::ecss::scheduling::Subservice; use spacepackets::ecss::tc::PusTcSecondaryHeader; - use spacepackets::ecss::WritablePusPacket; use spacepackets::time::TimeWriter; - use spacepackets::SpHeader; use spacepackets::{ ecss::{tc::PusTcCreator, tm::PusTmReader}, time::cds, diff --git a/satrs/src/pus/test.rs b/satrs/src/pus/test.rs index c2ec5ff..10905c9 100644 --- a/satrs/src/pus/test.rs +++ b/satrs/src/pus/test.rs @@ -2,9 +2,9 @@ use crate::pus::{ DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError, PusTmVariant, }; use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool}; -use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; -use spacepackets::ecss::PusPacket; use spacepackets::SpHeader; +use spacepackets::ecss::PusPacket; +use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; use std::sync::mpsc; use super::verification::{VerificationReporter, VerificationReportingProvider}; @@ -27,11 +27,11 @@ pub struct PusService17TestHandler< } impl< - TcReceiver: EcssTcReceiver, - TmSender: EcssTmSender, - TcInMemConverter: EcssTcInMemConversionProvider, - VerificationReporter: VerificationReportingProvider, - > PusService17TestHandler + TcReceiver: EcssTcReceiver, + TmSender: EcssTmSender, + TcInMemConverter: EcssTcInMemConversionProvider, + VerificationReporter: VerificationReportingProvider, +> PusService17TestHandler { pub fn new( service_helper: PusServiceHelper< @@ -134,6 +134,7 @@ pub type PusService17TestHandlerStaticWithBoundedMpsc = PusService17TestHandler< #[cfg(test)] mod tests { + use crate::ComponentId; use crate::pus::test_util::{PusTestHarness, SimplePusPacketHandler, TEST_APID}; use crate::pus::tests::{ PusServiceHandlerWithSharedStoreCommon, PusServiceHandlerWithVecCommon, @@ -148,13 +149,12 @@ mod tests { PartialPusHandlingError, PusPacketHandlingError, }; use crate::tmtc::PacketSenderWithSharedPool; - use crate::ComponentId; use delegate::delegate; + use spacepackets::SpHeader; + use spacepackets::ecss::PusPacket; use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader}; use spacepackets::ecss::tm::PusTmReader; - use spacepackets::ecss::PusPacket; - use spacepackets::time::{cds, TimeWriter}; - use spacepackets::SpHeader; + use spacepackets::time::{TimeWriter, cds}; use super::PusService17TestHandler; diff --git a/satrs/src/pus/verification.rs b/satrs/src/pus/verification.rs index 82236d3..b248be1 100644 --- a/satrs/src/pus/verification.rs +++ b/satrs/src/pus/verification.rs @@ -81,7 +81,7 @@ //! for the verification module contains examples how this module could be used in a more complex //! context involving multiple threads use crate::params::{Params, WritableToBeBytes}; -use crate::pus::{source_buffer_large_enough, EcssTmSender, EcssTmtcError}; +use crate::pus::{EcssTmSender, EcssTmtcError, source_buffer_large_enough}; use core::fmt::{Debug, Display, Formatter}; use core::hash::{Hash, Hasher}; use core::marker::PhantomData; @@ -90,11 +90,11 @@ use core::mem::size_of; use delegate::delegate; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; +use spacepackets::ecss::EcssEnumeration; use spacepackets::ecss::tc::IsPusTelecommand; use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; -use spacepackets::ecss::EcssEnumeration; use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceCtrl}; -use spacepackets::{SpHeader, MAX_APID}; +use spacepackets::{MAX_APID, SpHeader}; pub use spacepackets::ecss::verification::*; pub use spacepackets::seq_count::SeqCountProviderSimple; @@ -102,8 +102,8 @@ pub use spacepackets::seq_count::SeqCountProviderSimple; #[cfg(feature = "alloc")] pub use alloc_mod::*; -use crate::request::Apid; use crate::ComponentId; +use crate::request::Apid; /// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard. /// @@ -1686,39 +1686,39 @@ pub mod test_util { #[cfg(test)] pub mod tests { + use crate::ComponentId; use crate::params::Params; use crate::pool::{SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig}; use crate::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0}; use crate::pus::tests::CommonTmInfo; use crate::pus::verification::{ - handle_step_failure_with_generic_params, EcssTmSender, EcssTmtcError, FailParams, - FailParamsWithStep, RequestId, TcStateNone, VerificationReporter, VerificationReporterCfg, - VerificationToken, + EcssTmSender, EcssTmtcError, FailParams, FailParamsWithStep, RequestId, TcStateNone, + VerificationReporter, VerificationReporterCfg, VerificationToken, + handle_step_failure_with_generic_params, }; use crate::pus::{ChannelWithId, PusTmVariant}; use crate::request::MessageMetadata; use crate::spacepackets::seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProvider}; use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool}; - use crate::ComponentId; use alloc::format; use alloc::string::ToString; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; use spacepackets::ecss::{ - EcssEnumU16, EcssEnumU32, EcssEnumU8, EcssEnumeration, PusError, PusPacket, + EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, PusError, PusPacket, WritablePusPacket, }; use spacepackets::util::UnsignedEnum; use spacepackets::{ByteConversionError, SpHeader}; use std::cell::RefCell; use std::collections::VecDeque; - use std::sync::{mpsc, RwLock}; + use std::sync::{RwLock, mpsc}; use std::vec; use std::vec::Vec; use super::{ - handle_completion_failure_with_generic_params, DummyVerificationHook, FailParamHelper, - SeqCountProviderSimple, TcStateAccepted, TcStateStarted, VerificationHookProvider, - VerificationReportingProvider, WasAtLeastAccepted, + DummyVerificationHook, FailParamHelper, SeqCountProviderSimple, TcStateAccepted, + TcStateStarted, VerificationHookProvider, VerificationReportingProvider, + WasAtLeastAccepted, handle_completion_failure_with_generic_params, }; fn is_send(_: &T) {} diff --git a/satrs/src/request.rs b/satrs/src/request.rs index 180ce00..e3d03d1 100644 --- a/satrs/src/request.rs +++ b/satrs/src/request.rs @@ -9,13 +9,13 @@ pub use alloc_mod::*; pub use std_mod::*; use spacepackets::{ - ecss::{tc::IsPusTelecommand, PusPacket}, ByteConversionError, + ecss::{PusPacket, tc::IsPusTelecommand}, }; use crate::{ - queue::{GenericReceiveError, GenericSendError}, ComponentId, + queue::{GenericReceiveError, GenericSendError}, }; /// Generic request ID type. Requests can be associated with an ID to have a unique identifier @@ -335,12 +335,12 @@ pub mod alloc_mod { } impl< - To, - From, - Sender: MessageSenderProvider, - Receiver: MessageReceiverProvider, - SenderStore: MessageSenderStoreProvider, - > MessageSenderAndReceiver + To, + From, + Sender: MessageSenderProvider, + Receiver: MessageReceiverProvider, + SenderStore: MessageSenderStoreProvider, + > MessageSenderAndReceiver { pub fn new(local_channel_id: ComponentId, message_receiver: Receiver) -> Self { Self { @@ -403,15 +403,15 @@ pub mod alloc_mod { } impl< - Request, - ReqSender: MessageSenderProvider, - ReqReceiver: MessageReceiverProvider, - ReqSenderStore: MessageSenderStoreProvider, - Reply, - ReplySender: MessageSenderProvider, - ReplyReceiver: MessageReceiverProvider, - ReplySenderStore: MessageSenderStoreProvider, - > + Request, + ReqSender: MessageSenderProvider, + ReqReceiver: MessageReceiverProvider, + ReqSenderStore: MessageSenderStoreProvider, + Reply, + ReplySender: MessageSenderProvider, + ReplyReceiver: MessageReceiverProvider, + ReplySenderStore: MessageSenderStoreProvider, + > RequestAndReplySenderAndReceiver< Request, ReqSender, @@ -497,8 +497,8 @@ mod tests { use alloc::string::ToString; use spacepackets::{ - ecss::tc::{PusTcCreator, PusTcSecondaryHeader}, ByteConversionError, SpHeader, + ecss::tc::{PusTcCreator, PusTcSecondaryHeader}, }; use crate::{ diff --git a/satrs/src/scheduling.rs b/satrs/src/scheduling.rs index ff2c0a1..4b5a6af 100644 --- a/satrs/src/scheduling.rs +++ b/satrs/src/scheduling.rs @@ -211,8 +211,8 @@ mod tests { println, rc::Rc, sync::{ - mpsc::{self, TryRecvError}, Arc, Mutex, + mpsc::{self, TryRecvError}, }, time::Instant, }; diff --git a/satrs/src/subsystem.rs b/satrs/src/subsystem.rs index 5032789..578f22f 100644 --- a/satrs/src/subsystem.rs +++ b/satrs/src/subsystem.rs @@ -1,4 +1,5 @@ use crate::{ + ComponentId, health::{HealthState, HealthTableProvider}, mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, ModeRequestSender, UNKNOWN_MODE_VAL}, mode_tree::{ @@ -7,7 +8,6 @@ use crate::{ }, queue::GenericTargetedMessagingError, request::{GenericMessage, RequestId}, - ComponentId, }; #[derive(Debug, PartialEq, Eq, Copy, Clone)] @@ -252,10 +252,10 @@ impl SequenceExecutionHelper { Ok(ModeCommandingResult::AwaitingSuccessCheck) } else if seq_table_value.entries.len() - 1 == sequence_idx { self.state = SequenceExecutionHelperState::Idle; - return Ok(ModeCommandingResult::Done); + Ok(ModeCommandingResult::Done) } else { self.current_sequence_index = Some(sequence_idx + 1); - return Ok(ModeCommandingResult::StepDone); + Ok(ModeCommandingResult::StepDone) } } @@ -682,9 +682,10 @@ mod tests { use super::*; use crate::{ + ComponentId, mode::{ - tests::{ModeReqSenderMock, ModeReqWrapper}, Mode, ModeAndSubmode, ModeReply, ModeRequest, UNKNOWN_MODE, + tests::{ModeReqSenderMock, ModeReqWrapper}, }, mode_tree::{ ModeStoreProvider, ModeStoreVec, SequenceModeTables, SequenceTableEntry, @@ -693,7 +694,6 @@ mod tests { queue::GenericTargetedMessagingError, request::{GenericMessage, MessageMetadata, RequestId}, subsystem::{ModeCommandingResult, ModeTreeHelperState, SequenceExecutionHelperState}, - ComponentId, }; #[derive(Debug)] diff --git a/satrs/src/tmtc/mod.rs b/satrs/src/tmtc/mod.rs index f2993ce..3768a1e 100644 --- a/satrs/src/tmtc/mod.rs +++ b/satrs/src/tmtc/mod.rs @@ -9,20 +9,20 @@ //! They only need to send the received and generated data to these objects. use crate::queue::GenericSendError; use crate::{ - pool::{PoolAddr, PoolError}, ComponentId, + pool::{PoolAddr, PoolError}, }; #[cfg(feature = "std")] pub use alloc_mod::*; use core::fmt::Debug; #[cfg(feature = "alloc")] -use downcast_rs::{impl_downcast, Downcast}; +use downcast_rs::{Downcast, impl_downcast}; use spacepackets::{ + SpHeader, ecss::{ tc::PusTcReader, tm::{PusTmCreator, PusTmReader}, }, - SpHeader, }; #[cfg(feature = "std")] use std::sync::mpsc; diff --git a/satrs/src/tmtc/tm_helper.rs b/satrs/src/tmtc/tm_helper.rs index 56bc99c..26ea8d4 100644 --- a/satrs/src/tmtc/tm_helper.rs +++ b/satrs/src/tmtc/tm_helper.rs @@ -1,7 +1,7 @@ -use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; -use spacepackets::time::cds::CdsTime; -use spacepackets::time::TimeWriter; use spacepackets::SpHeader; +use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; +use spacepackets::time::TimeWriter; +use spacepackets::time::cds::CdsTime; pub struct PusTmWithCdsShortHelper { apid: u16, @@ -56,7 +56,7 @@ impl PusTmWithCdsShortHelper { #[cfg(test)] mod tests { - use spacepackets::{ecss::PusPacket, time::cds::CdsTime, CcsdsPacket}; + use spacepackets::{CcsdsPacket, ecss::PusPacket, time::cds::CdsTime}; use super::PusTmWithCdsShortHelper; diff --git a/satrs/tests/mode_tree.rs b/satrs/tests/mode_tree.rs index 06c1b2f..5fee024 100644 --- a/satrs/tests/mode_tree.rs +++ b/satrs/tests/mode_tree.rs @@ -4,13 +4,13 @@ use satrs::dev_mgmt::{ DevManagerCommandingHelper, DevManagerHelperResult, TransparentDevManagerHook, }; use satrs::mode::{ - Mode, ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, ModeRequestHandler, - ModeRequestHandlerMpscBounded, ModeRequestReceiver, ModeRequestorAndHandlerMpscBounded, - ModeRequestorOneChildBoundedMpsc, INVALID_MODE, UNKNOWN_MODE, + INVALID_MODE, Mode, ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, + ModeRequestHandler, ModeRequestHandlerMpscBounded, ModeRequestReceiver, + ModeRequestorAndHandlerMpscBounded, ModeRequestorOneChildBoundedMpsc, UNKNOWN_MODE, }; use satrs::mode_tree::{ - connect_mode_nodes, ModeChild, ModeNode, ModeParent, ModeStoreProvider, SequenceTableEntry, - SequenceTableMapTable, TargetTableEntry, + ModeChild, ModeNode, ModeParent, ModeStoreProvider, SequenceTableEntry, SequenceTableMapTable, + TargetTableEntry, connect_mode_nodes, }; use satrs::mode_tree::{SequenceTablesMapValue, TargetTablesMapValue}; use satrs::request::{MessageMetadata, RequestId}; @@ -20,10 +20,10 @@ use satrs::subsystem::{ StartSequenceError, SubsystemCommandingHelper, SubsystemHelperResult, }; use satrs::{ + ComponentId, mode::{ModeAndSubmode, ModeReply, ModeRequest}, queue::GenericTargetedMessagingError, request::GenericMessage, - ComponentId, }; use std::borrow::{Borrow, BorrowMut}; use std::cell::RefCell; diff --git a/satrs/tests/pus_verification.rs b/satrs/tests/pus_verification.rs index 16bb1f8..86a161e 100644 --- a/satrs/tests/pus_verification.rs +++ b/satrs/tests/pus_verification.rs @@ -8,10 +8,10 @@ pub mod crossbeam_test { VerificationReportingProvider, }; use satrs::tmtc::{PacketSenderWithSharedPool, SharedStaticMemoryPool}; + use spacepackets::SpHeader; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; use spacepackets::ecss::tm::PusTmReader; - use spacepackets::ecss::{EcssEnumU16, EcssEnumU8, PusPacket, WritablePusPacket}; - use spacepackets::SpHeader; + use spacepackets::ecss::{EcssEnumU8, EcssEnumU16, PusPacket, WritablePusPacket}; use std::sync::RwLock; use std::thread; use std::time::Duration; diff --git a/satrs/tests/tcp_servers.rs b/satrs/tests/tcp_servers.rs index 602913e..43b0423 100644 --- a/satrs/tests/tcp_servers.rs +++ b/satrs/tests/tcp_servers.rs @@ -17,12 +17,13 @@ use core::{ use std::{ io::{Read, Write}, net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream}, - sync::{mpsc, Mutex}, + sync::{Mutex, mpsc}, thread, }; use hashbrown::HashSet; use satrs::{ + ComponentId, encoding::{ ccsds::{SpValidity, SpacePacketValidator}, cobs::encode_packet_with_cobs, @@ -32,11 +33,10 @@ use satrs::{ TcpSpacepacketsServer, TcpTmtcInCobsServer, }, tmtc::PacketSource, - ComponentId, }; use spacepackets::{ - ecss::{tc::PusTcCreator, WritablePusPacket}, CcsdsPacket, PacketId, SpHeader, + ecss::{WritablePusPacket, tc::PusTcCreator}, }; use std::{collections::VecDeque, sync::Arc, vec::Vec}; -- 2.43.0