feat(runner): log simctl app outputs like print

Author: kkharji

Cargo.lock

@@ -6,13 +6,13 @@ edition = "2021"
 [features]
 default     = [ ]
 xcodegen    = [ "async", "dirs" ]
-daemon      = [ "serial", "compilation", "logging", "async", "watcher", "proc", "xcodegen", "parity-tokio-ipc", "nvim-rs", "async-stream", "tokio-stream", "strum", "simctl" ]
+daemon      = [ "serial", "compilation", "logging", "async", "watcher", "proc", "xcodegen", "parity-tokio-ipc", "nvim-rs", "strum", "simctl" ]
 server      = [ "serial", "logging", "dirs", "bsp-server", "url", "wax", "shell-words", "compilation", "strum" ]
 lua         = [ "mlua", "serial", "strum", "simctl" ]
 serial      = [ "serde", "serde_json", "serde_yaml" ]
 compilation = [ "serial", "lazy_static", "shell-words", "xcode" ]
 logging     = [ "tracing", "tracing-appender", "tracing-subscriber" ]
-async       = [ "tokio", "async-trait" ]
+async       = [ "tokio", "async-trait", "futures", "async-stream", "tokio-stream" ]
 proc        = [ "libproc" ]
 watcher     = [ "dirs", "notify", "wax" ]
 jsonrpc     = [ "serial" ]
@@ -50,6 +50,9 @@ serde_yaml            = { version = "0.8.23", optional = true }
 tokio                 = { version = "1.17.0", features = ["full"], optional = true }
 tokio-util            = { version = "0.7.1",  features = ["codec"], optional = true }
 async-trait           = { version = "0.1.52", optional = true }
+tokio-stream          = { version = "0.1.8", features = ["io-util"], optional = true  }
+async-stream          = { version = "0.3.3", optional = true }
+futures               = { version = "0.3.21", optional = true } 
 # Logging Feature
 tracing               = { version = "0.1.32", optional = true }
 tracing-subscriber    = { version = "0.3.9",  features = ["env-filter"], optional = true}
@@ -71,7 +74,6 @@ url                   = { version = "2.2.2",  features = ["serde"], optional = t
 nvim-rs               = { version = "0.4.0", optional = true, features = ["use_tokio"] }
 parity-tokio-ipc      = { version = "0.9.0", optional = true }
 strum                 = { version = "0.24.0",  features = ["derive"], optional  = true }
-tokio-stream          = { version = "0.1.8", features = ["io-util"], optional = true  }
-async-stream          = { version = "0.3.3", optional = true }
 simctl                = { path = "../../../sources/simctl/", optional = true }
 thiserror = "1.0.31"
+libc = "0.2.126"

Cargo.toml

@@ -70,6 +70,11 @@ impl Handler for Run {
             return Err(Error::Build(msg));
         }
 
+        // TODO(daemon): insert handler to state.runners
+        // TODO(nvim): provide mapping to close runners.
+        //
+        // If there is more then one runner then pick, else close from current buffer.
+        // C-c in normal/insert mode should close that process
         Runner {
             target: self.config.target,
             platform,

src/daemon/requests/run.rs

@@ -70,6 +70,10 @@ impl NvimClient {
             direction.clone(),
         )
     }
+
+    pub fn new_unamed_logger<'a>(&'a self) -> Logger<'a> {
+        Logger::new(self, "".into(), None)
+    }
 }
 
 #[cfg(feature = "daemon")]

src/nvim.rs

@@ -1,12 +1,16 @@
 mod simctl;
