Format Rust code using rustfmt

Cargo.lock

@@ -266,12 +266,6 @@ 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"
@@ -410,7 +404,6 @@ dependencies = [
  "env_logger",
  "itertools",
  "lazy-st",
- "lazy_static",
  "log",
  "question",
  "rayon",

Cargo.toml

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

src/main.rs

@@ -13,17 +13,11 @@ 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)]
@@ -296,6 +290,9 @@ 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
@@ -314,46 +311,26 @@ 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| {
-        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
-            println!("│ {} │ {}", display_name.yellow(), 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) => {
-                    handle_output(line, &display_name_stdout, code_only_stdout);
+                    if !code_only_stdout {
+                        println!(
+                            "{} {} {} {}",
+                            prefix,
+                            display_name_stdout.yellow(),
+                            prefix,
+                            line
+                        );
+                    }
                 }
                 Err(_) => break,
             }
@@ -366,11 +343,20 @@ 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) => {
-                    handle_output(line, &display_name_stderr, code_only_stderr);
+                    if !code_only_stderr {
+                        println!(
+                            "{} {} {} {}",
+                            prefix,
+                            display_name_stderr.yellow(),
+                            prefix,
+                            line
+                        );
+                    }
                 }
                 Err(_) => break,
             }
@@ -387,17 +373,6 @@ 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 {
@@ -406,10 +381,12 @@ fn execute_ssh_command(
         format!("{}", exit_code.to_string().red())
     };
 
-    // For code-only mode, just show hostname and exit code
+    // Display completion message
-    if code_only {
+    println!(
-        println!("{}: [{}]", display_name.yellow(), code_string);
+        "{} - COMPLETED (Exit code: [{}])",
-    }
+        display_name.yellow().bold(),
+        code_string
+    );
 
     Ok(exit_code)
 }