fmt and clippy

2024-04-24 16:45:38 +02:00 · 2024-04-24 16:45:38 +02:00 · 6f3e14af3b
commit 6f3e14af3b
parent 83322ae415
5 changed files with 86 additions and 57 deletions
--- a/src/config.rs
+++ b/src/config.rs
@ -42,12 +42,16 @@ pub enum GroupId {
 lazy_static! {
    pub static ref HOME_PATH: PathBuf = {
        let mut home_path = PathBuf::new();
-        let home_path_default = homedir::get_my_home().expect("Getting home dir from OS failed.").expect("No home dir found.");
+        let home_path_default = homedir::get_my_home()
+            .expect("Getting home dir from OS failed.")
+            .expect("No home dir found.");

        home_path.push(if Path::new(HOME_FOLDER_EXPERIMENT).exists() {
            HOME_FOLDER_EXPERIMENT
        } else {
-            home_path_default.to_str().expect("Error converting to string.")
+            home_path_default
+                .to_str()
+                .expect("Error converting to string.")
        });
        home_path
    };
--- a/src/handlers/camera.rs
+++ b/src/handlers/camera.rs
@ -1,5 +1,4 @@
-use std::fmt;
-use std::fmt::Formatter;
+use crate::pus::action::send_data_reply;
 /// Device handler implementation for the IMS-100 Imager used on the OPS-SAT mission.
 ///
 /// from the [OPSSAT Experimenter Wiki](https://opssat1.esoc.esa.int/projects/experimenter-information/wiki/Camera_Introduction):
@ -32,14 +31,15 @@ use log::{debug, info};
 use ops_sat_rs::TimeStampHelper;
 use satrs::action::{ActionRequest, ActionRequestVariant};
 use satrs::hk::HkRequest;
+use satrs::pus::action::{ActionReplyPus, ActionReplyVariant};
+use satrs::pus::EcssTmtcError;
 use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
 use satrs::tmtc::PacketAsVec;
 use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::fmt::Formatter;
 use std::process::{Command, Output};
 use std::sync::mpsc;
-use satrs::pus::action::{ActionReplyPus, ActionReplyVariant};
-use satrs::pus::EcssTmtcError;
-use crate::pus::action::send_data_reply;

 // const IMS_TESTAPP: &str = "scripts/ims100_testapp";
 const IMS_TESTAPP: &str = "ims100_testapp";
@ -181,7 +181,7 @@ impl fmt::Display for CameraError {
                write!(f, "{}", io_error)
            }
            CameraError::EcssTmtcError(ecss_tmtc_error) => {
-                write!(f ,"{}", ecss_tmtc_error)
+                write!(f, "{}", ecss_tmtc_error)
            }
        }
    }
