Support async: commands (#141)

This lets you prefix shell commands with `async:` to have them run
asynchronously. This will let us do things like reindex hie files in the
background.

Author: 9999years

src/cli.rs

@@ -13,6 +13,7 @@ use crate::clap::RustBacktrace;
 use crate::clonable_command::ClonableCommand;
 use crate::ghci::GhciCommand;
 use crate::ignore::GlobMatcher;
+use crate::maybe_async_command::MaybeAsyncCommand;
 use crate::normal_path::NormalPath;
 
 /// A `ghci`-based file watcher and Haskell recompiler.
@@ -178,7 +179,7 @@ pub struct HookOpts {
     /// This can be used to regenerate `.cabal` files with `hpack`.
     /// Can be given multiple times.
     #[arg(long, value_name = "SHELL_COMMAND")]
-    pub before_startup_shell: Vec<ClonableCommand>,
+    pub before_startup_shell: Vec<MaybeAsyncCommand>,
 
     /// `ghci` commands to run on startup. Use `:set args ...` in combination with `--test` to set
     /// the command-line arguments for tests.
@@ -199,6 +200,11 @@ pub struct HookOpts {
     #[arg(long, value_name = "GHCI_COMMAND")]
     pub after_reload_ghci: Vec<GhciCommand>,
 
+    /// Shell commands to run after reloading `ghci`.
+    /// Can be given multiple times.
+    #[arg(long, value_name = "SHELL_COMMAND")]
+    pub after_reload_shell: Vec<MaybeAsyncCommand>,
+
     /// `ghci` commands to run before restarting `ghci`.
     ///
     /// See `--after-restart-ghci` for more details.
@@ -217,6 +223,11 @@ pub struct HookOpts {
     /// See: https://gitlab.haskell.org/ghc/ghc/-/issues/9648
     #[arg(long, value_name = "GHCI_COMMAND")]
     pub after_restart_ghci: Vec<GhciCommand>,
+
+    /// Shell commands to run after restarting `ghci`.
+    /// Can be given multiple times.
+    #[arg(long, value_name = "SHELL_COMMAND")]
+    pub after_restart_shell: Vec<MaybeAsyncCommand>,
 }
 
 impl Opts {

src/clonable_command.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::ffi::OsString;
+use std::fmt::Display;
 use std::path::PathBuf;
 use std::process::Command as StdCommand;
 use std::process::Stdio;
@@ -13,10 +14,12 @@ use miette::Context;
 use miette::IntoDiagnostic;
 use tokio::process::Command;
 
+use crate::command_ext::CommandExt;
+
 /// Like [`std::process::Stdio`], but it implements [`Clone`].
 ///
 /// Unlike [`Stdio`], this value can't represent arbitrary files or file descriptors.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ClonableStdio {
     /// The stream will be ignored. Equivalent to attaching the stream to `/dev/null`.
     Null,
@@ -50,7 +53,7 @@ impl ClonableStdio {
 }
 
 /// Like [`std::process::Command`], but it implements [`Clone`].
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ClonableCommand {
     /// The program to be executed.
     pub program: OsString,
@@ -93,6 +96,14 @@ impl ClonableCommand {
         self
     }
 
+    /// Add arguments to this command. See [`StdCommand::args`].
+    pub fn args(mut self, args: impl IntoIterator<Item = impl Into<OsString>>) -> Self {
+        for arg in args {
+            self = self.arg(arg);
+        }
+        self
+    }
+
     /// Create a new [`std::process::Command`] from this command's configuration.
     pub fn as_std(&self) -> StdCommand {
         let mut ret = StdCommand::new(&self.program);
@@ -142,7 +153,7 @@ impl FromStr for ClonableCommand {
     type Err = miette::Report;
 
     fn from_str(shell_command: &str) -> Result<Self, Self::Err> {
-        let tokens = shell_words::split(shell_command)
+        let tokens = shell_words::split(shell_command.trim())
             .into_diagnostic()
             .wrap_err_with(|| format!("Failed to split shell command: {shell_command:?}"))?;
 
@@ -161,6 +172,21 @@ impl FromStr for ClonableCommand {
     }
 }
 
+impl Display for ClonableCommand {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let tokens = std::iter::once(self.program.to_string_lossy())
+            .chain(self.args.iter().map(|arg| arg.to_string_lossy()));
+
+        write!(f, "{}", shell_words::join(tokens))
+    }
+}
+
+impl CommandExt for ClonableCommand {
+    fn display(&self) -> String {
+        self.to_string()
+    }
+}
+
 /// [`clap`] parser for [`ClonableCommand`] values.
 #[derive(Default, Clone)]
 pub struct ClonableCommandParser {
@@ -190,3 +216,25 @@ impl ValueParserFactory for ClonableCommand {
         Self::Parser::default()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse() {
+        // Note quotes, whitespace at both ends.
+        assert_eq!(
+            " puppy --flavor 'sammy' --eyes \"brown\" "
+                .parse::<ClonableCommand>()
+                .unwrap(),
+            ClonableCommand::new("puppy").args(["--flavor", "sammy", "--eyes", "brown"])
+        );
+
+        // But quoted whitespace is preserved.
+        assert_eq!(
+            " \" puppy\" ".parse::<ClonableCommand>().unwrap(),
+            ClonableCommand::new(" puppy")
+        );
+    }
+}

src/command_ext.rs

@@ -2,8 +2,6 @@ use std::process::Command as StdCommand;
 
 use command_group::AsyncCommandGroup;
 use command_group::AsyncGroupChild;
-use command_group::CommandGroup;
-use command_group::GroupChild;
 use miette::Context;
 use miette::IntoDiagnostic;
 use nix::sys::signal::pthread_sigmask;
@@ -14,45 +12,19 @@ use tokio::process::Command;
 
 /// Extension trait for commands.
 pub trait CommandExt {
-    /// The type of spawned processes.
-    type Child;
-
-    /// Spawn the command, but do not inherit `SIGINT` signals from the calling process.
-    fn spawn_group_without_inheriting_sigint(&mut self) -> miette::Result<Self::Child>;
-
     /// Display the command as a string, suitable for user output.
     ///
     /// Arguments and program names should be quoted with [`shell_words::quote`].
     fn display(&self) -> String;
 }
 
 impl CommandExt for Command {
-    type Child = AsyncGroupChild;
-
-    fn spawn_group_without_inheriting_sigint(&mut self) -> miette::Result<Self::Child> {
-        spawn_without_inheriting_sigint(|| {
-            self.group_spawn()
-                .into_diagnostic()
-                .wrap_err_with(|| format!("Failed to start `{}`", self.display()))
-        })
-    }
-
     fn display(&self) -> String {
         self.as_std().display()
     }
 }
 
 impl CommandExt for StdCommand {
-    type Child = GroupChild;
-
-    fn spawn_group_without_inheriting_sigint(&mut self) -> miette::Result<Self::Child> {
-        spawn_without_inheriting_sigint(|| {
-            self.group_spawn()
-                .into_diagnostic()
-                .wrap_err_with(|| format!("Failed to start `{}`", self.display()))
-        })
-    }
-
     fn display(&self) -> String {
         let program = self.get_program().to_string_lossy();
 
@@ -64,6 +36,26 @@ impl CommandExt for StdCommand {
     }
 }
 
+pub trait SpawnExt {
+    /// The type of spawned processes.
+    type Child;
+
+    /// Spawn the command, but do not inherit `SIGINT` signals from the calling process.
+    fn spawn_group_without_inheriting_sigint(&mut self) -> miette::Result<Self::Child>;
+}
+
+impl SpawnExt for Command {
+    type Child = AsyncGroupChild;
+
+    fn spawn_group_without_inheriting_sigint(&mut self) -> miette::Result<Self::Child> {
+        spawn_without_inheriting_sigint(|| {
+            self.group_spawn()
+                .into_diagnostic()
+                .wrap_err_with(|| format!("Failed to start `{}`", self.display()))
+        })
+    }
+}
+
 fn spawn_without_inheriting_sigint<T>(
     spawn: impl FnOnce() -> miette::Result<T>,
 ) -> miette::Result<T> {

src/ghci/mod.rs

@@ -8,8 +8,10 @@ use std::collections::BTreeSet;
 use std::fmt::Debug;
 use std::fmt::Display;
 use std::path::Path;
+use std::process::ExitStatus;
 use std::process::Stdio;
 use std::time::Instant;
+use tokio::task::JoinHandle;
 
 use aho_corasick::AhoCorasick;
 use camino::Utf8Path;
@@ -57,6 +59,7 @@ use crate::buffers::LINE_BUFFER_CAPACITY;
 use crate::cli::HookOpts;
 use crate::cli::Opts;
 use crate::clonable_command::ClonableCommand;
+use crate::command_ext::SpawnExt;
 use crate::event_filter::FileEvent;
 use crate::format_bulleted_list;
 use crate::haskell_source_file::is_haskell_source_file;
@@ -157,6 +160,8 @@ pub struct Ghci {
     eval_commands: BTreeMap<NormalPath, Vec<EvalCommand>>,
     /// Search paths / current working directory for this `ghci` session.
     search_paths: ShowPaths,
+    /// Tasks running `async:` shell commands in the background.
+    command_handles: Vec<JoinHandle<miette::Result<ExitStatus>>>,
 }
 
 impl Debug for Ghci {
@@ -174,9 +179,14 @@ impl Ghci {
     /// streams.
     #[instrument(skip_all, level = "debug", name = "ghci")]
     pub async fn new(mut shutdown: ShutdownHandle, opts: GhciOpts) -> miette::Result<Self> {
-        for command in &opts.hooks.before_startup_shell {
-            shutdown.error_if_shutdown_requested()?;
-            Self::before_startup_shell(command).await?;
+        let mut command_handles = Vec::new();
+        {
+            let span = tracing::debug_span!("before_startup_shell");
+            let _enter = span.enter();
+            for command in &opts.hooks.before_startup_shell {
+                tracing::info!(%command, "Running before-startup command");
+                command.run_on(&mut command_handles).await?;
+            }
         }
 
         let mut group = {
@@ -271,6 +281,7 @@ impl Ghci {
                 cwd: crate::current_dir_utf8()?,
                 search_paths: Default::default(),
             },
+            command_handles,
         })
     }
 
@@ -410,6 +421,10 @@ impl Ghci {
                 tracing::info!(%command, "Running after-restart command");
                 self.stdin.run_command(&mut self.stdout, command).await?;
             }
+            for command in &self.opts.hooks.after_restart_shell {
+                tracing::info!(%command, "Running after-restart command");
+                command.run_on(&mut self.command_handles).await?;
+            }
             // Once we restart, everything is freshly loaded. We don't need to add or
             // reload any other modules.
             return Ok(());
@@ -455,6 +470,10 @@ impl Ghci {
                 tracing::info!(%command, "Running after-reload command");
                 self.stdin.run_command(&mut self.stdout, command).await?;
             }
+            for command in &self.opts.hooks.after_reload_shell {
+                tracing::info!(%command, "Running after-reload command");
+                command.run_on(&mut self.command_handles).await?;
+            }
 
             if compilation_failed {
                 tracing::debug!("Compilation failed, skipping running tests.");
@@ -465,6 +484,9 @@ impl Ghci {
             }
         }
 
+        // Get rid of any handles for background commands that have finished.
+        self.command_handles.retain(|handle| !handle.is_finished());
+
         Ok(())
     }
 

src/lib.rs

@@ -25,6 +25,7 @@ mod ghci;
 mod haskell_source_file;
 mod ignore;
 mod incremental_reader;
+mod maybe_async_command;
 mod normal_path;
 mod shutdown;
 mod tracing;