refactor(Device): Add error propagation and remove .unwraps() where applicable

tkornack · web-flow · commit c8f9d022f475 · 2025-07-30T13:09:53.000-04:00
diff --git a/twinleaf-tools/src/bin/tio-monitor.rs b/twinleaf-tools/src/bin/tio-monitor.rs
@@ -215,17 +215,16 @@ fn main() {
     };
 
     let proxy = tio::proxy::Interface::new(&root);
-    let mut device = twinleaf::Device::open(&proxy, route);
+    let mut device = twinleaf::Device::open(&proxy, route)
+        .expect("Failed to open device. Check connection and permissions.");
 
     let mut stdout = std::io::stdout();
-    if let Ok(()) = terminal_setup(&stdout) {
-        std::panic::set_hook(Box::new(|_| {
-            terminal_teardown(&std::io::stdout());
-        }));
-    } else {
-        terminal_teardown(&stdout);
-        return;
-    }
+    terminal_setup(&stdout).expect("Failed to setup terminal");
+    let original_hook = std::panic::take_hook();
+    std::panic::set_hook(Box::new(move |panic_info| {
+        terminal_teardown(&std::io::stdout());
+        original_hook(panic_info);
+    }));
 
     let mut wait_until = Instant::now();
     let mut width: usize = 0;
