wip

jdx · Dec 13, 2024 · aec7af1 · aec7af1
1 parent 3108800
commit aec7af1
Show file tree

Hide file tree

Showing 11 changed files with 143 additions and 83 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -29,7 +29,7 @@ exponential-backoff = "2"
 indexmap = { version = "2", features = ["serde"] }
 interprocess = { version = "2", features = ["tokio"] }
 itertools = "0.13"
-log = "0.4"
+log = {version="0.4", features=["serde"]}
 miette = { version = "7", features = ["fancy"] }
 notify = { version = "7", features = ["macos_fsevent"] }
 notify-debouncer-full = "0.4"

diff --git a/mise.toml b/mise.toml
@@ -30,6 +30,13 @@ run = [
   "git add pitchfork.usage.kdl docs",
 ]
 
+[tasks.install-dev]
+env = { "PITCHFORK_LOG" = "debug" }
+run = [
+  "cargo install --path . --debug",
+  "pitchfork sup start -f",
+]
+
 [tools]
 bun = "latest"
 

diff --git a/src/cli/cd.rs b/src/cli/cd.rs
@@ -3,6 +3,7 @@ use crate::pitchfork_toml::{PitchforkToml, PitchforkTomlAuto};
 use crate::{env, Result};
 use duct::cmd;
 use itertools::Itertools;
+use log::LevelFilter;
 use miette::IntoDiagnostic;
 use std::collections::HashSet;
 