+
 pub use self::simctl::*;
 
 use crate::{
     constants::DAEMON_STATE,
     nvim::BufferDirection,
     state::State,
-    types::{Client, Platform, SimDevice},
-    util::fmt,
+    types::{Client, Platform},
+    util::{
+        fmt,
+        process::{self, Output},
+    },
     Error, Result,
 };
 use {
@@ -94,46 +98,75 @@ impl Runner {
             target,
             state,
             udid,
-            direction,
             ..
         } = self;
 
-        let ref mut logger = state
-            .clients
-            .get(&client.pid)?
-            .new_logger("Run", &target, &direction);
+        let ref mut logger = state.clients.get(&client.pid)?.new_unamed_logger();
         let app_id = settings.product_bundle_identifier;
         let path_to_app = settings.metal_library_output_dir;
 
         logger.set_running().await?;
-        let _runner = {
-            let device = get_device(&state, udid)?;
+
+        let runner = {
+            let device = if let Some(udid) = udid {
+                state.devices.iter().find(|d| d.udid == udid).cloned()
+            } else {
+                None
+            }
+            .ok_or_else(|| Error::Run("udid not found!!".to_string()))?;
+
             let runner = SimDeviceRunner::new(device, target.clone(), app_id, path_to_app);
             runner.boot(logger).await?;
             runner.install(logger).await?;
-            runner.launch(logger).await?;
             runner
         };
 
-        // NOTE: This is required so when neovim exist this should also exit
+        let child = runner.launch(logger).await?;
+        let mut stream = process::stream(child)?;
+        // TODO(daemon): ensure Simulator.app is running
+
+        logger.log(fmt::separator()).await?;
+
+        // TODO(nvim): Close ran simctl process on exit.
         tokio::spawn(async move {
-            let state = DAEMON_STATE.clone().lock_owned().await;
-            let nvim = state.clients.get(&client.pid)?;
-            let ref mut _logger = nvim.new_logger("Run", &target, &direction);
+            while let Some(output) = stream.next().await {
+                let state = DAEMON_STATE.clone();
+                let state = state.lock().await;
+                let mut logger = match state.clients.get(&client.pid) {
+                    Ok(nvim) => nvim.new_unamed_logger(),
+                    Err(e) => {
+                        tracing::error!("SimDevice runner: {e}");
+                        break;
+                    }
+                };
 
-            state.sync_client_state().await?;
+                match output {
+                    Output::Out(msg) => {
+                        if !msg.contains("ignoring singular matrix") {
+                            logger.log(msg).await?;
+                        }
+                    }
+                    Output::Err(msg) => {
+                        logger.log(format!("[Error] {msg}")).await?;
+                    }
+                    Output::Exit(status) => {
+                        if let Ok(Some(code)) = status {
+                            logger.log(format!("[Exit] {code}")).await?;
+                        } else {
+                            logger
+                                .log(format!("[Error] Unable to get exit code"))
+                                .await?;
+                        }
+                        break;
+                    }
+                };
+                drop(state);
+            }
+
+            drop(stream);
 
             Ok(())
         })
         .pipe(Ok)
     }
 }
-
-fn get_device<'a>(state: &'a OwnedMutexGuard<State>, udid: Option<String>) -> Result<SimDevice> {
-    if let Some(udid) = udid {
-        state.devices.iter().find(|d| d.udid == udid).cloned()
-    } else {
-        None
-    }
-    .ok_or_else(|| Error::Run("udid not found!!".to_string()))
-}

src/runner.rs

@@ -1,15 +1,14 @@
 use crate::{nvim::Logger, types::SimDevice, Error, Result};
-use std::path::PathBuf;
+use std::{path::PathBuf, process::Stdio};
 use tap::Pipe;
+use tokio::process::{Child, Command};
 
 /// SimDevice ruuner
 pub struct SimDeviceRunner {
     device: SimDevice,
     target: String,
     app_id: String,
     path_to_app: PathBuf,
-    stdout_path: String,
-    stderr_path: String,
 }
 
 impl SimDeviceRunner {
@@ -36,18 +35,25 @@ impl SimDeviceRunner {
         Ok(())
     }
 
-    pub async fn launch<'a>(&self, logger: &mut Logger<'a>) -> Result<()> {
+    pub async fn launch<'a>(&self, logger: &mut Logger<'a>) -> Result<Child> {
         logger.log(self.launching_msg()).await?;
-        self.device
-            .launch(&self.app_id)
-            .stdout(&self.stdout_path)
-            .stderr(&self.stderr_path)
-            .exec()
-            .pipe(|res| self.ok_or_abort(res, logger))
-            .await?;
+        let process = Command::new("xcrun")
+            .arg("simctl")
+            .arg("launch")
+            .arg("--terminate-running-process")
+            .arg("--console")
+            .arg(&self.device.udid)
+            .arg(&self.app_id)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .stdin(Stdio::null())
+            .kill_on_drop(true)
+            .spawn()?;
+
         logger.log(self.connected_msg()).await?;
-        Ok(())
+        Ok(process)
     }