@@ -237,37 +236,37 @@ fn main() {
         std::thread::sleep(sleep_time);
         wait_until = now + sleep_time + Duration::from_millis(50);
 
-        loop {
-            use crossterm::event::*;
-            match poll(Duration::from_secs(0)) {
-                Ok(false) => {
-                    break;
-                }
-                Ok(true) => match read() {
-                    Ok(Event::Key(key_event)) => {
-                        if key_event.code == KeyCode::Char('q')
-                            || key_event.code == KeyCode::Esc
-                            || (key_event.code == KeyCode::Char('c')
-                                && key_event.modifiers == KeyModifiers::CONTROL)
-                        {
-                            break 'drawing;
-                        }
-                    }
-                    Ok(_) => {}
-                    Err(_) => {
+        if crossterm::event::poll(Duration::from_secs(0)).unwrap_or(false) {
+            match crossterm::event::read() {
+                Ok(crossterm::event::Event::Key(key)) => {
+                    use crossterm::event::{KeyCode, KeyModifiers};
+                    if key.code == KeyCode::Char('q')
+                        || key.code == KeyCode::Esc
+                        || (key.code == KeyCode::Char('c') && key.modifiers == KeyModifiers::CONTROL)
+                    {
                         break 'drawing;
                     }
-                },
-                Err(_) => {
-                    break 'drawing;
                 }
+                Err(_) => break 'drawing,
+                _ => {}
             }
         }
 
         let mut recompute_width = false;
-        while let Some(sample) = device.try_next() {
-            recompute_width = recompute_width || sample.meta_changed;
-            last_sample.insert(sample.stream.as_ref().stream_id, (sample, now));
+        loop {
+            match device.try_next() {
+                Ok(Some(sample)) => {
+                    recompute_width = recompute_width || sample.meta_changed;
+                    last_sample.insert(sample.stream.as_ref().stream_id, (sample, now));
+                }
+                Ok(None) => {
+                    break;
+                }
+                Err(e) => {
+                    eprintln!("\nError receiving data from device: {:?}. Exiting.", e);
+                    break 'drawing;
+                }
+            }
         }
         if recompute_width {
             for (_, (sample, _)) in &last_sample {
diff --git a/twinleaf-tools/src/bin/tio-tool.rs b/twinleaf-tools/src/bin/tio-tool.rs
@@ -347,9 +347,14 @@ fn meta_dump(args: &[String]) -> Result<(), ()> {
     let (_matches, root, route) = tio_parseopts(&opts, args);
 
     let proxy = proxy::Interface::new(&root);
-    let mut device = twinleaf::Device::open(&proxy, route);
+    let mut device = twinleaf::Device::open(&proxy, route).map_err(|e| {
+        eprintln!("Failed to open device: {:?}", e);
+    })?;
+
+    let meta = device.get_metadata().map_err(|e| {
+        eprintln!("Failed to get metadata: {:?}", e);
+    })?;
 
-    let meta = device.get_metadata();
     println!("{:?}", meta.device);
     for (_id, stream) in meta.streams {
         println!("{:?}", stream.stream);
@@ -380,12 +385,20 @@ fn data_dump(args: &[String]) -> Result<(), ()> {
     let (_matches, root, route) = tio_parseopts(&opts, args);
 
     let proxy = proxy::Interface::new(&root);
-    let mut device = twinleaf::Device::open(&proxy, route);
+    let mut device = twinleaf::Device::open(&proxy, route).map_err(|e| {
+        eprintln!("Failed to open device: {:?}", e);
+    })?;
 
     loop {
-        print_sample(&device.next());
+        match device.next() {
+            Ok(sample) => print_sample(&sample),
+            Err(e) => {
+                eprintln!("\nDevice error: {:?}. Exiting.", e);
+                break;
+            }
+        }
     }
-    // Ok(())
+    Ok(())
 }
 
 fn log(args: &[String]) -> Result<(), ()> {
@@ -443,9 +456,14 @@ fn log_metadata(args: &[String]) -> Result<(), ()> {
     }
 
     let proxy = proxy::Interface::new(&root);
-    let mut device = twinleaf::Device::open(&proxy, route);
-
-    let meta = device.get_metadata();
+    let mut device = twinleaf::Device::open(&proxy, route).map_err(|e| {
+        eprintln!("Failed to open device: {:?}", e);
+    })?;
+
+    let meta = device.get_metadata().map_err(|e| {
+        eprintln!("Failed to get metadata: {:?}", e);
+    })?;
+    
     let output_path = if let Some(path) = matches.opt_str("f") {
         path
     } else {
diff --git a/twinleaf/src/device/mod.rs b/twinleaf/src/device/mod.rs
@@ -22,19 +22,20 @@ impl Device {
         }
     }
 
-    pub fn open(proxy: &tio::proxy::Interface, route: DeviceRoute) -> Device {
-        let port = proxy.device_full(route).unwrap(); // TODO
-        Self::new(port)
+    pub fn open(proxy: &tio::proxy::Interface, route: DeviceRoute) -> Result<Device, proxy::PortError> {
+        let port = proxy.device_full(route)?;
+        Ok(Self::new(port))
     }
 
-    fn internal_rpcs(&mut self) {
+    fn internal_rpcs(&mut self) -> Result<(), proxy::SendError> {
         if self.n_reqs == 0 {
             let reqs = self.parser.requests();
             for req in reqs {
-                self.dev_port.send(req).unwrap();
+                self.dev_port.send(req)?;
                 self.n_reqs += 1;
             }
         }
+        Ok(())
     }
 
     fn process_packet(&mut self, pkt: tio::Packet) -> Option<tio::Packet> {
@@ -61,70 +62,71 @@ impl Device {
         None
     }
 
-    pub fn get_metadata(&mut self) -> DeviceFullMetadata {
+    pub fn get_metadata(&mut self) -> Result<DeviceFullMetadata, tio::proxy::RpcError> {
         loop {
             if self.n_reqs == 0 {
                 match self.parser.get_metadata() {
-                    Ok(full_meta) => return full_meta,
+                    Ok(full_meta) => return Ok(full_meta),
                     Err(reqs) => {
                         for req in reqs {
-                            self.dev_port.send(req).unwrap();
+                            self.dev_port.send(req).map_err(tio::proxy::RpcError::SendFailed)?;
                             self.n_reqs += 1;
                         }
                     }
                 }
             }
-            let pkt = self.dev_port.recv().unwrap();
+            let pkt = self.dev_port.recv().map_err(tio::proxy::RpcError::RecvFailed)?;
             self.process_packet(pkt);
         }
     }
 
-    pub fn next(&mut self) -> Sample {
+    pub fn next(&mut self) -> Result<Sample, tio::proxy::RpcError> {
         loop {
             if !self.sample_queue.is_empty() {
-                return self.sample_queue.pop_front().unwrap();
+                return Ok(self.sample_queue.pop_front().unwrap());
             }
 
-            self.internal_rpcs();
-            let pkt = self.dev_port.recv().expect("no packet in blocking recv");
+            self.internal_rpcs().map_err(tio::proxy::RpcError::SendFailed)?;
+            
+            let pkt = self.dev_port.recv().map_err(tio::proxy::RpcError::RecvFailed)?;
             self.process_packet(pkt);
         }
     }
 
-    pub fn try_next(&mut self) -> Option<Sample> {
+    pub fn try_next(&mut self) -> Result<Option<Sample>, tio::proxy::RpcError> {
         loop {
             if !self.sample_queue.is_empty() {
-                return self.sample_queue.pop_front();
+                return Ok(self.sample_queue.pop_front());
             }
 
-            self.internal_rpcs();
-            self.process_packet(match self.dev_port.try_recv() {
+            self.internal_rpcs().map_err(tio::proxy::RpcError::SendFailed)?;
+
+            let pkt = match self.dev_port.try_recv() {
                 Ok(pkt) => pkt,
-                Err(proxy::RecvError::WouldBlock) => {
-                    return None;
-                }
-                _ => {
-                    panic!("receive error");
-                }
-            });
+                Err(proxy::RecvError::WouldBlock) => return Ok(None),
+                Err(e) => return Err(tio::proxy::RpcError::RecvFailed(e)),
+            };
+            self.process_packet(pkt);
         }
     }
 
-    pub fn drain(&mut self) -> Vec<Sample> {
+    pub fn drain(&mut self) -> Result<Vec<Sample>, tio::proxy::RpcError> {
         loop {
-            self.internal_rpcs();
-            self.process_packet(match self.dev_port.try_recv() {
-                Ok(pkt) => pkt,
+            self.internal_rpcs().map_err(tio::proxy::RpcError::SendFailed)?;
+            match self.dev_port.try_recv() {
+                Ok(pkt) => {
+                    self.process_packet(pkt);
+                }
                 Err(proxy::RecvError::WouldBlock) => {
                     break;
                 }
-                _ => {
-                    panic!("receive error");
+                Err(e) => {
+                    return Err(tio::proxy::RpcError::RecvFailed(e));
                 }
-            });
+            }
         }
-
-        self.sample_queue.drain(0..).collect()
+        
+        Ok(self.sample_queue.drain(0..).collect())
     }
 
     pub fn raw_rpc(&mut self, name: &str, arg: &[u8]) -> Result<Vec<u8>, tio::proxy::RpcError> {
@@ -137,15 +139,19 @@ impl Device {
             return Err(tio::proxy::RpcError::SendFailed(err));
         }
         loop {
-            self.internal_rpcs();
-            let pkt = self.dev_port.recv().expect("no packet in blocking recv");
+            self.internal_rpcs().map_err(tio::proxy::RpcError::SendFailed)?;
+            let pkt = match self.dev_port.recv() {
+                Ok(packet) => packet,
+                Err(e) => return Err(tio::proxy::RpcError::RecvFailed(e)),
+            };
+
             if let Some(pkt) = self.process_packet(pkt) {
                 match pkt.payload {
                     tio::proto::Payload::RpcReply(rep) => return Ok(rep.reply),
                     tio::proto::Payload::RpcError(err) => {
                         return Err(tio::proxy::RpcError::ExecError(err))
                     }
-                    _ => panic!("unexpected"),
+                    _ => unreachable!("process_packet returned a non-RPC packet to raw_rpc"),
                 }
             }
         }
@@ -176,29 +182,32 @@ impl Device {
         self.rpc(name, ())
     }
 
-    pub fn get_multi(&mut self, name: &str) -> Vec<u8> {
+    pub fn get_multi(&mut self, name: &str) -> Result<Vec<u8>, tio::proxy::RpcError> {
         let mut full_reply = vec![];
 
         for i in 0u16..=65535u16 {
             match self.raw_rpc(&name, &i.to_le_bytes().to_vec()) {
                 Ok(mut rep) => full_reply.append(&mut rep),
-                Err(proxy::RpcError::ExecError(err)) => {
-                    if let tio::proto::RpcErrorCode::InvalidArgs = err.error {
-                        break;
-                    } else {
-                        panic!("RPC error");
+                Err(err @ proxy::RpcError::ExecError(_)) => {
+                    if let proxy::RpcError::ExecError(payload) = &err {
+                        if let tio::proto::RpcErrorCode::InvalidArgs = payload.error {
+                            break;
+                        }
                     }
+                    return Err(err);
                 }
-                _ => {
-                    panic!("RPC error")
+                Err(e) => {
+                    return Err(e);
                 }
             }
         }
 
-        full_reply
+        Ok(full_reply)
     }
 
-    pub fn get_multi_str(&mut self, name: &str) -> String {
-        String::from_utf8_lossy(&self.get_multi(name)).to_string()
+    pub fn get_multi_str(&mut self, name: &str) -> Result<String, tio::proxy::RpcError> {
+        let reply_bytes = self.get_multi(name)?;
+        let result_string = String::from_utf8_lossy(&reply_bytes).to_string();
+        Ok(result_string)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -22,19 +22,20 @@ impl Device {`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`- pub fn open(proxy: &tio::proxy::Interface, route: DeviceRoute) -> Device {`
`26`		`- let port = proxy.device_full(route).unwrap(); // TODO`
`27`		`- Self::new(port)`
	`25`	`+ pub fn open(proxy: &tio::proxy::Interface, route: DeviceRoute) -> Result<Device, proxy::PortError> {`
	`26`	`+ let port = proxy.device_full(route)?;`
	`27`	`+ Ok(Self::new(port))`
`28`	`28`	`}`
`29`	`29`
`30`		`- fn internal_rpcs(&mut self) {`
	`30`	`+ fn internal_rpcs(&mut self) -> Result<(), proxy::SendError> {`
`31`	`31`	`if self.n_reqs == 0 {`
`32`	`32`	`let reqs = self.parser.requests();`
`33`	`33`	`for req in reqs {`
`34`		`- self.dev_port.send(req).unwrap();`
	`34`	`+ self.dev_port.send(req)?;`
`35`	`35`	`self.n_reqs += 1;`
`36`	`36`	`}`
`37`	`37`	`}`
	`38`	`+ Ok(())`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`fn process_packet(&mut self, pkt: tio::Packet) -> Option<tio::Packet> {`
`@@ -61,70 +62,71 @@ impl Device {`
`61`	`62`	`None`
`62`	`63`	`}`
`63`	`64`
`64`		`- pub fn get_metadata(&mut self) -> DeviceFullMetadata {`
	`65`	`+ pub fn get_metadata(&mut self) -> Result<DeviceFullMetadata, tio::proxy::RpcError> {`
`65`	`66`	`loop {`
`66`	`67`	`if self.n_reqs == 0 {`
`67`	`68`	`match self.parser.get_metadata() {`
`68`		`- Ok(full_meta) => return full_meta,`
	`69`	`+ Ok(full_meta) => return Ok(full_meta),`
`69`	`70`	`Err(reqs) => {`
`70`	`71`	`for req in reqs {`
`71`		`- self.dev_port.send(req).unwrap();`
	`72`	`+ self.dev_port.send(req).map_err(tio::proxy::RpcError::SendFailed)?;`
`72`	`73`	`self.n_reqs += 1;`
`73`	`74`	`}`
`74`	`75`	`}`
`75`	`76`	`}`
`76`	`77`	`}`
`77`		`- let pkt = self.dev_port.recv().unwrap();`
	`78`	`+ let pkt = self.dev_port.recv().map_err(tio::proxy::RpcError::RecvFailed)?;`
`78`	`79`	`self.process_packet(pkt);`
`79`	`80`	`}`
`80`	`81`	`}`
`81`	`82`
`82`		`- pub fn next(&mut self) -> Sample {`
	`83`	`+ pub fn next(&mut self) -> Result<Sample, tio::proxy::RpcError> {`
`83`	`84`	`loop {`
`84`	`85`	`if !self.sample_queue.is_empty() {`
`85`		`- return self.sample_queue.pop_front().unwrap();`
	`86`	`+ return Ok(self.sample_queue.pop_front().unwrap());`
`86`	`87`	`}`
`87`	`88`
`88`		`- self.internal_rpcs();`
`89`		`- let pkt = self.dev_port.recv().expect("no packet in blocking recv");`
	`89`	`+ self.internal_rpcs().map_err(tio::proxy::RpcError::SendFailed)?;`
	`90`	`+`
	`91`	`+ let pkt = self.dev_port.recv().map_err(tio::proxy::RpcError::RecvFailed)?;`
`90`	`92`	`self.process_packet(pkt);`
`91`	`93`	`}`
`92`	`94`	`}`
`93`	`95`
`94`		`- pub fn try_next(&mut self) -> Option<Sample> {`
	`96`	`+ pub fn try_next(&mut self) -> Result<Option<Sample>, tio::proxy::RpcError> {`
`95`	`97`	`loop {`
`96`	`98`	`if !self.sample_queue.is_empty() {`
`97`		`- return self.sample_queue.pop_front();`
	`99`	`+ return Ok(self.sample_queue.pop_front());`
`98`	`100`	`}`
`99`	`101`
`100`		`- self.internal_rpcs();`
`101`		`- self.process_packet(match self.dev_port.try_recv() {`
	`102`	`+ self.internal_rpcs().map_err(tio::proxy::RpcError::SendFailed)?;`
	`103`	`+`
	`104`	`+ let pkt = match self.dev_port.try_recv() {`
`102`	`105`	`Ok(pkt) => pkt,`
`103`		`- Err(proxy::RecvError::WouldBlock) => {`
`104`		`- return None;`
`105`		`- }`
`106`		`- _ => {`
`107`		`- panic!("receive error");`
`108`		`- }`
`109`		`- });`
	`106`	`+ Err(proxy::RecvError::WouldBlock) => return Ok(None),`
	`107`	`+ Err(e) => return Err(tio::proxy::RpcError::RecvFailed(e)),`
	`108`	`+ };`
	`109`	`+ self.process_packet(pkt);`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`		`- pub fn drain(&mut self) -> Vec<Sample> {`
	`113`	`+ pub fn drain(&mut self) -> Result<Vec<Sample>, tio::proxy::RpcError> {`
`114`	`114`	`loop {`
`115`		`- self.internal_rpcs();`
`116`		`- self.process_packet(match self.dev_port.try_recv() {`
`117`		`- Ok(pkt) => pkt,`
	`115`	`+ self.internal_rpcs().map_err(tio::proxy::RpcError::SendFailed)?;`
	`116`	`+ match self.dev_port.try_recv() {`
	`117`	`+ Ok(pkt) => {`
	`118`	`+ self.process_packet(pkt);`
	`119`	`+ }`
`118`	`120`	`Err(proxy::RecvError::WouldBlock) => {`
`119`	`121`	`break;`
`120`	`122`	`}`
`121`		`- _ => {`
`122`		`- panic!("receive error");`
	`123`	`+ Err(e) => {`
	`124`	`+ return Err(tio::proxy::RpcError::RecvFailed(e));`
`123`	`125`	`}`
`124`		`- });`
	`126`	`+ }`
`125`	`127`	`}`
`126`		`-`
`127`		`- self.sample_queue.drain(0..).collect()`
	`128`	`+`
	`129`	`+ Ok(self.sample_queue.drain(0..).collect())`
`128`	`130`	`}`
`129`	`131`
`130`	`132`	`pub fn raw_rpc(&mut self, name: &str, arg: &[u8]) -> Result<Vec<u8>, tio::proxy::RpcError> {`
`@@ -137,15 +139,19 @@ impl Device {`
`137`	`139`	`return Err(tio::proxy::RpcError::SendFailed(err));`
`138`	`140`	`}`
`139`	`141`	`loop {`
`140`		`- self.internal_rpcs();`
`141`		`- let pkt = self.dev_port.recv().expect("no packet in blocking recv");`
	`142`	`+ self.internal_rpcs().map_err(tio::proxy::RpcError::SendFailed)?;`
	`143`	`+ let pkt = match self.dev_port.recv() {`
	`144`	`+ Ok(packet) => packet,`
	`145`	`+ Err(e) => return Err(tio::proxy::RpcError::RecvFailed(e)),`
	`146`	`+ };`
	`147`	`+`
`142`	`148`	`if let Some(pkt) = self.process_packet(pkt) {`
`143`	`149`	`match pkt.payload {`
`144`	`150`	`tio::proto::Payload::RpcReply(rep) => return Ok(rep.reply),`
`145`	`151`	`tio::proto::Payload::RpcError(err) => {`
`146`	`152`	`return Err(tio::proxy::RpcError::ExecError(err))`
`147`	`153`	`}`
`148`		`- _ => panic!("unexpected"),`
	`154`	`+ _ => unreachable!("process_packet returned a non-RPC packet to raw_rpc"),`
`149`	`155`	`}`
`150`	`156`	`}`
`151`	`157`	`}`
`@@ -176,29 +182,32 @@ impl Device {`
`176`	`182`	`self.rpc(name, ())`
`177`	`183`	`}`
`178`	`184`
`179`		`- pub fn get_multi(&mut self, name: &str) -> Vec<u8> {`
	`185`	`+ pub fn get_multi(&mut self, name: &str) -> Result<Vec<u8>, tio::proxy::RpcError> {`
`180`	`186`	`let mut full_reply = vec![];`
`181`	`187`
`182`	`188`	`for i in 0u16..=65535u16 {`
`183`	`189`	`match self.raw_rpc(&name, &i.to_le_bytes().to_vec()) {`
`184`	`190`	`Ok(mut rep) => full_reply.append(&mut rep),`
`185`		`- Err(proxy::RpcError::ExecError(err)) => {`
`186`		`- if let tio::proto::RpcErrorCode::InvalidArgs = err.error {`
`187`		`- break;`
`188`		`- } else {`
`189`		`- panic!("RPC error");`
	`191`	`+ Err(err @ proxy::RpcError::ExecError(_)) => {`
	`192`	`+ if let proxy::RpcError::ExecError(payload) = &err {`
	`193`	`+ if let tio::proto::RpcErrorCode::InvalidArgs = payload.error {`
	`194`	`+ break;`
	`195`	`+ }`
`190`	`196`	`}`
	`197`	`+ return Err(err);`
`191`	`198`	`}`
`192`		`- _ => {`
`193`		`- panic!("RPC error")`
	`199`	`+ Err(e) => {`
	`200`	`+ return Err(e);`
`194`	`201`	`}`
`195`	`202`	`}`
`196`	`203`	`}`
`197`	`204`
`198`		`- full_reply`
	`205`	`+ Ok(full_reply)`
`199`	`206`	`}`
`200`	`207`
`201`		`- pub fn get_multi_str(&mut self, name: &str) -> String {`
`202`		`- String::from_utf8_lossy(&self.get_multi(name)).to_string()`
	`208`	`+ pub fn get_multi_str(&mut self, name: &str) -> Result<String, tio::proxy::RpcError> {`
	`209`	`+ let reply_bytes = self.get_multi(name)?;`
	`210`	`+ let result_string = String::from_utf8_lossy(&reply_bytes).to_string();`
	`211`	`+ Ok(result_string)`
`203`	`212`	`}`
`204`	`213`	`}`