feat: Migrate to Rust 2024 edition

- Update edition from 2021 to 2024 in both Cargo.toml files
  - Cargo.toml (bssh main package)
  - crates/bssh-russh/Cargo.toml (SSH library fork)

- Fix pattern matching for 2024 edition:
  - Remove explicit 'ref' and 'ref mut' bindings in if-let patterns
  - 2024 edition uses implicit borrowing in patterns
  - Updated session_info to mutable variable where needed
  - src/server/handler.rs (4 pattern changes)
  - src/server/shell.rs (1 pattern change)

- Code changes summary:
  - 119 files reformatted by rustfmt
  - No breaking API changes
  - All unsafe code, macros, async/await remain compatible
  - All dependencies support 2024 edition

- Compilation status:
  - cargo build --release: ✅ SUCCESS
  - All binaries (bssh, bssh-server, bssh-keygen) compile correctly

2024 edition improvements applied:
- Implicit pattern borrowing eliminates need for 'ref'/'ref mut'
- Support for guard clauses (if let X = Y && condition)
- Better error messages and compile-time checks

Author: inureyes

Cargo.toml

@@ -14,7 +14,7 @@ repository = "https://github.com/lablup/bssh"
 readme = "README.md"
 keywords = ["cli", "rust"]
 categories = ["command-line-utilities"]
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 bytes = "1.11.1"

benches/large_output_benchmark.rs

@@ -25,9 +25,9 @@ use bssh::node::Node;
 use bssh::ssh::tokio_client::CommandOutput;
 use bssh::ui::tui::app::TuiApp;
 use bytes::Bytes;
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
-use ratatui::backend::TestBackend;
+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use ratatui::Terminal;
+use ratatui::backend::TestBackend;
 use std::hint::black_box;
 use tokio::runtime::Runtime;
 use tokio::sync::mpsc;

crates/bssh-russh/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.60.1"
 authors = ["Jeongkyu Shin <inureyes@gmail.com>"]
 description = "Temporary fork of russh with high-frequency PTY output fix (Handle::data from spawned tasks)"
 documentation = "https://docs.rs/bssh-russh"
-edition = "2021"
+edition = "2024"
 homepage = "https://github.com/lablup/bssh"
 keywords = ["ssh"]
 license = "Apache-2.0"

src/app/dispatcher.rs

@@ -19,23 +19,23 @@ use bssh::{
     cli::{Cli, Commands},
     commands::{
         download::download_file,
-        exec::{execute_command, ExecuteCommandParams},
+        exec::{ExecuteCommandParams, execute_command},
         interactive::InteractiveCommand,
         list::list_clusters,
         ping::ping_nodes,
-        upload::{upload_file, FileTransferParams},
+        upload::{FileTransferParams, upload_file},
     },
     config::InteractiveMode,
     pty::PtyConfig,
     security::get_sudo_password,
-    ssh::tokio_client::{SshConnectionConfig, DEFAULT_KEEPALIVE_INTERVAL, DEFAULT_KEEPALIVE_MAX},
+    ssh::tokio_client::{DEFAULT_KEEPALIVE_INTERVAL, DEFAULT_KEEPALIVE_MAX, SshConnectionConfig},
 };
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 #[cfg(target_os = "macos")]
 use super::initialization::determine_use_keychain;
-use super::initialization::{determine_ssh_key_path, AppContext};
+use super::initialization::{AppContext, determine_ssh_key_path};
 use super::utils::format_duration;
 
 /// Build SSH connection config with keepalive settings.

src/app/initialization.rs

@@ -20,7 +20,7 @@ use bssh::{
     config::Config,
     jump::parse_jump_hosts,
     node::Node,
-    ssh::{known_hosts::StrictHostKeyChecking, SshConfig},
+    ssh::{SshConfig, known_hosts::StrictHostKeyChecking},
     utils::init_logging,
 };
 use std::path::PathBuf;
@@ -275,15 +275,15 @@ pub fn determine_strict_host_key_checking(
     }
 
     // SSH config value for specific hostname
