better error messages

src/backend/wayland/consumer.rs

@@ -95,19 +95,25 @@ impl App {
         let keyboard: Vk = self.vkm.create_virtual_keyboard(&self.seat, &self.qh, ());
 
         // receive keymap from device
-        eprintln!("connecting to {}", client.addr);
+        eprint!("\rconnecting to {} ", client.addr);
-
+        let mut attempts = 0;
         let data = loop {
-            match request::request_data(client.addr, Request::KeyMap) {
+            let result = request::request_data(client.addr, Request::KeyMap);
-                Some(data) => break data,
+            eprint!("\rconnecting to {} ", client.addr);
-                None => {
+            for _ in 0..attempts { eprint!("."); }
-                    eprint!(".");
+            match result {
-                    io::stderr().flush().unwrap();
+                Ok(data) => break data,
-                    thread::sleep(Duration::from_millis(500));
+                Err(e) => { eprint!(" - {}", e); }
-                }
             }
+            io::stderr().flush().unwrap();
+            thread::sleep(Duration::from_millis(500));
+            attempts += 1;
         };
 
+        eprint!("\rconnecting to {} ", client.addr);
+        for _ in 0..attempts { eprint!("."); }
+        eprintln!(" done!                          ");
+
         // TODO use shm_open
         let f = tempfile::tempfile().unwrap();
         let mut buf = BufWriter::new(&f);

src/request.rs

@@ -4,7 +4,7 @@ use std::{
     io::prelude::*,
     net::{SocketAddr, TcpListener, TcpStream},
     sync::{Arc, RwLock},
-    thread::{self, JoinHandle},
+    thread::{self, JoinHandle}, fmt::Display,
 };
 
 use memmap::Mmap;
@@ -83,47 +83,51 @@ impl Server {
     }
 }
 
-pub fn request_data(addr: SocketAddr, req: Request) -> Option<Vec<u8>> {
+#[derive(Debug)]
+pub struct BadRequest;
+
+impl Display for BadRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "BadRequest")
+    }
+}
+
+impl Error for BadRequest {}
+
+pub fn request_data(addr: SocketAddr, req: Request) -> Result<Vec<u8>, Box<dyn Error>> {
     // connect to server
     let mut sock = match TcpStream::connect(addr) {
         Ok(sock) => sock,
-        Err(e) => {
+        Err(e) => return Err(Box::new(e)),
-            eprintln!("{}", e);
-            return None;
-        }
     };
 
     // write the request to the socket
     // convert to u32
     let req: u32 = req as u32;
     if let Err(e) = sock.write(&req.to_ne_bytes()) {
-        eprintln!("{}", e);
+        return Err(Box::new(e));
-        return None;
     }
     if let Err(e) = sock.flush() {
-        eprintln!("{}", e);
+        return Err(Box::new(e));
-        return None;
     }
 
     // read the response = (len, data) - len 0 means no data / bad request
     // read len
     let mut buf = [0u8; 8];
     if let Err(e) = sock.read_exact(&mut buf[..]) {
-        eprintln!("{}", e);
+        return Err(Box::new(e));
-        return None;
     }
     let len = usize::from_ne_bytes(buf);
 
     // check for bad request
     if len == 0 {
-        return None;
+        return Err(Box::new(BadRequest{}));
     }
 
     // read the data
     let mut data: Vec<u8> = vec![0u8; len];
     if let Err(e) = sock.read_exact(&mut data[..]) {
-        eprintln!("{}", e);
+        return Err(Box::new(e));
-        return None;
     }
-    Some(data)
+    Ok(data)
 }