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"
@@ -401,7 +395,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rexec"
-version = "1.5.1"
+version = "1.4.0"
 dependencies = [
  "brace-expand",
  "clap",
@@ -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.2"
+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

@@ -2,9 +2,8 @@ extern crate log;
 
 use std::fs::read_to_string;
 use std::hash::Hash;
-use std::io::{self, BufRead, BufReader};
+use std::io::{BufRead, BufReader};
 use std::net::IpAddr;
-use std::path::{Path, PathBuf};
 use std::process::{self, Command, Stdio};
 use std::sync::{Arc, Mutex};
 use std::thread;
@@ -14,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)]
@@ -158,78 +151,26 @@ fn shorten_hostname(hostname: &str, common_suffix: &Option<String>) -> String {
     }
 }
 
-/// Resolve the default SSH known_hosts path for the current user.
-fn default_known_hosts_path() -> PathBuf {
-    let home = std::env::var_os("HOME")
-        .map(PathBuf::from)
-        .filter(|path| !path.as_os_str().is_empty())
-        .unwrap_or_else(|| PathBuf::from(format!("/home/{}", whoami::username())));
-
-    home.join(".ssh").join("known_hosts")
-}
-
-fn normalize_known_host_entry(entry: &str) -> Option<String> {
-    if entry.is_empty() || entry.starts_with('|') {
-        return None;
-    }
-
-    let hostname = entry
-        .strip_prefix('[')
-        .and_then(|value| value.split_once("]:").map(|(host, _)| host))
-        .unwrap_or(entry);
-
-    if hostname.is_empty() {
-        None
-    } else {
-        Some(hostname.to_string())
-    }
-}
-
-fn parse_known_hosts(content: &str) -> Vec<Host> {
-    let mut result: Vec<Host> = Vec::new();
-
-    for line in content.lines() {
-        let line = line.trim();
-
-        if line.is_empty() || line.starts_with('#') {
-            continue;
-        }
-
-        let mut fields = line.split_whitespace();
-        let first = match fields.next() {
-            Some(field) => field,
-            None => continue,
-        };
-
-        let hostnames = if first.starts_with('@') {
-            match fields.next() {
-                Some(field) => field,
-                None => continue,
-            }
-        } else {
-            first
-        };
-
-        for hostname in hostnames.split(',').filter_map(normalize_known_host_entry) {
-            result.push(Host {
-                name: hostname,
-                ip: None,
-            });
-        }
-    }
-
-    result
-}
-
 /// Read and parse the SSH known_hosts file to extract server names
 ///
-/// # Arguments
-/// * `path` - Path to the known_hosts file
-///
 /// # Returns
-/// * `io::Result<Vec<Host>>` - List of hosts found in the known_hosts file
+/// * `Vec<Host>` - List of hosts found in the known_hosts file
-fn read_known_hosts(path: &Path) -> io::Result<Vec<Host>> {
+fn read_known_hosts() -> Vec<Host> {
-    read_to_string(path).map(|content| parse_known_hosts(&content))
+    let mut result: Vec<Host> = Vec::new();
+
+    // Read known_hosts file from the user's home directory
+    for line in read_to_string(format!("/home/{}/.ssh/known_hosts", whoami::username()))
+        .unwrap()
+        .lines()
+    {
+        let line = line.split(" ").collect::<Vec<&str>>();
+        let hostname = line[0];
+        result.push(Host {
+            name: hostname.to_string(),
+            ip: None,
+        })
+    }
+    result
 }
 
 /// Expand a numeric range in the format [start:end] to a list of strings
@@ -349,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
@@ -367,58 +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, 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) => {
-                    handle_output(line, &display_name_stdout, code_only_stdout, false);
+                    if !code_only_stdout {
-                    // false = stdout
+                        println!(
+                            "{} {} {} {}",
+                            prefix,
+                            display_name_stdout.yellow(),
+                            prefix,
+                            line
+                        );
+                    }
                 }
                 Err(_) => break,
             }
@@ -431,12 +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, true);
+                    if !code_only_stderr {
-                    // true = stderr
+                        println!(
+                            "{} {} {} {}",
+                            prefix,
+                            display_name_stderr.yellow(),
+                            prefix,
+                            line
+                        );
+                    }
                 }
                 Err(_) => break,
             }
@@ -453,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 {
@@ -472,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)
 }
@@ -494,19 +405,8 @@ fn main() {
     // Build the list of target hosts based on user selection method
     let hosts = if args.known_hosts {
         // Use regex pattern matching against known_hosts file
-        let known_hosts_path = default_known_hosts_path();
+        info!("Using ~/.ssh/known_hosts to build server list.");
-        info!("Using {} to build server list.", known_hosts_path.display());
+        let known_hosts = read_known_hosts();
-        let known_hosts = match read_known_hosts(&known_hosts_path) {
-            Ok(hosts) => hosts,
-            Err(e) => {
-                error!(
-                    "Failed to read known_hosts file {}: {}",
-                    known_hosts_path.display(),
-                    e
-                );
-                process::exit(1);
-            }
-        };
         let mut all_hosts = Vec::new();
         for expression in args.expression.iter() {
             let re = match Regex::new(expression) {
@@ -688,41 +588,3 @@ fn main() {
         processed = end;
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parse_known_hosts_extracts_usable_hosts() {
-        let content = r#"
-# comment
-admin.example.com ssh-ed25519 AAAA
-web.example.com,192.0.2.10 ecdsa-sha2-nistp256 AAAA
-@cert-authority *.example.com ssh-rsa AAAA
-|1|salt|hash ssh-ed25519 AAAA
-[custom.example.com]:2222 ssh-rsa AAAA
-"#;
-
-        let hosts: Vec<_> = parse_known_hosts(content)
-            .iter()
-            .map(|host| host.name.as_str())
-            .collect();
-
-        assert_eq!(
-            hosts,
-            vec![
-                "admin.example.com",
-                "web.example.com",
-                "192.0.2.10",
-                "*.example.com",
-                "custom.example.com"
-            ]
-        );
-    }
-
-    #[test]
-    fn normalize_known_host_entry_skips_hashed_entries() {
-        assert_eq!(normalize_known_host_entry("|1|salt|hash"), None);
-    }
-}