use std::ops::ControlFlow;
use crate::{
config::{self, StartTogetherOptions},
errors::TogetherResult,
log, log_err,
manager::{self, ProcessAction},
process, t_println,
terminal::Terminal,
terminal_ext::TerminalExt,
};
#[derive(Default)]
struct InputState {
requested_quit: bool,
awaiting_quit_command: bool,
last_command: Option<BufferedCommand>,
}
enum BufferedCommand {
Start(String),
Restart(String, process::ProcessId),
}
enum Key {
#[cfg(feature = "termion")]
CtrlC,
Char(char),
}
#[cfg(feature = "termion")]
impl TryFrom<termion::event::Key> for Key {
type Error = ();
fn try_from(key: termion::event::Key) -> Result<Self, Self::Error> {
match key {
termion::event::Key::Ctrl('c') => Ok(Self::CtrlC),
termion::event::Key::Char(c) => Ok(Self::Char(c)),
_ => Err(()),
}
}
}
impl From<char> for Key {
fn from(c: char) -> Self {
Self::Char(c)
}
}
#[cfg(feature = "termion")]
pub fn block_for_user_input(
start_opts: &StartTogetherOptions,
sender: manager::ProcessManagerHandle,
) -> TogetherResult<()> {
use std::io::Write;
use termion::input::TermRead;
let mut state = InputState::default();
let mut stdout = std::io::stdout();
let stdin = std::io::stdin();
for k in stdin.keys() {
let Ok(k): Result<Key, ()> = k?.try_into() else {
continue;
};
match handle_key_press(k, &mut state, start_opts, &sender) {
Ok(ControlFlow::Continue(_)) => {
write!(stdout, "{}", termion::cursor::Show).unwrap();
stdout.flush().unwrap();
}
Ok(ControlFlow::Break(_)) => break,
Err(e) => {
log_err!("Unexpected error: {:?}", e);
}
}
}
drop(stdout);
Ok(())
}
#[cfg(not(feature = "termion"))]
pub fn block_for_user_input(
start_opts: &StartTogetherOptions,
sender: manager::ProcessManagerHandle,
) -> TogetherResult<()> {
let mut state = InputState::default();
let mut input = String::new();
loop {
std::io::stdin().read_line(&mut input)?;
let Some(key) = input.trim().chars().next() else {
continue;
};
match handle_key_press(key.into(), &mut state, start_opts, &sender) {
Ok(ControlFlow::Continue(_)) => {}
Ok(ControlFlow::Break(_)) => break,
Err(e) => {
log_err!("Unexpected error: {:?}", e);
}
}
input.clear();
}
Ok(())
}
fn handle_key_press(
key: Key,
state: &mut InputState,
start_opts: &StartTogetherOptions,
sender: &manager::ProcessManagerHandle,
) -> TogetherResult<ControlFlow<()>> {
if state.requested_quit {
state.requested_quit = false;
state.awaiting_quit_command = true;
}
match key {
#[cfg(feature = "termion")]
Key::CtrlC => {
log!("Ctrl-C pressed, stopping all processes...");
sender
.send(ProcessAction::KillAll)
.expect("Could not send signal on channel.");
}
Key::Char('h') | Key::Char('?') => {
log!("[help]");
t_println!("together is a tool to run multiple commands in parallel selectively by an interactive prompt.");
t_println!();
t_println!("Press 't' to trigger a one-time run");
t_println!("Press '.' to re-trigger the last one-time run or restart action");
if let Some(last) = &state.last_command {
t_println!(
" (last command: [{}] {})",
match last {
BufferedCommand::Start(_) => "start",
BufferedCommand::Restart(_, _) => "restart",
},
match last {
BufferedCommand::Start(command) => command,
BufferedCommand::Restart(command, _) => command,
}
);
}
t_println!("Press 'b' to batch trigger commands by recipe");
t_println!("Press 'z' to switch to running a single recipe");
t_println!("Press 'k' to kill a running command");
t_println!("Press 'r' to restart a running command");
t_println!("Press 'l' to list all running commands");
t_println!("Press 'd' to dump the current configuration");
t_println!("Press 'h' or '?' to show this help message");
t_println!("Press 'q' to stop");
t_println!();
t_println!();
log!("[status]");
match sender.list() {
Ok(list) => {
t_println!("together is running {} commands in parallel:", list.len());
for command in list {
t_println!(" {}", command);
}
}
Err(_) => {
t_println!("together is running in an unknown state");
}
}
}
Key::Char('q') => {
if state.awaiting_quit_command {
log!("Quitting together...");
sender.send(ProcessAction::KillAll)?;
return Ok(ControlFlow::Break(()));
}
log!("Press 'q' again to quit together");
state.requested_quit = true;
return Ok(ControlFlow::Break(()));
}
Key::Char('l') => {
for command in sender.list()? {
t_println!("{}", command);
}
}
Key::Char('d') => {
let list = sender.list()?;
let running: Vec<_> = list.iter().map(|c| c.command()).collect();
let config = start_opts.config.clone();
let config = config.with_running(&running);
config::dump(&config)?;
}
Key::Char('k') => {
let list = sender.list()?;
let command = Terminal::select_single_process(
"Pick command to kill, or press 'q' to cancel",
&sender,
&list,
)?;
if let Some(command) = command {
sender.kill(command.clone())?;
}
}
Key::Char('K') => {
let list = sender.list()?;
let command = Terminal::select_single_process(
"Pick command to kill, or press 'q' to cancel",
&sender,
&list,
)?;
let signal = command.and_then(|_| {
Terminal::select_single(
"Pick signal to send, or press 'q' to cancel",
&["SIGINT", "SIGTERM", "SIGKILL"],
)
});
let target = signal
.and_then(|signal| match *signal {
"SIGINT" => Some(process::ProcessSignal::SIGINT),
"SIGTERM" => Some(process::ProcessSignal::SIGTERM),
"SIGKILL" => Some(process::ProcessSignal::SIGKILL),
_ => None,
})
.and_then(|signal| command.map(|command| (command, signal)));
if let Some((command, signal)) = target {
sender.send(ProcessAction::KillAdvanced(command.clone(), signal))?;
}
}
Key::Char('r') => {
let list = sender.list()?;
let command = Terminal::select_single_process(
"Pick command to restart, or press 'q' to cancel",
&sender,
&list,
)?;
if let Some(command) = command {
sender.send(ProcessAction::Kill(command.clone()))?;
let process_id = sender.spawn(command.command())?;
state.last_command = Some(BufferedCommand::Restart(
command.command().to_string(),
process_id,
));
}
}
Key::Char('t') => {
let list = sender.list()?;
let command = Terminal::select_single_command_with_running(
"Pick command to run, or press 'q' to cancel",
&sender,
&start_opts.config.start_options.commands,
&list,
)?;
if let Some(command) = command {
sender.spawn(command)?;
state.last_command = Some(BufferedCommand::Start(command.to_string()));
}
}
Key::Char('.') => match &state.last_command {
Some(BufferedCommand::Start(command)) => {
sender.spawn(command)?;
}
Some(BufferedCommand::Restart(command, process_id)) => {
match sender.restart(process_id.clone(), &command)? {
Some(id) => {
let command = command.clone();
state.last_command = Some(BufferedCommand::Restart(command, id))
}
None => {
log_err!("Could not find process to restart");
}
};
}
_ => {
log!("No last command to re-trigger");
}
},
Key::Char('b') => {
let all_recipes = config::get_unique_recipes(&start_opts.config.start_options);
let all_recipes = all_recipes.into_iter().cloned().collect::<Vec<_>>();
let recipes = Terminal::select_multiple_recipes(
"Select one or more recipes to start running, or press 'q' to cancel",
&sender,
&all_recipes,
)?;
let commands =
config::collect_commands_by_recipes(&start_opts.config.start_options, &recipes);
for command in commands {
sender.send(ProcessAction::Create(command.clone()))?;
}
}
Key::Char('z') => {
let all_recipes = config::get_unique_recipes(&start_opts.config.start_options);
let all_recipes = all_recipes.into_iter().cloned().collect::<Vec<_>>();
let recipe = Terminal::select_single_recipe(
"Select a recipe to start running, or press 'q' to cancel (note: this will stop all other commands)",
&sender,
&all_recipes,
)?;
if let Some(recipe) = recipe {
let recipe = recipe.clone();
let recipe_commands = config::collect_commands_by_recipes(
&start_opts.config.start_options,
&[recipe],
);
let list = sender.list()?;
let kill_commands: Vec<_> = list
.iter()
.filter(|c| !recipe_commands.contains(&c.command().to_string()))
.collect();
for command in kill_commands {
sender.kill(command.clone())?;
}
for command in recipe_commands {
sender.spawn(&command)?;
}
}
}
Key::Char('\n') => {}
Key::Char(c) => {
log_err!("Unknown command: '{}'", c);
log!("Press 'h' or '?' for help");
}
}
state.awaiting_quit_command = false;
Ok(ControlFlow::Continue(()))
}