@ -264,35 +264,41 @@ impl IMS100BatchHandler {
        requestor_info: &MessageMetadata,
        action_request: &ActionRequest,
    ) -> Result<(), CameraError> {
-        let param = match CameraActionId::try_from(action_request.action_id).expect("Invalid action id") {
-            CameraActionId::DefaultSingle => DEFAULT_SINGLE_CAM_PARAMS,
-            CameraActionId::BalancedSingle => BALANCED_SINGLE_CAM_PARAMS,
-            CameraActionId::DefaultSingleFlatSat => DEFAULT_SINGLE_FLATSAT_CAM_PARAMS,
-            CameraActionId::BalancedSingleFlatSat => BALANCED_SINGLE_FLATSAT_CAM_PARAMS,
-            CameraActionId::CustomParameters => match &action_request.variant {
-                ActionRequestVariant::NoData => return Err(CameraError::NoDataSent),
-                ActionRequestVariant::StoreData(_) => {
-                    // let param = serde_json::from_slice()
-                    // TODO implement non dynamic version
-                    return Err(CameraError::VariantNotImplemented);
-                }
-                ActionRequestVariant::VecData(data) => {
-                    let param: serde_json::Result<CameraPictureParameters> =
-                        serde_json::from_slice(data.as_slice());
-                    match param {
-                        Ok(param) => param,
-                        Err(_) => {
-                            return Err(CameraError::DeserializeError);
+        let param =
+            match CameraActionId::try_from(action_request.action_id).expect("Invalid action id") {
+                CameraActionId::DefaultSingle => DEFAULT_SINGLE_CAM_PARAMS,
+                CameraActionId::BalancedSingle => BALANCED_SINGLE_CAM_PARAMS,
+                CameraActionId::DefaultSingleFlatSat => DEFAULT_SINGLE_FLATSAT_CAM_PARAMS,
+                CameraActionId::BalancedSingleFlatSat => BALANCED_SINGLE_FLATSAT_CAM_PARAMS,
+                CameraActionId::CustomParameters => match &action_request.variant {
+                    ActionRequestVariant::NoData => return Err(CameraError::NoDataSent),
+                    ActionRequestVariant::StoreData(_) => {
+                        // let param = serde_json::from_slice()
+                        // TODO implement non dynamic version
+                        return Err(CameraError::VariantNotImplemented);
+                    }
+                    ActionRequestVariant::VecData(data) => {
+                        let param: serde_json::Result<CameraPictureParameters> =
+                            serde_json::from_slice(data.as_slice());
+                        match param {
+                            Ok(param) => param,
+                            Err(_) => {
+                                return Err(CameraError::DeserializeError);
+                            }
                        }
                    }
-                }
-                _ => return Err(CameraError::VariantNotImplemented),
-            },
-        };
+                    _ => return Err(CameraError::VariantNotImplemented),
+                },
+            };
        let output = self.take_picture(param)?;
        debug!("Sending action reply!");
        send_data_reply(self.id, output.stdout, &self.stamp_helper, &self.tm_tx)?;
-        self.action_reply_tx.send(GenericMessage::new(*requestor_info, ActionReplyPus::new(action_request.action_id, ActionReplyVariant::Completed))).unwrap();
+        self.action_reply_tx
+            .send(GenericMessage::new(
+                *requestor_info,
+                ActionReplyPus::new(action_request.action_id, ActionReplyVariant::Completed),
+            ))
+            .unwrap();
        Ok(())
    }

@ -328,16 +334,13 @@ impl IMS100BatchHandler {
    }

    pub fn list_current_images(&self) -> Result<Vec<String>, CameraError> {
-        let output = Command::new("ls").arg("-l")
-            .arg("*.png")
-            .output()?;
+        let output = Command::new("ls").arg("-l").arg("*.png").output()?;

        if output.status.success() {
            let output_str = String::from_utf8(output.stdout).unwrap();
            let files: Vec<String> = output_str.lines().map(|s| s.to_string()).collect();
            Ok(files)
-        }
-        else {
+        } else {
            Err(CameraError::ListFileError)
        }
    }
@ -391,19 +394,29 @@ mod tests {
    use ops_sat_rs::config::components::CAMERA_HANDLER;
    use ops_sat_rs::TimeStampHelper;
    use satrs::action::{ActionRequest, ActionRequestVariant};
+    use satrs::pus::action::ActionReplyPus;
    use satrs::request::{GenericMessage, MessageMetadata};
    use satrs::tmtc::PacketAsVec;
    use std::sync::mpsc;
    use std::sync::mpsc::{Receiver, Sender};
-    use satrs::pus::action::ActionReplyPus;

-    fn create_handler() -> (IMS100BatchHandler, Sender<GenericMessage<CompositeRequest>>, Receiver<PacketAsVec>, Receiver<GenericMessage<ActionReplyPus>>) {
+    fn create_handler() -> (
+        IMS100BatchHandler,
+        Sender<GenericMessage<CompositeRequest>>,
+        Receiver<PacketAsVec>,
+        Receiver<GenericMessage<ActionReplyPus>>,
+    ) {
        let (composite_request_tx, composite_request_rx) = mpsc::channel();
        let (tm_tx, tm_rx) = mpsc::channel();
        let (action_reply_tx, action_reply_rx) = mpsc::channel();
        let time_helper = TimeStampHelper::default();
-        let cam_handler: IMS100BatchHandler =
-            IMS100BatchHandler::new(CAMERA_HANDLER, composite_request_rx, tm_tx, action_reply_tx, time_helper);
+        let cam_handler: IMS100BatchHandler = IMS100BatchHandler::new(
+            CAMERA_HANDLER,
+            composite_request_rx,
+            tm_tx,
+            action_reply_tx,
+            time_helper,
+        );
        (cam_handler, composite_request_tx, tm_rx, action_reply_rx)
    }

--- a/src/logger.rs
+++ b/src/logger.rs
@ -7,7 +7,7 @@ pub fn setup_logger() -> Result<(), fern::InitError> {
        eprintln!("Failed to create log folder '{}'", LOG_FOLDER);
    }
    let mut path_buf = PathBuf::from(LOG_FOLDER);
-    path_buf.push(format!("output.log"));
+    path_buf.push("output.log");
    println!("{:?}", path_buf);
    fern::Dispatch::new()
        .format(move |out, message, record| {
--- a/src/main.rs
+++ b/src/main.rs
@ -14,8 +14,8 @@ use ops_sat_rs::config::{
    VALID_PACKET_ID_LIST,
 };
 use ops_sat_rs::config::{tasks::FREQ_MS_UDP_TMTC, OBSW_SERVER_ADDR, SERVER_PORT};
-use satrs::hal::std::{tcp_server::ServerConfig, udp_server::UdpTcServer};
 use ops_sat_rs::TimeStampHelper;
+use satrs::hal::std::{tcp_server::ServerConfig, udp_server::UdpTcServer};

 use crate::handlers::camera::IMS100BatchHandler;
 use crate::pus::{PusTcDistributor, PusTcMpscRouter};
@ -184,8 +184,13 @@ fn main() {
    .expect("creating TCP SPP client failed");

    let timestamp_helper = TimeStampHelper::default();
-    let mut camera_handler: IMS100BatchHandler =
-        IMS100BatchHandler::new(CAMERA_HANDLER, camera_composite_rx, tm_funnel_tx.clone(), pus_action_reply_tx.clone(), timestamp_helper);
+    let mut camera_handler: IMS100BatchHandler = IMS100BatchHandler::new(
+        CAMERA_HANDLER,
+        camera_composite_rx,
+        tm_funnel_tx.clone(),
+        pus_action_reply_tx.clone(),
+        timestamp_helper,
+    );

    // Main Task Thread Definitions

--- a/src/pus/action.rs
+++ b/src/pus/action.rs
@ -1,5 +1,7 @@
 use log::{debug, error, warn};
+use ops_sat_rs::config::components::PUS_ACTION_SERVICE;
 use ops_sat_rs::config::tmtc_err;
+use ops_sat_rs::TimeStampHelper;
 use satrs::action::{ActionRequest, ActionRequestVariant};
 use satrs::params::WritableToBeBytes;
 use satrs::pus::action::{
@ -9,17 +11,19 @@ use satrs::pus::verification::{
    FailParams, FailParamsWithStep, TcStateAccepted, TcStateStarted, VerificationReporter,
    VerificationReportingProvider, VerificationToken,
 };
-use satrs::pus::{ActiveRequestProvider, EcssTcAndToken, EcssTcInVecConverter, EcssTmSender, EcssTmtcError, GenericConversionError, PusPacketHandlerResult, PusReplyHandler, PusServiceHelper, PusTcToRequestConverter, PusTmVariant};
+use satrs::pus::{
+    ActiveRequestProvider, EcssTcAndToken, EcssTcInVecConverter, EcssTmSender, EcssTmtcError,
+    GenericConversionError, PusPacketHandlerResult, PusReplyHandler, PusServiceHelper,
+    PusTcToRequestConverter, PusTmVariant,
+};
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
+use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket};
+use satrs::spacepackets::SpHeader;
 use satrs::tmtc::PacketAsVec;
 use std::sync::mpsc;
 use std::time::Duration;
-use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
-use satrs::spacepackets::SpHeader;
-use ops_sat_rs::config::components::PUS_ACTION_SERVICE;
-use ops_sat_rs::TimeStampHelper;

 use crate::requests::GenericRequestRouter;

@ -271,20 +275,23 @@ impl TargetedPusService for ActionServiceWrapper {
    }
 }

-pub fn send_data_reply<TmSender: EcssTmSender>(apid_target: UniqueApidTargetId, reply_data: Vec<u8>, stamp_helper: &TimeStampHelper, tm_sender: &TmSender) -> Result<(), EcssTmtcError> {
+pub fn send_data_reply<TmSender: EcssTmSender>(
+    apid_target: UniqueApidTargetId,
+    reply_data: Vec<u8>,
+    stamp_helper: &TimeStampHelper,
+    tm_sender: &TmSender,
+) -> Result<(), EcssTmtcError> {
    let sp_header = SpHeader::new_from_apid(apid_target.apid);
    let sec_header = PusTmSecondaryHeader::new(8, DATA_REPLY, 0, 0, stamp_helper.stamp());
    let mut data = Vec::new();
    data.extend(apid_target.apid.to_be_bytes());
    data.extend(apid_target.unique_id.to_be_bytes());
    data.extend(reply_data);
-    debug!("{}", String::from_utf8(data.clone()[6..].to_vec()).expect("Error decoding data reply."));
-    let data_reply_tm = PusTmCreator::new(
-        sp_header,
-        sec_header,
-        &data,
-        true,
+    debug!(
+        "{}",
+        String::from_utf8(data.clone()[6..].to_vec()).expect("Error decoding data reply.")
    );
+    let data_reply_tm = PusTmCreator::new(sp_header, sec_header, &data, true);
    tm_sender.send_tm(apid_target.id(), PusTmVariant::Direct(data_reply_tm))
 }