From 5923ffa28cb0d360752b8aebd4f504c906f0addb Mon Sep 17 00:00:00 2001 From: Icedsoda <29167146+1cedsoda@users.noreply.github.com> Date: Thu, 17 Apr 2025 14:01:36 +0200 Subject: [PATCH] reduce `.unwrap()` usage --- control-core/src/identification/mod.rs | 24 +++++- control-core/src/machines/new.rs | 7 +- control-core/src/rest/mutation.rs | 8 -- control-core/src/socketio/event.rs | 24 +++--- control-core/src/socketio/namespace.rs | 2 +- docs/io.md | 10 ++- ethercat-hal/src/devices/el1008.rs | 17 ++-- ethercat-hal/src/devices/el2002.rs | 14 +++- ethercat-hal/src/devices/el2008.rs | 50 ++++++++---- ethercat-hal/src/devices/el2024.rs | 26 ++++-- ethercat-hal/src/devices/el2634.rs | 26 ++++-- ethercat-hal/src/devices/el2809.rs | 98 +++++++++++++++-------- ethercat-hal/src/devices/el3204.rs | 9 ++- server/src/ethercat/loop.rs | 2 +- server/src/machines/winder2/api.rs | 36 ++++++--- server/src/machines/winder2/mod.rs | 12 +-- server/src/main.rs | 2 +- server/src/rest/util.rs | 35 ++++++-- server/src/socketio/main_namespace/mod.rs | 18 ++++- 19 files changed, 280 insertions(+), 140 deletions(-) diff --git a/control-core/src/identification/mod.rs b/control-core/src/identification/mod.rs index aacbc7d2..104d93bf 100644 --- a/control-core/src/identification/mod.rs +++ b/control-core/src/identification/mod.rs @@ -187,20 +187,36 @@ pub async fn machine_device_identification<'maindevice>( vendor: subdevice .eeprom_read::(maindevice, addresses.vendor_word) .await - .unwrap(), + .or(Err(anyhow!( + "[{}::machine_device_identification] Failed to read vendor from EEPROM for device {}", + module_path!(), + subdevice.name() + )))?, serial: subdevice .eeprom_read::(maindevice, addresses.serial_word) .await - .unwrap(), + .or(Err(anyhow!( + "[{}::machine_device_identification] Failed to read serial from EEPROM for device {}", + module_path!(), + subdevice.name() + )))?, machine: subdevice .eeprom_read::(maindevice, addresses.machine_word) .await - .unwrap(), + .or(Err(anyhow!( + "[{}::machine_device_identification] Failed to read machine from EEPROM for device {}", + module_path!(), + subdevice.name() + )))?, }, role: subdevice .eeprom_read::(maindevice, addresses.role_word) .await - .unwrap(), + .or(Err(anyhow!( + "[{}::machine_device_identification] Failed to read role from EEPROM for device {}", + module_path!(), + subdevice.name() + )))?, subdevice_index: subdevice_index, }; diff --git a/control-core/src/machines/new.rs b/control-core/src/machines/new.rs index df041990..0ead7017 100644 --- a/control-core/src/machines/new.rs +++ b/control-core/src/machines/new.rs @@ -32,7 +32,12 @@ pub fn validate_same_machine_identification( ) -> Result<(), Error> { let machine_identification_unique = &identified_device_group .first() - .unwrap() + .ok_or_else(|| { + anyhow::anyhow!( + "[{}::validate_same_machine_identification] No devices in group", + module_path!() + ) + })? .machine_identification_unique; for device in identified_device_group.iter() { if device.machine_identification_unique != *machine_identification_unique { diff --git a/control-core/src/rest/mutation.rs b/control-core/src/rest/mutation.rs index 52fd0d1d..c3d6bbcd 100644 --- a/control-core/src/rest/mutation.rs +++ b/control-core/src/rest/mutation.rs @@ -1,4 +1,3 @@ -use axum::body::Body; use serde::Serialize; use crate::identification::MachineIdentificationUnique; @@ -24,13 +23,6 @@ impl MutationResponse { } } -impl From for Body { - fn from(mutation_response: MutationResponse) -> Self { - let body = serde_json::to_string(&mutation_response).unwrap(); - Body::from(body) - } -} - #[derive(Debug, serde::Deserialize)] pub struct MachineMutationBody { pub machine_identification_unique: MachineIdentificationUnique, diff --git a/control-core/src/socketio/event.rs b/control-core/src/socketio/event.rs index 5f3812c5..e6d6f14b 100644 --- a/control-core/src/socketio/event.rs +++ b/control-core/src/socketio/event.rs @@ -20,29 +20,33 @@ where pub ts: i64, } -impl From> for GenericEvent +impl TryFrom> for GenericEvent where T: Serialize, { - fn from(event: Event) -> Self { - Self { + type Error = serde_json::Error; + + fn try_from(event: Event) -> Result { + Ok(Self { name: event.name, - data: serde_json::to_value(event.data).unwrap(), + data: serde_json::to_value(event.data)?, ts: event.ts, - } + }) } } -impl From<&Event> for GenericEvent +impl TryFrom<&Event> for GenericEvent where T: Serialize, { - fn from(event: &Event) -> Self { - Self { + type Error = serde_json::Error; + + fn try_from(event: &Event) -> Result { + Ok(Self { name: event.name.clone(), - data: serde_json::to_value(&event.data).unwrap(), + data: serde_json::to_value(&event.data)?, ts: event.ts, - } + }) } } diff --git a/control-core/src/socketio/namespace.rs b/control-core/src/socketio/namespace.rs index dce34baa..91d4c461 100644 --- a/control-core/src/socketio/namespace.rs +++ b/control-core/src/socketio/namespace.rs @@ -147,7 +147,7 @@ where } pub trait CacheableEvents { - fn event_value(&self) -> GenericEvent; + fn event_value(&self) -> Result; fn event_cache_fn(&self) -> CacheFn; } diff --git a/docs/io.md b/docs/io.md index 4c6fd47e..d3920e39 100644 --- a/docs/io.md +++ b/docs/io.md @@ -42,17 +42,19 @@ The `digital_output_state` is used to read the current state of the output of a ```rust impl DigitalOutputDevice for EL2002 { fn digital_output_write(&mut self, port: EL2002Port, value: DigitalOutputOutput) { + let expect_text = "All channels should be Some(_)"; match port { - EL2002Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(), - EL2002Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(), + EL2002Port::DO1 => self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into(), + EL2002Port::DO2 => self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into(), } } fn digital_output_state(&self, port: EL2002Port) -> DigitalOutputState { + let expect_text = "All channels should be Some(_)"; DigitalOutputState { output: DigitalOutputOutput(match port { - EL2002Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value, - EL2002Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value, + EL2002Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value, + EL2002Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value, }), } } diff --git a/ethercat-hal/src/devices/el1008.rs b/ethercat-hal/src/devices/el1008.rs index 4107591b..05c64799 100644 --- a/ethercat-hal/src/devices/el1008.rs +++ b/ethercat-hal/src/devices/el1008.rs @@ -28,17 +28,18 @@ impl NewDevice for EL1008 { impl DigitalInputDevice for EL1008 { fn digital_input_state(&self, port: EL1008Port) -> DigitalInputState { + let expect_text = "All channels should be Some(_)"; DigitalInputState { input: DigitalInputInput { value: match port { - EL1008Port::DI1 => self.txpdo.channel1.as_ref().unwrap().value, - EL1008Port::DI2 => self.txpdo.channel2.as_ref().unwrap().value, - EL1008Port::DI3 => self.txpdo.channel3.as_ref().unwrap().value, - EL1008Port::DI4 => self.txpdo.channel4.as_ref().unwrap().value, - EL1008Port::DI5 => self.txpdo.channel5.as_ref().unwrap().value, - EL1008Port::DI6 => self.txpdo.channel6.as_ref().unwrap().value, - EL1008Port::DI7 => self.txpdo.channel7.as_ref().unwrap().value, - EL1008Port::DI8 => self.txpdo.channel8.as_ref().unwrap().value, + EL1008Port::DI1 => self.txpdo.channel1.as_ref().expect(&expect_text).value, + EL1008Port::DI2 => self.txpdo.channel2.as_ref().expect(&expect_text).value, + EL1008Port::DI3 => self.txpdo.channel3.as_ref().expect(&expect_text).value, + EL1008Port::DI4 => self.txpdo.channel4.as_ref().expect(&expect_text).value, + EL1008Port::DI5 => self.txpdo.channel5.as_ref().expect(&expect_text).value, + EL1008Port::DI6 => self.txpdo.channel6.as_ref().expect(&expect_text).value, + EL1008Port::DI7 => self.txpdo.channel7.as_ref().expect(&expect_text).value, + EL1008Port::DI8 => self.txpdo.channel8.as_ref().expect(&expect_text).value, }, }, } diff --git a/ethercat-hal/src/devices/el2002.rs b/ethercat-hal/src/devices/el2002.rs index 72b57eac..3685c857 100644 --- a/ethercat-hal/src/devices/el2002.rs +++ b/ethercat-hal/src/devices/el2002.rs @@ -28,17 +28,23 @@ impl NewDevice for EL2002 { impl DigitalOutputDevice for EL2002 { fn digital_output_write(&mut self, port: EL2002Port, value: DigitalOutputOutput) { + let expect_text = "All channels should be Some(_)"; match port { - EL2002Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(), - EL2002Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(), + EL2002Port::DO1 => { + self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into() + } + EL2002Port::DO2 => { + self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into() + } } } fn digital_output_state(&self, port: EL2002Port) -> DigitalOutputState { + let expect_text = "All channels should be Some(_)"; DigitalOutputState { output: DigitalOutputOutput(match port { - EL2002Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value, - EL2002Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value, + EL2002Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value, + EL2002Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value, }), } } diff --git a/ethercat-hal/src/devices/el2008.rs b/ethercat-hal/src/devices/el2008.rs index 1f561551..00bffdcf 100644 --- a/ethercat-hal/src/devices/el2008.rs +++ b/ethercat-hal/src/devices/el2008.rs @@ -28,29 +28,47 @@ impl NewDevice for EL2008 { impl DigitalOutputDevice for EL2008 { fn digital_output_write(&mut self, port: EL2008Port, value: DigitalOutputOutput) { + let expect_text = "All channels should be Some(_)"; match port { - EL2008Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(), - EL2008Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(), - EL2008Port::DO3 => self.rxpdo.channel3.as_mut().unwrap().value = value.into(), - EL2008Port::DO4 => self.rxpdo.channel4.as_mut().unwrap().value = value.into(), - EL2008Port::DO5 => self.rxpdo.channel5.as_mut().unwrap().value = value.into(), - EL2008Port::DO6 => self.rxpdo.channel6.as_mut().unwrap().value = value.into(), - EL2008Port::DO7 => self.rxpdo.channel7.as_mut().unwrap().value = value.into(), - EL2008Port::DO8 => self.rxpdo.channel8.as_mut().unwrap().value = value.into(), + EL2008Port::DO1 => { + self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into() + } + EL2008Port::DO2 => { + self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into() + } + EL2008Port::DO3 => { + self.rxpdo.channel3.as_mut().expect(&expect_text).value = value.into() + } + EL2008Port::DO4 => { + self.rxpdo.channel4.as_mut().expect(&expect_text).value = value.into() + } + EL2008Port::DO5 => { + self.rxpdo.channel5.as_mut().expect(&expect_text).value = value.into() + } + EL2008Port::DO6 => { + self.rxpdo.channel6.as_mut().expect(&expect_text).value = value.into() + } + EL2008Port::DO7 => { + self.rxpdo.channel7.as_mut().expect(&expect_text).value = value.into() + } + EL2008Port::DO8 => { + self.rxpdo.channel8.as_mut().expect(&expect_text).value = value.into() + } } } fn digital_output_state(&self, port: EL2008Port) -> DigitalOutputState { + let expect_text = "All channels should be Some(_)"; DigitalOutputState { output: DigitalOutputOutput(match port { - EL2008Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value, - EL2008Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value, - EL2008Port::DO3 => self.rxpdo.channel3.as_ref().unwrap().value, - EL2008Port::DO4 => self.rxpdo.channel4.as_ref().unwrap().value, - EL2008Port::DO5 => self.rxpdo.channel5.as_ref().unwrap().value, - EL2008Port::DO6 => self.rxpdo.channel6.as_ref().unwrap().value, - EL2008Port::DO7 => self.rxpdo.channel7.as_ref().unwrap().value, - EL2008Port::DO8 => self.rxpdo.channel8.as_ref().unwrap().value, + EL2008Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value, + EL2008Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value, + EL2008Port::DO3 => self.rxpdo.channel3.as_ref().expect(&expect_text).value, + EL2008Port::DO4 => self.rxpdo.channel4.as_ref().expect(&expect_text).value, + EL2008Port::DO5 => self.rxpdo.channel5.as_ref().expect(&expect_text).value, + EL2008Port::DO6 => self.rxpdo.channel6.as_ref().expect(&expect_text).value, + EL2008Port::DO7 => self.rxpdo.channel7.as_ref().expect(&expect_text).value, + EL2008Port::DO8 => self.rxpdo.channel8.as_ref().expect(&expect_text).value, }), } } diff --git a/ethercat-hal/src/devices/el2024.rs b/ethercat-hal/src/devices/el2024.rs index b6137ed0..d1cfa767 100644 --- a/ethercat-hal/src/devices/el2024.rs +++ b/ethercat-hal/src/devices/el2024.rs @@ -29,21 +29,31 @@ impl NewDevice for EL2024 { impl DigitalOutputDevice for EL2024 { fn digital_output_write(&mut self, port: EL2024Port, value: DigitalOutputOutput) { + let expect_text = "All channels should be Some(_)"; match port { - EL2024Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(), - EL2024Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(), - EL2024Port::DO3 => self.rxpdo.channel3.as_mut().unwrap().value = value.into(), - EL2024Port::DO4 => self.rxpdo.channel4.as_mut().unwrap().value = value.into(), + EL2024Port::DO1 => { + self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into() + } + EL2024Port::DO2 => { + self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into() + } + EL2024Port::DO3 => { + self.rxpdo.channel3.as_mut().expect(&expect_text).value = value.into() + } + EL2024Port::DO4 => { + self.rxpdo.channel4.as_mut().expect(&expect_text).value = value.into() + } } } fn digital_output_state(&self, port: EL2024Port) -> DigitalOutputState { + let expect_text = "All channels should be Some(_)"; DigitalOutputState { output: DigitalOutputOutput(match port { - EL2024Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value, - EL2024Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value, - EL2024Port::DO3 => self.rxpdo.channel3.as_ref().unwrap().value, - EL2024Port::DO4 => self.rxpdo.channel4.as_ref().unwrap().value, + EL2024Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value, + EL2024Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value, + EL2024Port::DO3 => self.rxpdo.channel3.as_ref().expect(&expect_text).value, + EL2024Port::DO4 => self.rxpdo.channel4.as_ref().expect(&expect_text).value, }), } } diff --git a/ethercat-hal/src/devices/el2634.rs b/ethercat-hal/src/devices/el2634.rs index 7ff563f7..240f24f2 100644 --- a/ethercat-hal/src/devices/el2634.rs +++ b/ethercat-hal/src/devices/el2634.rs @@ -29,21 +29,31 @@ impl NewDevice for EL2634 { impl DigitalOutputDevice for EL2634 { fn digital_output_write(&mut self, port: EL2634Port, value: DigitalOutputOutput) { + let expect_text = "All channels should be Some(_)"; match port { - EL2634Port::R1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(), - EL2634Port::R2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(), - EL2634Port::R3 => self.rxpdo.channel3.as_mut().unwrap().value = value.into(), - EL2634Port::R4 => self.rxpdo.channel4.as_mut().unwrap().value = value.into(), + EL2634Port::R1 => { + self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into() + } + EL2634Port::R2 => { + self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into() + } + EL2634Port::R3 => { + self.rxpdo.channel3.as_mut().expect(&expect_text).value = value.into() + } + EL2634Port::R4 => { + self.rxpdo.channel4.as_mut().expect(&expect_text).value = value.into() + } } } fn digital_output_state(&self, port: EL2634Port) -> DigitalOutputState { + let expect_text = "All channels should be Some(_)"; DigitalOutputState { output: DigitalOutputOutput(match port { - EL2634Port::R1 => self.rxpdo.channel1.as_ref().unwrap().value, - EL2634Port::R2 => self.rxpdo.channel2.as_ref().unwrap().value, - EL2634Port::R3 => self.rxpdo.channel3.as_ref().unwrap().value, - EL2634Port::R4 => self.rxpdo.channel4.as_ref().unwrap().value, + EL2634Port::R1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value, + EL2634Port::R2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value, + EL2634Port::R3 => self.rxpdo.channel3.as_ref().expect(&expect_text).value, + EL2634Port::R4 => self.rxpdo.channel4.as_ref().expect(&expect_text).value, }), } } diff --git a/ethercat-hal/src/devices/el2809.rs b/ethercat-hal/src/devices/el2809.rs index 3d7f6f3f..a3037d3b 100644 --- a/ethercat-hal/src/devices/el2809.rs +++ b/ethercat-hal/src/devices/el2809.rs @@ -29,45 +29,79 @@ impl NewDevice for EL2809 { impl DigitalOutputDevice for EL2809 { fn digital_output_write(&mut self, port: EL2809Port, value: DigitalOutputOutput) { + let expect_text = "All channels should be Some(_)"; match port { - EL2809Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(), - EL2809Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(), - EL2809Port::DO3 => self.rxpdo.channel3.as_mut().unwrap().value = value.into(), - EL2809Port::DO4 => self.rxpdo.channel4.as_mut().unwrap().value = value.into(), - EL2809Port::DO5 => self.rxpdo.channel5.as_mut().unwrap().value = value.into(), - EL2809Port::DO6 => self.rxpdo.channel6.as_mut().unwrap().value = value.into(), - EL2809Port::DO7 => self.rxpdo.channel7.as_mut().unwrap().value = value.into(), - EL2809Port::DO8 => self.rxpdo.channel8.as_mut().unwrap().value = value.into(), - EL2809Port::DO9 => self.rxpdo.channel9.as_mut().unwrap().value = value.into(), - EL2809Port::DO10 => self.rxpdo.channel10.as_mut().unwrap().value = value.into(), - EL2809Port::DO11 => self.rxpdo.channel11.as_mut().unwrap().value = value.into(), - EL2809Port::DO12 => self.rxpdo.channel12.as_mut().unwrap().value = value.into(), - EL2809Port::DO13 => self.rxpdo.channel13.as_mut().unwrap().value = value.into(), - EL2809Port::DO14 => self.rxpdo.channel14.as_mut().unwrap().value = value.into(), - EL2809Port::DO15 => self.rxpdo.channel15.as_mut().unwrap().value = value.into(), - EL2809Port::DO16 => self.rxpdo.channel16.as_mut().unwrap().value = value.into(), + EL2809Port::DO1 => { + self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO2 => { + self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO3 => { + self.rxpdo.channel3.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO4 => { + self.rxpdo.channel4.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO5 => { + self.rxpdo.channel5.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO6 => { + self.rxpdo.channel6.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO7 => { + self.rxpdo.channel7.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO8 => { + self.rxpdo.channel8.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO9 => { + self.rxpdo.channel9.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO10 => { + self.rxpdo.channel10.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO11 => { + self.rxpdo.channel11.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO12 => { + self.rxpdo.channel12.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO13 => { + self.rxpdo.channel13.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO14 => { + self.rxpdo.channel14.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO15 => { + self.rxpdo.channel15.as_mut().expect(&expect_text).value = value.into() + } + EL2809Port::DO16 => { + self.rxpdo.channel16.as_mut().expect(&expect_text).value = value.into() + } } } fn digital_output_state(&self, port: EL2809Port) -> DigitalOutputState { + let expect_text = "All channels should be Some(_)"; DigitalOutputState { output: DigitalOutputOutput(match port { - EL2809Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value, - EL2809Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value, - EL2809Port::DO3 => self.rxpdo.channel3.as_ref().unwrap().value, - EL2809Port::DO4 => self.rxpdo.channel4.as_ref().unwrap().value, - EL2809Port::DO5 => self.rxpdo.channel5.as_ref().unwrap().value, - EL2809Port::DO6 => self.rxpdo.channel6.as_ref().unwrap().value, - EL2809Port::DO7 => self.rxpdo.channel7.as_ref().unwrap().value, - EL2809Port::DO8 => self.rxpdo.channel8.as_ref().unwrap().value, - EL2809Port::DO9 => self.rxpdo.channel9.as_ref().unwrap().value, - EL2809Port::DO10 => self.rxpdo.channel10.as_ref().unwrap().value, - EL2809Port::DO11 => self.rxpdo.channel11.as_ref().unwrap().value, - EL2809Port::DO12 => self.rxpdo.channel12.as_ref().unwrap().value, - EL2809Port::DO13 => self.rxpdo.channel13.as_ref().unwrap().value, - EL2809Port::DO14 => self.rxpdo.channel14.as_ref().unwrap().value, - EL2809Port::DO15 => self.rxpdo.channel15.as_ref().unwrap().value, - EL2809Port::DO16 => self.rxpdo.channel16.as_ref().unwrap().value, + EL2809Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value, + EL2809Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value, + EL2809Port::DO3 => self.rxpdo.channel3.as_ref().expect(&expect_text).value, + EL2809Port::DO4 => self.rxpdo.channel4.as_ref().expect(&expect_text).value, + EL2809Port::DO5 => self.rxpdo.channel5.as_ref().expect(&expect_text).value, + EL2809Port::DO6 => self.rxpdo.channel6.as_ref().expect(&expect_text).value, + EL2809Port::DO7 => self.rxpdo.channel7.as_ref().expect(&expect_text).value, + EL2809Port::DO8 => self.rxpdo.channel8.as_ref().expect(&expect_text).value, + EL2809Port::DO9 => self.rxpdo.channel9.as_ref().expect(&expect_text).value, + EL2809Port::DO10 => self.rxpdo.channel10.as_ref().expect(&expect_text).value, + EL2809Port::DO11 => self.rxpdo.channel11.as_ref().expect(&expect_text).value, + EL2809Port::DO12 => self.rxpdo.channel12.as_ref().expect(&expect_text).value, + EL2809Port::DO13 => self.rxpdo.channel13.as_ref().expect(&expect_text).value, + EL2809Port::DO14 => self.rxpdo.channel14.as_ref().expect(&expect_text).value, + EL2809Port::DO15 => self.rxpdo.channel15.as_ref().expect(&expect_text).value, + EL2809Port::DO16 => self.rxpdo.channel16.as_ref().expect(&expect_text).value, }), } } diff --git a/ethercat-hal/src/devices/el3204.rs b/ethercat-hal/src/devices/el3204.rs index 55381c24..fd82b5c1 100644 --- a/ethercat-hal/src/devices/el3204.rs +++ b/ethercat-hal/src/devices/el3204.rs @@ -32,11 +32,12 @@ impl NewDevice for EL3204 { impl TemperatureInputDevice for EL3204 { fn temperature_input_state(&self, port: EL3204Port) -> TemperatureInputState { + let expect_text = "All channels should be Some(_)"; let channel = match port { - EL3204Port::T1 => self.txpdo.channel1.as_ref().unwrap(), - EL3204Port::T2 => self.txpdo.channel2.as_ref().unwrap(), - EL3204Port::T3 => self.txpdo.channel3.as_ref().unwrap(), - EL3204Port::T4 => self.txpdo.channel4.as_ref().unwrap(), + EL3204Port::T1 => self.txpdo.channel1.as_ref().expect(&expect_text), + EL3204Port::T2 => self.txpdo.channel2.as_ref().expect(&expect_text), + EL3204Port::T3 => self.txpdo.channel3.as_ref().expect(&expect_text), + EL3204Port::T4 => self.txpdo.channel4.as_ref().expect(&expect_text), }; TemperatureInputState { input: TemperatureInputInput { diff --git a/server/src/ethercat/loop.rs b/server/src/ethercat/loop.rs index 8fca6d48..a0365498 100644 --- a/server/src/ethercat/loop.rs +++ b/server/src/ethercat/loop.rs @@ -105,7 +105,7 @@ pub async fn setup_loop( machines.insert( identified_device_group .first() - .unwrap() + .expect("There should always be a first device") .machine_identification_unique .clone(), machine, diff --git a/server/src/machines/winder2/api.rs b/server/src/machines/winder2/api.rs index 819d451e..e1b23f4a 100644 --- a/server/src/machines/winder2/api.rs +++ b/server/src/machines/winder2/api.rs @@ -272,7 +272,17 @@ pub struct Winder1Namespace(Namespace); impl NamespaceCacheingLogic for Winder1Namespace { fn emit_cached(&mut self, events: Winder1Events) { - let event = events.event_value(); + let event = match events.event_value() { + Ok(event) => event, + Err(err) => { + log::error!( + "[{}::emit_cached] Failed to event.event_value(): {:?}", + module_path!(), + err + ); + return; + } + }; let buffer_fn = events.event_cache_fn(); self.0.emit_cached(&event, buffer_fn); } @@ -285,19 +295,19 @@ impl Winder1Namespace { } impl CacheableEvents for Winder1Events { - fn event_value(&self) -> GenericEvent { + fn event_value(&self) -> Result { match self { - Winder1Events::TraversePosition(event) => event.into(), - Winder1Events::TraverseState(event) => event.into(), - Winder1Events::PullerSpeed(event) => event.into(), - Winder1Events::PullerState(event) => event.into(), - Winder1Events::AutostopWoundedlength(event) => event.into(), - Winder1Events::AutostopState(event) => event.into(), - Winder1Events::Mode(event) => event.into(), - Winder1Events::SpoolRpm(event) => event.into(), - Winder1Events::SpoolState(event) => event.into(), - Winder1Events::TensionArmAngleEvent(event) => event.into(), - Winder1Events::TensionArmStateEvent(event) => event.into(), + Winder1Events::TraversePosition(event) => event.try_into(), + Winder1Events::TraverseState(event) => event.try_into(), + Winder1Events::PullerSpeed(event) => event.try_into(), + Winder1Events::PullerState(event) => event.try_into(), + Winder1Events::AutostopWoundedlength(event) => event.try_into(), + Winder1Events::AutostopState(event) => event.try_into(), + Winder1Events::Mode(event) => event.try_into(), + Winder1Events::SpoolRpm(event) => event.try_into(), + Winder1Events::SpoolState(event) => event.try_into(), + Winder1Events::TensionArmAngleEvent(event) => event.try_into(), + Winder1Events::TensionArmStateEvent(event) => event.try_into(), } } diff --git a/server/src/machines/winder2/mod.rs b/server/src/machines/winder2/mod.rs index 46a8e94a..beae946b 100644 --- a/server/src/machines/winder2/mod.rs +++ b/server/src/machines/winder2/mod.rs @@ -62,7 +62,7 @@ impl Winder2 { } .build(); self.namespace - .emit_cached(Winder1Events::TraverseState(event)); + .emit_cached(Winder1Events::TraverseState(event)) } } @@ -107,7 +107,7 @@ impl Winder2 { mode: self.mode.clone().into(), } .build(); - self.namespace.emit_cached(Winder1Events::Mode(event)); + self.namespace.emit_cached(Winder1Events::Mode(event)) } } @@ -131,7 +131,7 @@ impl Winder2 { } .build(); self.namespace - .emit_cached(Winder1Events::TensionArmAngleEvent(event)); + .emit_cached(Winder1Events::TensionArmAngleEvent(event)) } fn emit_tension_arm_state(&mut self) { @@ -140,7 +140,7 @@ impl Winder2 { } .build(); self.namespace - .emit_cached(Winder1Events::TensionArmStateEvent(event)); + .emit_cached(Winder1Events::TensionArmStateEvent(event)) } } @@ -162,7 +162,7 @@ impl Winder2 { .steps_to_angular_velocity(self.spool.get_speed() as f64) .get::(); let event = api::SpoolRpmEvent { rpm }.build(); - self.namespace.emit_cached(Winder1Events::SpoolRpm(event)); + self.namespace.emit_cached(Winder1Events::SpoolRpm(event)) } fn emit_spool_state(&mut self) { @@ -171,7 +171,7 @@ impl Winder2 { speed_max: self.spool_speed_controller.get_max_speed(), } .build(); - self.namespace.emit_cached(Winder1Events::SpoolState(event)); + self.namespace.emit_cached(Winder1Events::SpoolState(event)) } } diff --git a/server/src/main.rs b/server/src/main.rs index e938a427..d0ec2b2d 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -13,7 +13,7 @@ pub mod socketio; fn main() { env_logger::Builder::from_env(Env::default().default_filter_or("info")).init(); - let rt = tokio::runtime::Runtime::new().unwrap(); + let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime"); let socketio_layer = rt.block_on(init_socketio()); rt.spawn(async { init_api(APP_STATE.clone(), socketio_layer) diff --git a/server/src/rest/util.rs b/server/src/rest/util.rs index ab25bd42..2990ea38 100644 --- a/server/src/rest/util.rs +++ b/server/src/rest/util.rs @@ -8,30 +8,51 @@ pub struct ResponseUtil {} impl ResponseUtil { pub fn error(message: &str) -> Response { + let json = match serde_json::to_string(&json!({ "error": message })) { + Ok(json) => json, + Err(e) => { + log::error!("Failed to serialize error message: {}", e); + return Response::builder() + .status(StatusCode::INTERNAL_SERVER_ERROR) + .body(Body::empty()) + .unwrap(); + } + }; Response::builder() .status(StatusCode::INTERNAL_SERVER_ERROR) .header("Content-Type", "application/json") - .body(Body::from( - serde_json::to_string(&json!({ "error": message })).unwrap(), - )) + .body(Body::from(json)) .unwrap() } pub fn ok(data: T) -> Response { + let json = match serde_json::to_string(&data) { + Ok(json) => json, + Err(e) => { + log::error!("Failed to serialize response data: {}", e); + return ResponseUtil::error("Failed to serialize response data"); + } + }; + Response::builder() .status(StatusCode::OK) .header("Content-Type", "application/json") - .body(Body::from(serde_json::to_string(&data).unwrap())) + .body(Body::from(json)) .unwrap() } pub fn not_found(message: &str) -> Response { + let json = match serde_json::to_string(&json!({ "error": message })) { + Ok(json) => json, + Err(e) => { + log::error!("Failed to serialize not found message: {}", e); + return ResponseUtil::error("Failed to serialize not found message"); + } + }; Response::builder() .status(StatusCode::NOT_FOUND) .header("Content-Type", "application/json") - .body(Body::from( - serde_json::to_string(&json!({ "error": message })).unwrap(), - )) + .body(Body::from(json)) .unwrap() } } diff --git a/server/src/socketio/main_namespace/mod.rs b/server/src/socketio/main_namespace/mod.rs index a2581636..387fd422 100644 --- a/server/src/socketio/main_namespace/mod.rs +++ b/server/src/socketio/main_namespace/mod.rs @@ -26,7 +26,17 @@ where fn emit_cached(&mut self, event: MainNamespaceEvents) { println!("Emitting event: {:?}", event); let buffer_fn = event.event_cache_fn(); - let generic_event = event.event_value(); + let generic_event = match event.event_value() { + Ok(event) => event, + Err(err) => { + log::error!( + "[{}::emit_cached] Failed to event.event_value(): {:?}", + module_path!(), + err + ); + return; + } + }; self.0.emit_cached(&generic_event, buffer_fn); } } @@ -38,10 +48,10 @@ pub enum MainNamespaceEvents { } impl CacheableEvents for MainNamespaceEvents { - fn event_value(&self) -> GenericEvent { + fn event_value(&self) -> Result { match self { - MainNamespaceEvents::EthercatSetupEvent(event) => event.clone().into(), - MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event) => event.clone().into(), + MainNamespaceEvents::EthercatSetupEvent(event) => event.clone().try_into(), + MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event) => event.clone().try_into(), } }