system: remove all unwraps from system.rs

Signed-off-by: Leonard Göhrs <[email protected]>

Author: hnez

src/main.rs

@@ -114,7 +114,7 @@ async fn init(screenshooter: ScreenShooter) -> Result<(Ui, WatchedTasksBuilder)>
 
     // Expose information about the system provided by the kernel via the
     // broker framework.
-    let system = System::new(&mut bb, hardware_generation);
+    let system = System::new(&mut bb, hardware_generation)?;
 
     // Make sure the ADC and power switching threads of the tacd are not
     // stalled for too long by providing watchdog events to systemd

src/system.rs

@@ -15,7 +15,9 @@
 // with this program; if not, write to the Free Software Foundation, Inc.,
 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-use anyhow::{bail, Result};
+use std::ffi::OsStr;
+
+use anyhow::{anyhow, bail, Result};
 use async_std::sync::Arc;
 use nix::sys::utsname::uname;
 use serde::{Deserialize, Serialize};
@@ -24,6 +26,8 @@ use crate::broker::{BrokerBuilder, Topic};
 
 #[cfg(feature = "demo_mode")]
 mod read_dt_props {
+    use anyhow::{anyhow, Result};
+
     const DEMO_DATA_STR: &[(&str, &str)] = &[
         (
             "compatible",
@@ -53,14 +57,22 @@ mod read_dt_props {
         ),
     ];
 
-    pub fn read_dt_property(path: &str) -> String {
-        let (_, content) = DEMO_DATA_STR.iter().find(|(p, _)| *p == path).unwrap();
+    pub fn read_dt_property(path: &str) -> Result<String> {
+        let (_, content) = DEMO_DATA_STR
+            .iter()
+            .find(|(p, _)| *p == path)
+            .ok_or_else(|| anyhow!("could not find devicetree property {path}"))?;
 
-        content.to_string()
+        Ok(content.to_string())
     }
 
-    pub fn read_dt_property_u32(path: &str) -> u32 {
-        DEMO_DATA_NUM.iter().find(|(p, _)| *p == path).unwrap().1
+    pub fn read_dt_property_u32(path: &str) -> Result<u32> {
+        let (_, content) = DEMO_DATA_NUM
+            .iter()
+            .find(|(p, _)| *p == path)
+            .ok_or_else(|| anyhow!("could not find devicetree property {path}"))?;
+
+        Ok(*content)
     }
 }
 
@@ -69,17 +81,26 @@ mod read_dt_props {
     use std::fs::read;
     use std::str::from_utf8;
 
+    use anyhow::{anyhow, Result};
+
     const DT_BASE: &str = "/sys/firmware/devicetree/base/";
 
-    pub fn read_dt_property(path: &str) -> String {
-        let bytes = read([DT_BASE, path].join("/")).unwrap();
-        from_utf8(bytes.strip_suffix(&[0]).unwrap())
-            .unwrap()
-            .to_string()
+    pub fn read_dt_property(path: &str) -> Result<String> {
+        let path = [DT_BASE, path].join("/");
+        let bytes = read(&path)?;
+        let stripped_bytes = bytes
+            .strip_suffix(&[0])
+            .ok_or_else(|| anyhow!("Devicetree property {path} did not contain a value"))?;
+        let stripped = from_utf8(stripped_bytes)?;
+
+        Ok(stripped.to_string())
     }
 
-    pub fn read_dt_property_u32(path: &str) -> u32 {
-        read_dt_property(path).parse().unwrap()
+    pub fn read_dt_property_u32(path: &str) -> Result<u32> {
+        let raw = read_dt_property(path)?;
+        let value = raw.parse()?;
+
+        Ok(value)
     }
 }
 
@@ -95,16 +116,25 @@ pub struct Uname {
 }
 
 impl Uname {
-    fn get() -> Self {
-        let uts = uname().unwrap();
-
-        Self {
-            sysname: uts.sysname().to_str().unwrap().to_string(),
-            nodename: uts.nodename().to_str().unwrap().to_string(),
-            release: uts.release().to_str().unwrap().to_string(),
-            version: uts.version().to_str().unwrap().to_string(),
-            machine: uts.machine().to_str().unwrap().to_string(),
+    fn get() -> Result<Self> {
+        let uts = uname()?;
+
+        fn to_string(val: &OsStr, name: &str) -> Result<String> {
+            let res = val
+                .to_str()
+                .ok_or_else(|| anyhow!("uname entry {name} can not be converted to utf-8"))?
+                .to_string();
+
+            Ok(res)
         }
+
+        Ok(Self {
+            sysname: to_string(uts.sysname(), "sysname")?,
+            nodename: to_string(uts.nodename(), "nodename")?,
+            release: to_string(uts.release(), "release")?,
+            version: to_string(uts.version(), "version")?,
+            machine: to_string(uts.machine(), "machine")?,
+        })
     }
 }
 
@@ -118,31 +148,31 @@ pub struct Barebox {
 }
 
 impl Barebox {
-    fn get() -> Self {
+    fn get() -> Result<Self> {
         // Get info from devicetree chosen
-        Self {
-            version: read_dt_property("chosen/barebox-version"),
+        Ok(Self {
+            version: read_dt_property("chosen/barebox-version")?,
             baseboard_release: {
                 let template =
-                    read_dt_property("chosen/baseboard-factory-data/pcba-hardware-release");
-                let changeset = read_dt_property_u32("chosen/baseboard-factory-data/modification");
-
+                    read_dt_property("chosen/baseboard-factory-data/pcba-hardware-release")?;
+                let changeset = read_dt_property_u32("chosen/baseboard-factory-data/modification")?;
                 template.replace("-C??", &format!("-C{changeset:02}"))
             },
             powerboard_release: {
                 let template =
-                    read_dt_property("chosen/powerboard-factory-data/pcba-hardware-release");
-                let changeset = read_dt_property_u32("chosen/powerboard-factory-data/modification");
+                    read_dt_property("chosen/powerboard-factory-data/pcba-hardware-release")?;
+                let changeset =
+                    read_dt_property_u32("chosen/powerboard-factory-data/modification")?;
 
                 template.replace("-C??", &format!("-C{changeset:02}"))
             },
             baseboard_timestamp: {
-                read_dt_property_u32("chosen/baseboard-factory-data/factory-timestamp")
+                read_dt_property_u32("chosen/baseboard-factory-data/factory-timestamp")?
             },
             powerboard_timestamp: {
-                read_dt_property_u32("chosen/powerboard-factory-data/factory-timestamp")
+                read_dt_property_u32("chosen/powerboard-factory-data/factory-timestamp")?
             },
-        }
+        })
     }
 }
 
@@ -155,7 +185,7 @@ pub enum HardwareGeneration {
 
 impl HardwareGeneration {
     pub fn get() -> Result<Self> {
-        let compatible = read_dt_property("compatible");
+        let compatible = read_dt_property("compatible")?;
 
         // The compatible property consists of strings separated by NUL bytes.
         // We are interested in the first of these strings.
@@ -182,17 +212,20 @@ pub struct System {
 }
 
 impl System {
-    pub fn new(bb: &mut BrokerBuilder, hardware_generation: HardwareGeneration) -> Self {
+    pub fn new(bb: &mut BrokerBuilder, hardware_generation: HardwareGeneration) -> Result<Self> {
         let version = env!("VERSION_STRING").to_string();
 
-        Self {
-            uname: bb.topic_ro("/v1/tac/info/uname", Some(Arc::new(Uname::get()))),
-            barebox: bb.topic_ro("/v1/tac/info/bootloader", Some(Arc::new(Barebox::get()))),
+        let uname = Uname::get()?;
+        let barebox = Barebox::get()?;
+
+        Ok(Self {
+            uname: bb.topic_ro("/v1/tac/info/uname", Some(Arc::new(uname))),
+            barebox: bb.topic_ro("/v1/tac/info/bootloader", Some(Arc::new(barebox))),
             tacd_version: bb.topic_ro("/v1/tac/info/tacd/version", Some(version)),
             hardware_generation: bb.topic_ro(
                 "/v1/tac/info/hardware_generation",
                 Some(hardware_generation),
             ),
-        }
+        })
     }
 }