+
     async fn ok_or_abort<'a, T>(
         &self,
         res: simctl::Result<T>,
@@ -84,10 +90,6 @@ impl SimDeviceRunner {
 
 impl SimDeviceRunner {
     pub fn new(device: SimDevice, target: String, app_id: String, path_to_app: PathBuf) -> Self {
-        let out_path = |out| format!("/tmp/{}_{out}_{}_runner.log", target, &device.udid).into();
-        let stdout_path = out_path("stdout");
-        let stderr_path = out_path("stderr");
-
         tracing::debug!(
             "SimDeviceRunner: {}: {app_id} [{path_to_app:?}]",
             device.name
@@ -97,8 +99,6 @@ impl SimDeviceRunner {
             target,
             app_id,
             path_to_app,
-            stdout_path,
-            stderr_path,
         }
     }
 }

src/runner/simctl.rs

@@ -15,3 +15,7 @@ pub fn as_section(content: String) -> String {
     content.push_str("]");
     content
 }
+
+pub fn separator() -> String {
+    "-".repeat(73)
+}

src/util/fmt.rs

@@ -10,3 +10,6 @@ pub mod serde;
 pub mod tracing;
 
 pub mod fmt;
+
+#[cfg(feature = "daemon")]
+pub mod process;

src/util/mod.rs

@@ -0,0 +1,66 @@
+//! Helper type for processing process output and exit status in non-blocking way
+// use futures::io::Chain;
+use futures::stream::{once, Stream, StreamExt};
+use std::{fmt::Display, io};
+use tokio::{
+    io::{AsyncBufReadExt, AsyncRead, BufReader},
+    process::Child,
+};
+
+/// Create new process from [`Child`]
+/// Child must set stdout and stderr or it might panic.
+pub fn stream(mut child: Child) -> io::Result<impl Stream<Item = Output> + Send> {
+    let stdout = child.stdout.take().unwrap();
+    let stderr = child.stderr.take().unwrap();
+    let status = tokio::spawn(async move { child.wait().await });
+
+    fn to_output(v: io::Result<String>, is_stdout: bool) -> Output {
+        match v {
+            Ok(line) if is_stdout => Output::Out(line),
+            Ok(line) => Output::Err(line),
+            Err(e) => Output::Err(e.to_string()),
+        }
+    }
+
+    use tokio_stream::wrappers::LinesStream;
+    fn to_stream<R: AsyncRead>(out: R) -> LinesStream<BufReader<R>> {
+        LinesStream::new(BufReader::new(out).lines())
+    }
+
+    let stdout_stream = to_stream(stdout).map(|v| to_output(v, true));
+    let stderr_stream = to_stream(stderr).map(|v| to_output(v, false));
+    let exit_stream = once(async move {
+        match status.await {
+            Err(err) => Output::Err(err.to_string()),
+            Ok(Ok(status)) => Output::Exit(Ok(status.code())),
+            Ok(Err(err)) => Output::Exit(Err(err)),
+        }
+    });
+    let stream = tokio_stream::StreamExt::merge(stdout_stream, stderr_stream)
+        .chain(exit_stream)
+        .boxed();
+
+    Ok(stream)
+}
+
+/// Output produced by [`process`]
+#[derive(Debug)]
+pub enum Output {
+    /// Source stdout
+    Out(String),
+    /// Source stderr or internal io::Error
+    Err(String),
+    /// Exit status
+    Exit(Result<Option<i32>, io::Error>),
+}
+
+impl Display for Output {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Output::Out(msg) => msg.fmt(f),
+            Output::Err(msg) => write!(f, "[Error] {msg}"),
+            Output::Exit(Ok(Some(code))) => code.fmt(f),
+            _ => Ok(()),
+        }
+    }
+}