Improved live logging

Cargo.lock

@@ -266,6 +266,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2a61bcce320b4968c46542aabe3d14e4d40ad6a6089eeced644326e73f6279a"
 
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libc"
 version = "0.2.172"
@@ -395,7 +401,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rexec"
-version = "1.4.0"
+version = "1.5.0"
 dependencies = [
  "brace-expand",
  "clap",
@@ -404,6 +410,7 @@ dependencies = [
  "env_logger",
  "itertools",
  "lazy-st",
+ "lazy_static",
  "log",
  "question",
  "rayon",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rexec"
-version = "1.4.0"
+version = "1.5.1"
 readme = "https://github.com/house-of-vanity/rexec#readme"
 edition = "2021"
 description = "Parallel SSH executor"
@@ -25,3 +25,4 @@ colored = "3"
 itertools = "0.14"
 brace-expand = "0.1.0"
 question = "0.2.2"
+lazy_static = "1.5.0"

src/main.rs

@@ -13,11 +13,17 @@ use colored::*;
 use dns_lookup::lookup_host;
 use env_logger::Env;
 use itertools::Itertools;
+use lazy_static::lazy_static;
 use log::{error, info, warn};
 use question::{Answer, Question};
 use rayon::prelude::*;
 use regex::Regex;
 
+// Global state to track the currently open block
+lazy_static! {
+    static ref CURRENT_BLOCK: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
+}
+
 // Define command-line arguments using the clap library
 #[derive(Parser, Debug)]
 #[command(author = "AB ab@hexor.ru", version, about = "Parallel SSH executor in Rust", long_about = None)]
@@ -290,9 +296,6 @@ fn execute_ssh_command(
 ) -> Result<i32, String> {
     let display_name = shorten_hostname(hostname, common_suffix);
 
-    // Display execution start message with shortened hostname
-    println!("\n{} - STARTED", display_name.yellow().bold());
-
     // Build the SSH command with appropriate options
     let mut ssh_cmd = Command::new("ssh");
     ssh_cmd
@@ -311,26 +314,58 @@ fn execute_ssh_command(
         Err(e) => return Err(format!("Failed to start SSH process: {}", e)),
     };
 
+    // Function to handle output lines with proper block management
+    let handle_output = |line: String, display_name: &str, code_only: bool, is_stderr: bool| {
+        if !code_only {
+            let mut current_block = CURRENT_BLOCK.lock().unwrap();
+
+            // Check if we need to close the previous block and open a new one
+            match current_block.as_ref() {
+                Some(open_host) if open_host != display_name => {
+                    // Close the previous block
+                    println!("└ {} ┘", open_host.yellow());
+                    // Open new block
+                    println!("┌ {} ┐", display_name.yellow());
+                    *current_block = Some(display_name.to_string());
+                }
+                None => {
+                    // Open new block
+                    println!("┌ {} ┐", display_name.yellow());
+                    *current_block = Some(display_name.to_string());
+                }
+                Some(_) => {
+                    // Same host, continue with current block
+                }
+            }
+
+            // Print the log line with colored separator based on stream type
+            let separator = if is_stderr {
+                "│".red()
+            } else {
+                "│".green()
+            };
+            println!(
+                "{} {} {} {}",
+                separator,
+                display_name.yellow(),
+                separator,
+                line
+            );
+        }
+    };
+
     // Capture and display stdout in real-time using a dedicated thread
     let stdout = child.stdout.take().unwrap();
     let display_name_stdout = display_name.clone();
     let code_only_stdout = code_only;
     let stdout_thread = thread::spawn(move || {
         let reader = BufReader::new(stdout);
-        let prefix = format!("{}", "║".green());
 
         for line in reader.lines() {
             match line {
                 Ok(line) => {
-                    if !code_only_stdout {
+                    handle_output(line, &display_name_stdout, code_only_stdout, false);
-                        println!(
+                    // false = stdout
-                            "{} {} {} {}",
-                            prefix,
-                            display_name_stdout.yellow(),
-                            prefix,
-                            line
-                        );
-                    }
                 }
                 Err(_) => break,
             }
@@ -343,20 +378,12 @@ fn execute_ssh_command(
     let code_only_stderr = code_only;
     let stderr_thread = thread::spawn(move || {
         let reader = BufReader::new(stderr);
-        let prefix = format!("{}", "║".red());
 
         for line in reader.lines() {
             match line {
                 Ok(line) => {
-                    if !code_only_stderr {
+                    handle_output(line, &display_name_stderr, code_only_stderr, true);
-                        println!(
+                    // true = stderr
-                            "{} {} {} {}",
-                            prefix,
-                            display_name_stderr.yellow(),
-                            prefix,
-                            line
-                        );
-                    }
                 }
                 Err(_) => break,
             }
@@ -373,6 +400,17 @@ fn execute_ssh_command(
     stdout_thread.join().unwrap();
     stderr_thread.join().unwrap();
 
+    // Close the block if this host was the last one to output
+    if !code_only {
+        let mut current_block = CURRENT_BLOCK.lock().unwrap();
+        if let Some(open_host) = current_block.as_ref() {
+            if open_host == &display_name {
+                println!("└ {} ┘", display_name.yellow());
+                *current_block = None;
+            }
+        }
+    }
+
     // Format exit code with color (green for success, red for failure)
     let exit_code = status.code().unwrap_or(-1);
     let code_string = if exit_code == 0 {
@@ -381,12 +419,10 @@ fn execute_ssh_command(
         format!("{}", exit_code.to_string().red())
     };
 
-    // Display completion message
+    // For code-only mode, just show hostname and exit code
-    println!(
+    if code_only {
-        "{} - COMPLETED (Exit code: [{}])",
+        println!("{}: [{}]", display_name.yellow(), code_string);
-        display_name.yellow().bold(),
+    }
-        code_string
-    );
 
     Ok(exit_code)
 }