-    if let Some(host) = hostname {
-        if let Some(ssh_config_value) = ssh_config.get_strict_host_key_checking(host) {
-            return match ssh_config_value.to_lowercase().as_str() {
-                "yes" => StrictHostKeyChecking::Yes,
-                "no" => StrictHostKeyChecking::No,
-                "ask" | "accept-new" => StrictHostKeyChecking::AcceptNew,
-                _ => StrictHostKeyChecking::AcceptNew,
-            };
-        }
+    if let Some(host) = hostname
+        && let Some(ssh_config_value) = ssh_config.get_strict_host_key_checking(host)
+    {
+        return match ssh_config_value.to_lowercase().as_str() {
+            "yes" => StrictHostKeyChecking::Yes,
+            "no" => StrictHostKeyChecking::No,
+            "ask" | "accept-new" => StrictHostKeyChecking::AcceptNew,
+            _ => StrictHostKeyChecking::AcceptNew,
+        };
     }
 
     // Default from CLI (already parsed)

src/app/nodes.rs

@@ -562,10 +562,12 @@ mod tests {
         let result = exclude_nodes(nodes, &patterns);
 
         assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("too many wildcards"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("too many wildcards")
+        );
     }
 
     #[test]
@@ -575,10 +577,12 @@ mod tests {
         let result = exclude_nodes(nodes, &patterns);
 
         assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("invalid characters"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("invalid characters")
+        );
     }
 
     #[test]
@@ -588,10 +592,12 @@ mod tests {
         let result = exclude_nodes(nodes, &patterns);
 
         assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("invalid sequences"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("invalid sequences")
+        );
     }
 
     #[test]

src/bin/bssh_keygen.rs

@@ -123,11 +123,11 @@ fn main() -> Result<()> {
     };
 
     // Ensure parent directory exists
-    if let Some(parent) = output.parent() {
-        if !parent.exists() {
-            std::fs::create_dir_all(parent)
-                .with_context(|| format!("Failed to create directory: {}", parent.display()))?;
-        }
+    if let Some(parent) = output.parent()
+        && !parent.exists()
+    {
+        std::fs::create_dir_all(parent)
+            .with_context(|| format!("Failed to create directory: {}", parent.display()))?;
     }
 
     // Check if file exists and prompt for overwrite

src/bin/bssh_server.rs

@@ -17,8 +17,8 @@
 //! This binary provides a command-line interface for managing the bssh SSH server.
 
 use anyhow::{Context, Result};
-use bssh::server::config::{generate_config_template, load_config, ServerFileConfig};
 use bssh::server::BsshServer;
+use bssh::server::config::{ServerFileConfig, generate_config_template, load_config};
 use bssh::utils::logging;
 use clap::{ArgAction, Parser, Subcommand};
 use std::fs;
@@ -471,37 +471,36 @@ fn setup_signal_handlers() -> Result<impl std::future::Future<Output = ()>> {
 /// Write the current process ID to a PID file
 fn write_pid_file(path: &PathBuf) -> Result<()> {
     // Check if PID file already exists and refers to a running process
-    if path.exists() {
-        if let Ok(existing_pid_str) = fs::read_to_string(path) {
-            if let Ok(existing_pid) = existing_pid_str.trim().parse::<i32>() {
-                // Check if process is still running
-                #[cfg(unix)]
-                {
-                    use nix::sys::signal::kill;
-                    use nix::unistd::Pid;
-
-                    let pid = Pid::from_raw(existing_pid);
-                    // Use signal 0 (None) to check if process exists without sending actual signal
-                    if kill(pid, None).is_ok() {
-                        anyhow::bail!(
-                            "Another instance is already running with PID {}. \
+    if path.exists()
+        && let Ok(existing_pid_str) = fs::read_to_string(path)
+        && let Ok(existing_pid) = existing_pid_str.trim().parse::<i32>()
+    {
+        // Check if process is still running
+        #[cfg(unix)]
+        {
+            use nix::sys::signal::kill;
+            use nix::unistd::Pid;
+
+            let pid = Pid::from_raw(existing_pid);
+            // Use signal 0 (None) to check if process exists without sending actual signal
+            if kill(pid, None).is_ok() {
+                anyhow::bail!(
+                    "Another instance is already running with PID {}. \
                              If this is incorrect, remove {} and try again.",
-                            existing_pid,
-                            path.display()
-                        );
-                    }
-                }
-
-                #[cfg(not(unix))]
-                {
-                    // On non-Unix systems, warn but allow overwrite
-                    tracing::warn!(
-                        "PID file exists with PID {}. Overwriting (process check not available on this platform).",
-                        existing_pid
-                    );
-                }
+                    existing_pid,
+                    path.display()
+                );
             }
         }
+
+        #[cfg(not(unix))]
+        {
+            // On non-Unix systems, warn but allow overwrite
+            tracing::warn!(
+                "PID file exists with PID {}. Overwriting (process check not available on this platform).",
+                existing_pid
+            );
+        }
     }
 
     let pid = std::process::id();
@@ -798,10 +797,12 @@ mod tests {
 
         let result = gen_host_key("rsa", &key_path, 1024);
         assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("RSA key size must be at least 2048"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("RSA key size must be at least 2048")
+        );
     }
 
     #[test]

src/cli/bssh.rs

@@ -444,12 +444,12 @@ pub enum Commands {
 impl Cli {
     pub fn get_command(&self) -> String {
         // In multi-server mode with destination, treat destination as first command arg
-        if self.is_multi_server_mode() {
-            if let Some(dest) = &self.destination {
-                let mut all_args = vec![dest.clone()];
-                all_args.extend(self.command_args.clone());
-                return all_args.join(" ");
-            }
+        if self.is_multi_server_mode()
+            && let Some(dest) = &self.destination
+        {
+            let mut all_args = vec![dest.clone()];
+            all_args.extend(self.command_args.clone());
+            return all_args.join(" ");
         }
         if !self.command_args.is_empty() {
             self.command_args.join(" ")
@@ -567,10 +567,10 @@ impl Cli {
 
         // Check SSH options for Port=
         for opt in &self.ssh_options {
-            if let Some(port_str) = opt.strip_prefix("Port=") {
-                if let Ok(port) = port_str.parse::<u16>() {
-                    return Some(port);
-                }
+            if let Some(port_str) = opt.strip_prefix("Port=")
+                && let Ok(port) = port_str.parse::<u16>()
+            {
+                return Some(port);
             }
         }
 

src/cli/mod.rs

@@ -44,6 +44,6 @@ pub use bssh::{Cli, Commands};
 
 // Re-export pdsh compatibility utilities
 pub use pdsh::{
-    has_pdsh_compat_flag, is_pdsh_compat_mode, remove_pdsh_compat_flag, PdshCli, QueryResult,
-    PDSH_COMPAT_ENV_VAR,
+    PDSH_COMPAT_ENV_VAR, PdshCli, QueryResult, has_pdsh_compat_flag, is_pdsh_compat_mode,
+    remove_pdsh_compat_flag,
 };