@@ -15,7 +16,7 @@ pub struct Cd {
 
 impl Cd {
     pub async fn run(&self) -> Result<()> {
-        if let Ok(ipc) = IpcClient::connect(false).await {
+        if let Ok(ipc) = IpcClient::connect(true).await {
             ipc.update_shell_dir(self.shell_pid, env::CWD.clone())
                 .await?;
 
@@ -50,6 +51,16 @@ impl Cd {
             if args.len() > 3 {
                 cmd(&*env::PITCHFORK_BIN, args).run().into_diagnostic()?;
             }
+            for (level, msg) in ipc.get_notifications().await? {
+                match level {
+                    LevelFilter::Trace => trace!("{}", msg),
+                    LevelFilter::Debug => debug!("{}", msg),
+                    LevelFilter::Info => info!("{}", msg),
+                    LevelFilter::Warn => warn!("{}", msg),
+                    LevelFilter::Error => error!("{}", msg),
+                    _ => {}
+                }
+            }
         } else {
             debug!("No daemon running");
         }

diff --git a/src/cli/logs.rs b/src/cli/logs.rs
@@ -24,7 +24,7 @@ pub struct Logs {
     /// Show N lines of logs
     ///
     /// Set to 0 to show all logs
-    #[clap(short, default_value = "10")]
+    #[clap(short, default_value = "100")]
     n: usize,
 
     /// Show logs in real-time
@@ -54,31 +54,31 @@ impl Logs {
 
     fn print_existing_logs(&self) -> Result<()> {
         let log_files = get_log_file_infos(&self.id)?;
-        let log_lines = log_files.iter().flat_map(|(name, lf)| {
-            let rev = match xx::file::open(&lf.path) {
-                Ok(f) => rev_lines::RevLines::new(f),
-                Err(e) => {
-                    error!("{}: {}", lf.path.display(), e);
-                    return vec![];
-                }
-            };
-            let lines = rev.into_iter().filter_map(Result::ok);
-            let lines = if self.n == 0 {
-                lines.collect_vec()
-            } else {
-                lines.take(self.n).collect_vec()
-            };
-            merge_log_lines(name, lines)
-        });
+        let log_lines = log_files
+            .iter()
+            .flat_map(|(name, lf)| {
+                let rev = match xx::file::open(&lf.path) {
+                    Ok(f) => rev_lines::RevLines::new(f),
+                    Err(e) => {
+                        error!("{}: {}", lf.path.display(), e);
+                        return vec![];
+                    }
+                };
+                let lines = rev.into_iter().filter_map(Result::ok);
+                let lines = if self.n == 0 {
+                    lines.collect_vec()
+                } else {
+                    lines.take(self.n).collect_vec()
+                };
+                merge_log_lines(name, lines)
+            })
+            .sorted_by_cached_key(|l| l.0.to_string());
+
         let log_lines = if self.n == 0 {
             log_lines.collect_vec()
         } else {
             log_lines.take(self.n).collect_vec()
         };
-        let log_lines = log_lines
-            .into_iter()
-            .sorted_by_cached_key(|l| l.0.to_string())
-            .collect_vec();
 
         for (date, id, msg) in log_lines {
             if self.id.len() == 1 {

diff --git a/src/cli/run.rs b/src/cli/run.rs
@@ -24,15 +24,20 @@ impl Run {
 
         let ipc = IpcClient::connect(true).await?;
 
-        ipc.run(RunOptions {
-            id: self.id.clone(),
-            cmd: self.run.clone(),
-            shell_pid: None,
-            force: self.force,
-            dir: env::CWD.clone(),
-            autostop: false,
-        })
-        .await?;
+        let started = ipc
+            .run(RunOptions {
+                id: self.id.clone(),
+                cmd: self.run.clone(),
+                shell_pid: None,
+                force: self.force,
+                dir: env::CWD.clone(),
+                autostop: false,
+            })
+            .await?;
+
+        if !started.is_empty() {
+            info!("started {}", started.join(", "));
+        }
         Ok(())
     }
 }
diff --git a/src/cli/start.rs b/src/cli/start.rs
@@ -53,23 +53,27 @@ impl Start {
             let daemon = pt.daemons.get(id);
             if let Some(daemon) = daemon {
                 let cmd = shell_words::split(&daemon.run).into_diagnostic()?;
-                ipc.run(RunOptions {
-                    id: id.clone(),
-                    cmd,
-                    shell_pid: self.shell_pid,
-                    force: self.force,
-                    autostop: daemon
-                        .auto
-                        .contains(&crate::pitchfork_toml::PitchforkTomlAuto::Stop),
-                    dir: daemon
-                        .path
-                        .as_ref()
-                        .unwrap()
-                        .parent()
-                        .map(|p| p.to_path_buf())
-                        .unwrap_or_default(),
-                })
-                .await?;
+                let started = ipc
+                    .run(RunOptions {
+                        id: id.clone(),
+                        cmd,
+                        shell_pid: self.shell_pid,
+                        force: self.force,
+                        autostop: daemon
+                            .auto
+                            .contains(&crate::pitchfork_toml::PitchforkTomlAuto::Stop),
+                        dir: daemon
+                            .path
+                            .as_ref()
+                            .unwrap()
+                            .parent()
+                            .map(|p| p.to_path_buf())
+                            .unwrap_or_default(),
+                    })
+                    .await?;
+                if !started.is_empty() {
+                    info!("started {}", started.join(", "));
+                }
             } else {
                 warn!("Daemon {} not found", id);
             }

diff --git a/src/ipc/client.rs b/src/ipc/client.rs
@@ -134,12 +134,13 @@ impl IpcClient {
         }
     }
 
-    pub async fn run(&self, opts: RunOptions) -> Result<()> {
-        info!("starting daemon {}", opts.id);
+    pub async fn run(&self, opts: RunOptions) -> Result<Vec<String>> {
+        debug!("starting daemon {}", opts.id);
         let rsp = self.request(IpcRequest::Run(opts.clone())).await?;
+        let mut started_daemons = vec![];
         match rsp {
             IpcResponse::DaemonStart { daemon } => {
-                info!("started daemon {}", daemon);
+                started_daemons.push(daemon.id);
             }
             IpcResponse::DaemonAlreadyRunning => {
                 warn!("daemon {} already running", opts.id);
@@ -149,7 +150,7 @@ impl IpcClient {
             }
             rsp => unreachable!("unexpected response: {rsp:?}"),
         }
-        Ok(())
+        Ok(started_daemons)
     }
 
     pub async fn active_daemons(&self) -> Result<Vec<Daemon>> {
@@ -194,4 +195,12 @@ impl IpcClient {
             rsp => unreachable!("unexpected response: {rsp:?}"),
         }
     }
+
+    pub async fn get_notifications(&self) -> Result<Vec<(log::LevelFilter, String)>> {
+        let rsp = self.request(IpcRequest::GetNotifications).await?;
+        match rsp {
+            IpcResponse::Notifications(notifications) => Ok(notifications),
+            rsp => unreachable!("unexpected response: {rsp:?}"),
+        }
+    }
 }
diff --git a/src/ipc/mod.rs b/src/ipc/mod.rs
@@ -33,6 +33,7 @@ pub enum IpcRequest {
     Enable { id: String },
     Disable { id: String },
     UpdateShellDir { shell_pid: u32, dir: PathBuf },
+    GetNotifications,
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, strum::Display, strum::EnumIs)]
@@ -41,6 +42,7 @@ pub enum IpcResponse {
     Yes,
     No,
     Error(String),
+    Notifications(Vec<(log::LevelFilter, String)>),
     ActiveDaemons(Vec<Daemon>),
     DisabledDaemons(Vec<String>),
     DaemonAlreadyStopped,

diff --git a/src/pitchfork_toml.rs b/src/pitchfork_toml.rs
@@ -70,7 +70,7 @@ impl PitchforkToml {
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct PitchforkTomlDaemon {
     pub run: String,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub auto: Vec<PitchforkTomlAuto>,
     #[serde(skip)]
     pub path: Option<PathBuf>,