ref(logger): log and trace at the same time

Author: kkharji

src/daemon/requests/run.rs

@@ -5,7 +5,10 @@ use crate::{
 };
 
 #[cfg(feature = "daemon")]
-use {crate::constants::DAEMON_STATE, crate::types::SimDevice, anyhow::anyhow as err};
+use {
+    crate::constants::DAEMON_STATE, crate::types::SimDevice, anyhow::anyhow as err,
+    xcodebuild::runner::build_settings,
+};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct DeviceLookup {
@@ -27,15 +30,11 @@ pub struct Run {
 #[async_trait::async_trait]
 impl Handler for Run {
     async fn handle(self) -> Result<()> {
-        tracing::info!("⚙️ Running command: {:#?}", self);
+        tracing::info!("⚙️ Running command: {}", self.config.to_string());
+        tracing::trace!("{:#?}", self);
 
-        let Self {
-            client,
-            config,
-            device,
-            ..
-        } = self;
-        let Client { pid, root } = client;
+        let Self { config, device, .. } = self;
+        let Client { pid, root } = self.client;
 
         let direction = self.direction.clone();
         let state = DAEMON_STATE.clone().lock_owned().await;
@@ -58,12 +57,13 @@ impl Handler for Run {
             args
         };
 
-        let build_settings = xcodebuild::runner::build_settings(&root, &args).await?;
+        let build_settings = build_settings(&root, &args).await?;
         let ref app_id = build_settings.product_bundle_identifier;
 
         // FIX(run): When running with release path_to_app is incorrect
         //
-        // Err: application bundle was not found at the provided path.\nProvide a valid path to the desired application bundle.
+        // Err: application bundle was not found at the provided path.\nProvide a valid path to the
+        // desired application bundle.
         //
         // Path doesn't point to local directory build
         let ref path_to_app = build_settings.metal_library_output_dir;

src/nvim/logger.rs

@@ -58,6 +58,8 @@ impl<'a> Logger<'a> {
     }
 
     pub async fn log(&mut self, msg: String, win: &Option<NvimWindow>) -> Result<()> {
+        tracing::debug!("{msg}");
+
         let mut c = self.get_line_count().await?;
         let lines = msg
             .split("\n")

src/types/simdevice.rs

@@ -1,11 +1,11 @@
-use anyhow::anyhow as err;
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use simctl::list::DeviceState;
 use simctl::Device;
 use std::hash::Hash;
 use std::ops::{Deref, DerefMut};
 use std::path::PathBuf;
+use tap::Pipe;
 
 use crate::nvim::Logger;
 use crate::nvim::NvimWindow;
@@ -60,12 +60,14 @@ impl SimDevice {
         win: &Option<NvimWindow>,
     ) -> Result<()> {
         if let DeviceState::Shutdown = &self.state {
-            self.boot().map_err(|e| err!("{:#?}", e))?;
-            self.state = DeviceState::Booted;
+            logger
+                .log(format!("[Booting] ({})", self.name), win)
+                .await?;
 
-            let msg = format!("[Booting] \"{}\"", self.name);
-            tracing::info!("{msg}");
-            logger.log(msg, win).await?;
+            self.boot()
+                .pipe(|res| self.handle_error(res, logger, win))
+                .await?;
+            self.state = DeviceState::Booted;
         }
 
         Ok(())
@@ -78,11 +80,12 @@ impl SimDevice {
         logger: &mut Logger<'a>,
         win: &Option<NvimWindow>,
     ) -> Result<()> {
-        self.install(path_to_app).map_err(|e| err!("{:#?}", e))?;
-        let msg = format!("[Installed] \"{}\" {app_id}", self.name);
-        tracing::info!("{msg}");
-        logger.log(msg, win).await?;
-        Ok(())
+        self.install(path_to_app)
+            .pipe(|res| self.handle_error(res, logger, win))
+            .await?;
+        logger
+            .log(format!("[Installing] ({}) {app_id}", self.name), win)
+            .await
     }
 
     pub async fn try_launch<'a>(
@@ -92,21 +95,49 @@ impl SimDevice {
         win: &Option<NvimWindow>,
     ) -> Result<()> {
         if !self.is_running {
-            tracing::info!("[Launching] \"{}\" {app_id}", self.name);
+            logger
+                .log(format!("[Launching] ({}) {app_id}", self.name), win)
+                .await?;
+
             self.launch(app_id)
                 .stdout(&"/tmp/wordle_log")
                 .stderr(&"/tmp/wordle_log")
                 .exec()
-                .map_err(|e| err!("{:#?}", e))?;
+                .pipe(|res| self.handle_error(res, logger, win))
+                .await?;
 
             self.is_running = true;
 
-            tracing::info!("[Launched]");
             logger
                 .log(string_as_section("[Launched]".into()), win)
                 .await?;
         }
 
         Ok(())
     }
+
+    async fn handle_error<'a, T>(
+        &mut self,
+        res: simctl::Result<T>,
+        logger: &mut Logger<'a>,
+        win: &Option<NvimWindow>,
+    ) -> Result<()> {
+        if let Err(e) = to_anyhow_error(res) {
+            logger.log(e.to_string(), win).await?;
+            logger.set_status_end(false, true).await?;
+            self.is_running = false;
+        }
+        Ok(())
+    }
+}
+
+fn to_anyhow_error<T>(v: simctl::Result<T>) -> Result<T> {
+    v.map_err(|e| match e {
+        simctl::Error::Output { stderr, .. } => {
+            anyhow::anyhow!("External Command Failure: {stderr}")
+        }
+        simctl::Error::Io(err) => anyhow::Error::new(err),
+        simctl::Error::Json(err) => anyhow::Error::new(err),
+        simctl::Error::Utf8(err) => anyhow::Error::new(err),
+    })
 }