implement reids review suggestions

scylla-server-rust/src/controllers/send_config_controller.rs → scylla-server-rust/src/controllers/car_command_controller.rs

@@ -9,13 +9,18 @@ use tracing::{info, warn};
 
 use crate::{command_data::CommandData, error::ScyllaError};
 
+/// the prefix for the calypso topic, so topic of cmd is this plus the key appended on
 pub const CALYPSO_BIDIR_CMD_PREFIX: &str = "Calypso/Bidir/Command/";
 
 #[derive(Deserialize, Debug)]
 pub struct ConfigRequest {
     pub data: Vec<f32>,
 }
 
+/// This controller recieves two peices of info: the key from the path, and the list of float values from the query params
+/// The key is used in accordance with the calypso specification: a command_data object is sent over siren to CALYPSO_BIDIR_CMD_PREFIX/<key>
+/// That command_data object is processed and matched via the key to a YAML specification for the encoding and sending of a CAN message
+/// TLDR: This triggers a command <key> with the values <data_query.0.data> for calypso to update the CAN packet sent to the bus.
 pub async fn send_config(
     Path(key): Path<String>,
     data_query: Query<ConfigRequest>,
@@ -25,16 +30,19 @@ pub async fn send_config(
         "Sending car config with key: {}, and values: {:?}",
         key, data_query.0.data
     );
+    // disable scylla if not prod, as there will be None mqtt client
     let Some(client) = client else {
         return Err(ScyllaError::NotProd);
     };
 
+    // create a payload object of the values to be parsed by calypso into a CAN packet
     let mut payload = CommandData::new();
     payload.data = data_query.0.data;
     let Ok(bytes) = payload.write_to_bytes() else {
         return Err(ScyllaError::ImpossibleEncoding);
     };
 
+    // publish the message to the topic that calypso's encoder is susbcribed to
     if let Err(err) = client
         .publish(
             format!("{}{}", CALYPSO_BIDIR_CMD_PREFIX, key),
@@ -47,5 +55,6 @@ pub async fn send_config(
         warn!("Could not publish instruction: {}", err);
         return Err(ScyllaError::CommFailure);
     }
+
     Ok(())
 }

scylla-server-rust/src/controllers/mod.rs

@@ -1,8 +1,8 @@
+pub mod car_command_controller;
 pub mod data_controller;
 pub mod data_type_controller;
 pub mod driver_controller;
 pub mod location_controller;
 pub mod node_controller;
 pub mod run_controller;
-pub mod send_config_controller;
 pub mod system_controller;

scylla-server-rust/src/main.rs

@@ -10,10 +10,10 @@ use prisma_client_rust::chrono;
 use rumqttc::v5::AsyncClient;
 use scylla_server_rust::{
     controllers::{
-        self, data_type_controller, driver_controller, location_controller, node_controller,
-        run_controller,
-        send_config_controller::{self},
-        system_controller,
+        self,
+        car_command_controller::{self},
+        data_type_controller, driver_controller, location_controller, node_controller,
+        run_controller, system_controller,
     },
     prisma::PrismaClient,
     processors::{
@@ -200,8 +200,8 @@ async fn main() {
         .route("/systems", get(system_controller::get_all_systems))
         // CONFIG
         .route(
-            "/config/:key",
-            post(send_config_controller::send_config).layer(Extension(client)),
+            "/config/set/:configKey",
+            post(car_command_controller::send_config).layer(Extension(client)),
         )
         // for CORS handling
         .layer(

scylla-server-rust/src/processors/mqtt_processor.rs

@@ -13,7 +13,7 @@ use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::{debug, instrument, trace, warn, Level};
 
 use crate::{
-    controllers::send_config_controller::CALYPSO_BIDIR_CMD_PREFIX, serverdata,
+    controllers::car_command_controller::CALYPSO_BIDIR_CMD_PREFIX, serverdata,
     services::run_service,
 };