Refactor Error Handling

examples/wifi-ap.rs

@@ -16,8 +16,11 @@ async fn main() -> Result {
         info!("[{:?}] {:?}", i, itf.name);
     }
     let user_input = read_until_break().await;
-    let index = user_input.trim().parse::<usize>()?;
-    let mut setup = ap::WifiSetup::new()?;
+    let index = user_input
+        .trim()
+        .parse::<usize>()
+        .expect("user should enter a number");
+    let mut setup = ap::WifiSetup::new();
 
     let proposed_path = format!("/var/run/hostapd/{}", network_interfaces[index].name);
     info!("Connect to \"{proposed_path}\"? Type full new path or just press enter to accept.");
@@ -31,7 +34,7 @@ async fn main() -> Result {
 
     let broadcast = setup.get_broadcast_receiver();
     let requester = setup.get_request_client();
-    let runtime = setup.complete();
+    let mut runtime = setup.complete();
 
     let (_runtime, _app, _broadcast) = tokio::join!(
         async move {

examples/wifi-sta.rs

@@ -16,8 +16,8 @@ async fn main() -> Result {
         info!("[{:?}] {:?}", i, itf.name);
     }
     let user_input = read_until_break().await;
-    let index = user_input.trim().parse::<usize>()?;
-    let mut setup = sta::WifiSetup::new()?;
+    let index = user_input.trim().parse::<usize>().expect("");
+    let mut setup = sta::WifiSetup::new();
 
     let proposed_path = format!("/var/run/wpa_supplicant/{}", network_interfaces[index].name);
     info!("Connect to \"{proposed_path}\"? Type full new path or just press enter to accept.");
@@ -31,7 +31,7 @@ async fn main() -> Result {
 
     let broadcast = setup.get_broadcast_receiver();
     let requester = setup.get_request_client();
-    let runtime = setup.complete();
+    let mut runtime = setup.complete();
 
     let (_runtime, _app, _broadcast) = tokio::join!(
         async move {

src/ap/client.rs

@@ -15,26 +15,6 @@ impl ShutdownSignal for Request {
     fn is_shutdown(&self) -> bool {
         matches!(self, Request::Shutdown)
     }
-    fn inform_of_shutdown(self) {
-        match self {
-            Request::Custom(_, response) => {
-                let _ = response.send(Err(error::Error::StartupAborted));
-            }
-            Request::Status(response) => {
-                let _ = response.send(Err(error::Error::StartupAborted));
-            }
-            Request::Config(response) => {
-                let _ = response.send(Err(error::Error::StartupAborted));
-            }
-            Request::Enable(response) | Request::Disable(response) => {
-                let _ = response.send(Err(error::Error::StartupAborted));
-            }
-            Request::SetValue(_, _, response) => {
-                let _ = response.send(Err(error::Error::StartupAborted));
-            }
-            Request::Shutdown => {}
-        }
-    }
 }
 
 #[derive(Clone)]
@@ -48,56 +28,46 @@ impl RequestClient {
         RequestClient { sender }
     }
 
-    async fn send_request(&self, request: Request) -> Result {
-        self.sender
-            .send(request)
-            .await
-            .map_err(|_| error::Error::WifiApRequestChannelClosed)?;
-        Ok(())
-    }
-
     pub async fn send_custom(&self, custom: String) -> Result<String> {
         let (response, request) = oneshot::channel();
-        self.sender
-            .send(Request::Custom(custom, response))
-            .await
-            .map_err(|_| error::Error::WifiApRequestChannelClosed)?;
+        self.sender.send(Request::Custom(custom, response)).await?;
         request.await?
     }
 
     pub async fn get_status(&self) -> Result<Status> {
         let (response, request) = oneshot::channel();
-        self.send_request(Request::Status(response)).await?;
+        self.sender.send(Request::Status(response)).await?;
         request.await?
     }
 
     pub async fn get_config(&self) -> Result<Config> {
         let (response, request) = oneshot::channel();
-        self.send_request(Request::Config(response)).await?;
+        self.sender.send(Request::Config(response)).await?;
         request.await?
     }
 
     pub async fn enable(&self) -> Result {
         let (response, request) = oneshot::channel();
-        self.send_request(Request::Enable(response)).await?;
+        self.sender.send(Request::Enable(response)).await?;
         request.await?
     }
 
     pub async fn disable(&self) -> Result {
         let (response, request) = oneshot::channel();
-        self.send_request(Request::Disable(response)).await?;
+        self.sender.send(Request::Disable(response)).await?;
         request.await?
     }
 
     pub async fn set_value(&self, key: &str, value: &str) -> Result {
         let (response, request) = oneshot::channel();
-        self.send_request(Request::SetValue(key.into(), value.into(), response))
+        self.sender
+            .send(Request::SetValue(key.into(), value.into(), response))
             .await?;
         request.await?
     }
 
     pub async fn shutdown(&self) -> Result {
-        self.send_request(Request::Shutdown).await
+        Ok(self.sender.send(Request::Shutdown).await?)
     }
 }
 

src/ap/event_socket.rs

@@ -2,9 +2,6 @@ use super::*;
 
 pub(crate) struct EventSocket {
     socket_handle: SocketHandle<1024>,
-    attach_options: Vec<String>,
-    /// Sends messages to client
-    sender: mpsc::Sender<Event>,
 }
 
 #[derive(Debug)]
@@ -14,88 +11,51 @@ pub(crate) enum Event {
     Unknown(String),
 }
 
-pub(crate) type EventReceiver = mpsc::Receiver<Event>;
-
 impl EventSocket {
     pub(crate) async fn new<P>(
         socket: P,
         request_receiver: &mut mpsc::Receiver<Request>,
         attach_options: &[String],
-    ) -> Result<(EventReceiver, Vec<Request>, Self)>
+    ) -> SocketResult<(Vec<Request>, Self)>
     where
         P: AsRef<std::path::Path> + std::fmt::Debug,
     {
-        let (socket_handle, deferred_requests) =
+        let (mut socket_handle, deferred_requests) =
             SocketHandle::open(socket, "hostapd_async.sock", request_receiver).await?;
 
-        // setup the channel for client requests
-        let (sender, receiver) = mpsc::channel(32);
-        Ok((
-            receiver,
-            deferred_requests,
-            Self {
-                socket_handle,
-                sender,
-                attach_options: attach_options.to_vec(),
-            },
-        ))
-    }
-
-    async fn send_event(&self, event: Event) -> Result {
-        self.sender
-            .send(event)
-            .await
-            .map_err(|_| error::Error::WifiApEventChannelClosed)?;
-        Ok(())
-    }
-
-    pub(crate) async fn run(mut self) -> Result {
         let mut command = "ATTACH".to_string();
-        for o in &self.attach_options {
+        for o in attach_options {
             command.push(' ');
             command.push_str(o);
         }
-        let mut attach = self.socket_handle.command(command.as_bytes()).await;
+        let mut attach = socket_handle.command(command.as_bytes()).await?;
         while attach.is_err() {
             tokio::time::sleep(tokio::time::Duration::from_millis(250)).await;
-            attach = self.socket_handle.command(command.as_bytes()).await;
+            attach = socket_handle.command(command.as_bytes()).await?;
         }
 
-        let mut log_level = self.socket_handle.command(b"LOG_LEVEL DEBUG").await;
+        let mut log_level = socket_handle.command(b"LOG_LEVEL DEBUG").await?;
         while log_level.is_err() {
             tokio::time::sleep(tokio::time::Duration::from_millis(250)).await;
-            log_level = self.socket_handle.command(b"LOG_LEVEL DEBUG").await;
+            log_level = socket_handle.command(b"LOG_LEVEL DEBUG").await?;
         }
         info!("hostapd event stream registered");
+        Ok((deferred_requests, Self { socket_handle }))
+    }
 
-        loop {
-            match self
-                .socket_handle
-                .socket
-                .recv(&mut self.socket_handle.buffer)
-                .await
-            {
-                Ok(n) => {
-                    let data_str = std::str::from_utf8(&self.socket_handle.buffer[..n])?.trim_end();
-                    if let Some(n) = data_str.find("AP-STA-DISCONNECTED") {
-                        let index = n + "AP-STA-DISCONNECTED".len();
-                        let mac = &data_str[index..];
-                        self.send_event(Event::ApStaDisconnected(mac.to_string()))
-                            .await?;
-                    } else if let Some(n) = data_str.find("AP-STA-CONNECTED") {
-                        let index = n + "AP-STA-CONNECTED".len();
-                        let mac = &data_str[index..];
-                        self.send_event(Event::ApStaConnected(mac.to_string()))
-                            .await?;
-                    } else {
-                        self.send_event(Event::Unknown(data_str.to_string()))
-                            .await?;
-                    }
-                }
-                Err(e) => {
-                    return Err(error::Error::UnsolicitedIoError(e));
-                }
-            }
-        }
+    pub(crate) async fn recv(&mut self) -> SocketResult<Event> {
+        let bytes = self.socket_handle.recv().await?;
+        let data_str = String::from_utf8_lossy(bytes);
+        Ok(if let Some(n) = data_str.find("AP-STA-DISCONNECTED") {
+            let index = n + "AP-STA-DISCONNECTED".len();
+            let mac = data_str[index..].trim();
+            Event::ApStaDisconnected(mac.to_string())
+        } else if let Some(n) = data_str.find("AP-STA-CONNECTED") {
+            let index = n + "AP-STA-CONNECTED".len();
+            let mac = &data_str[index..].trim();
+            Event::ApStaConnected(mac.to_string())
+        } else {
+            Event::Unknown(data_str.to_string())
+        })
     }
 }