refactor: split SshConfig into SshCredentials and SshConnection

Splits SSH configuration into two focused types:
- SshCredentials: Static authentication info (username, key paths)
- SshConnection: Complete connection info (credentials + host IP)

This eliminates the need for placeholder IP addresses like '0.0.0.0'
and provides better type safety by separating static configuration
from runtime connection state.

Changes:
- Created SshCredentials with promotion method with_host()
- Created SshConnection with accessor methods
- Updated all usages in actions, steps, and command wrappers
- Removed original SshConfig struct
- Updated module exports and documentation

Author: josecelano

src/actions/cloud_init.rs

@@ -3,7 +3,7 @@ use tracing::info;
 
 use crate::actions::{RemoteAction, RemoteActionError};
 use crate::command_wrappers::ssh::SshClient;
-use crate::config::ssh::SshConfig;
+use crate::config::ssh::SshConnection;
 
 /// Action that checks if cloud-init has completed successfully on the server
 pub struct CloudInitValidator {
@@ -14,10 +14,10 @@ impl CloudInitValidator {
     /// Create a new `CloudInitValidator` with the specified SSH configuration
     ///
     /// # Arguments
-    /// * `ssh_config` - SSH configuration containing key path, username, host IP, etc.
+    /// * `ssh_connection` - SSH connection configuration containing credentials and host IP
     #[must_use]
-    pub fn new(ssh_config: SshConfig) -> Self {
-        let ssh_client = SshClient::new(ssh_config);
+    pub fn new(ssh_connection: SshConnection) -> Self {
+        let ssh_client = SshClient::new(ssh_connection);
         Self { ssh_client }
     }
 }

src/actions/docker.rs

@@ -3,7 +3,7 @@ use tracing::{info, warn};
 
 use crate::actions::{RemoteAction, RemoteActionError};
 use crate::command_wrappers::ssh::SshClient;
-use crate::config::ssh::SshConfig;
+use crate::config::ssh::SshConnection;
 
 /// Action that validates Docker installation and daemon status on the server
 pub struct DockerValidator {
@@ -14,10 +14,10 @@ impl DockerValidator {
     /// Create a new `DockerValidator` with the specified SSH configuration
     ///
     /// # Arguments
-    /// * `ssh_config` - SSH configuration containing key path, username, host IP, etc.
+    /// * `ssh_connection` - SSH connection configuration containing credentials and host IP
     #[must_use]
-    pub fn new(ssh_config: SshConfig) -> Self {
-        let ssh_client = SshClient::new(ssh_config);
+    pub fn new(ssh_connection: SshConnection) -> Self {
+        let ssh_client = SshClient::new(ssh_connection);
         Self { ssh_client }
     }
 }

src/actions/docker_compose.rs

@@ -3,7 +3,7 @@ use tracing::{info, warn};
 
 use crate::actions::{RemoteAction, RemoteActionError};
 use crate::command_wrappers::ssh::SshClient;
-use crate::config::ssh::SshConfig;
+use crate::config::ssh::SshConnection;
 
 /// Action that validates Docker Compose installation and basic functionality on the server
 pub struct DockerComposeValidator {
@@ -14,10 +14,10 @@ impl DockerComposeValidator {
     /// Create a new `DockerComposeValidator` with the specified SSH configuration
     ///
     /// # Arguments
-    /// * `ssh_config` - SSH configuration containing key path, username, host IP, etc.
+    /// * `ssh_connection` - SSH connection configuration containing credentials and host IP
     #[must_use]
-    pub fn new(ssh_config: SshConfig) -> Self {
-        let ssh_client = SshClient::new(ssh_config);
+    pub fn new(ssh_connection: SshConnection) -> Self {
+        let ssh_client = SshClient::new(ssh_connection);
         Self { ssh_client }
     }
 }

src/bin/e2e_tests.rs

@@ -8,7 +8,7 @@ use tracing::{error, info, warn};
 use tracing_subscriber::EnvFilter;
 
 // Import command execution system
-use torrust_tracker_deploy::config::{Config, SshConfig};
+use torrust_tracker_deploy::config::{Config, SshCredentials};
 use torrust_tracker_deploy::container::Services;
 // Import remote actions
 use torrust_tracker_deploy::actions::{
@@ -56,18 +56,14 @@ impl TestEnvironment {
         let temp_ssh_pub_key = temp_dir.path().join("testing_rsa.pub");
         Self::setup_ssh_key(&project_root, &temp_dir, &temp_ssh_key)?;
 
-        // Create configuration
-        // Note: Using placeholder IP since this config is used as a template - actual host IP will be set per connection
-        let placeholder_ip = "0.0.0.0".parse().expect("Valid IP address");
-        let ssh_config = SshConfig::new(
-            temp_ssh_key,
-            temp_ssh_pub_key,
-            "torrust".to_string(),
-            placeholder_ip,
-        );
+        // Create SSH credentials (no host IP needed yet)
+        let ssh_credentials =
+            SshCredentials::new(temp_ssh_key, temp_ssh_pub_key, "torrust".to_string());
+        
+        // Create main configuration
         let config = Config::new(
             keep_env,
-            ssh_config,
+            ssh_credentials,
             templates_dir,
             project_root.clone(),
             project_root.join("build"),
@@ -292,13 +288,8 @@ async fn validate_deployment(env: &TestEnvironment, instance_ip: &IpAddr) -> Res
         component = "cloud_init",
         "Validating cloud-init completion"
     );
-    let cloud_init_ssh_config = SshConfig::new(
-        env.config.ssh_config.ssh_priv_key_path.clone(),
-        env.config.ssh_config.ssh_pub_key_path.clone(),
-        env.config.ssh_config.ssh_username.clone(),
-        *instance_ip,
-    );
-    let cloud_init_validator = CloudInitValidator::new(cloud_init_ssh_config);
+    let cloud_init_ssh_connection = env.config.ssh_config.clone().with_host(*instance_ip);
+    let cloud_init_validator = CloudInitValidator::new(cloud_init_ssh_connection);
     cloud_init_validator
         .execute(instance_ip)
         .await
@@ -310,13 +301,8 @@ async fn validate_deployment(env: &TestEnvironment, instance_ip: &IpAddr) -> Res
         component = "docker",
         "Validating Docker installation"
     );
-    let docker_ssh_config = SshConfig::new(
-        env.config.ssh_config.ssh_priv_key_path.clone(),
-        env.config.ssh_config.ssh_pub_key_path.clone(),
-        env.config.ssh_config.ssh_username.clone(),
-        *instance_ip,
-    );
-    let docker_validator = DockerValidator::new(docker_ssh_config);
+    let docker_ssh_connection = env.config.ssh_config.clone().with_host(*instance_ip);
+    let docker_validator = DockerValidator::new(docker_ssh_connection);
     docker_validator
         .execute(instance_ip)
         .await
@@ -328,13 +314,8 @@ async fn validate_deployment(env: &TestEnvironment, instance_ip: &IpAddr) -> Res
         component = "docker_compose",
         "Validating Docker Compose installation"
     );
-    let docker_compose_ssh_config = SshConfig::new(
-        env.config.ssh_config.ssh_priv_key_path.clone(),
-        env.config.ssh_config.ssh_pub_key_path.clone(),
-        env.config.ssh_config.ssh_username.clone(),
-        *instance_ip,
-    );
-    let docker_compose_validator = DockerComposeValidator::new(docker_compose_ssh_config);
+    let docker_compose_ssh_connection = env.config.ssh_config.clone().with_host(*instance_ip);
+    let docker_compose_validator = DockerComposeValidator::new(docker_compose_ssh_connection);
     docker_compose_validator
         .execute(instance_ip)
         .await
@@ -363,13 +344,8 @@ async fn run_full_deployment_test(env: &TestEnvironment) -> Result<IpAddr> {
     let instance_ip = env.provision_infrastructure()?;
 
     // Wait for SSH connectivity
-    let wait_ssh_config = SshConfig::new(
-        env.config.ssh_config.ssh_priv_key_path.clone(),
-        env.config.ssh_config.ssh_pub_key_path.clone(),
-        env.config.ssh_config.ssh_username.clone(),
-        instance_ip,
-    );
-    let wait_ssh_step = WaitForSSHConnectivityStep::new(wait_ssh_config);
+    let wait_ssh_connection = env.config.ssh_config.clone().with_host(instance_ip);
+    let wait_ssh_step = WaitForSSHConnectivityStep::new(wait_ssh_connection);
     wait_ssh_step
         .execute()
         .await

src/command_wrappers/ssh.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 use tracing::info;
 
 use crate::command::{CommandError, CommandExecutor};
-use crate::config::ssh::SshConfig;
+use crate::config::ssh::SshConnection;
 
 /// Errors that can occur during SSH operations
 #[derive(Error, Debug)]
@@ -35,19 +35,19 @@ pub enum SshError {
 ///
 /// Uses `CommandExecutor` as a collaborator for actual command execution.
 pub struct SshClient {
-    ssh_config: SshConfig,
+    ssh_connection: SshConnection,
     command_executor: CommandExecutor,
 }
 
 impl SshClient {
     /// Creates a new `SshClient`
     ///
     /// # Arguments
-    /// * `ssh_config` - SSH configuration containing key path, username, host IP, etc.
+    /// * `ssh_connection` - SSH connection configuration containing credentials and host IP
     #[must_use]
-    pub fn new(ssh_config: SshConfig) -> Self {
+    pub fn new(ssh_connection: SshConnection) -> Self {
         Self {
-            ssh_config,
+            ssh_connection,
             command_executor: CommandExecutor::new(),
         }
     }
@@ -56,8 +56,8 @@ impl SshClient {
     fn build_ssh_args(&self, remote_command: &str, additional_options: &[&str]) -> Vec<String> {
         let mut args = vec![
             "-i".to_string(),
-            self.ssh_config
-                .ssh_priv_key_path
+            self.ssh_connection
+                .ssh_priv_key_path()
                 .to_string_lossy()
                 .to_string(),
             "-o".to_string(),
@@ -74,7 +74,8 @@ impl SshClient {
 
         args.push(format!(
             "{}@{}",
-            self.ssh_config.ssh_username, self.ssh_config.host_ip
+            self.ssh_connection.ssh_username(),
+            self.ssh_connection.host_ip
         ));
         args.push(remote_command.to_string());
 
@@ -193,7 +194,7 @@ impl SshClient {
     pub async fn wait_for_connectivity(&self) -> Result<(), SshError> {
         info!(
             operation = "ssh_connectivity",
-            host_ip = %self.ssh_config.host_ip,
+            host_ip = %self.ssh_connection.host_ip,
             "Waiting for SSH connectivity"
         );
 
@@ -208,7 +209,7 @@ impl SshClient {
                 Ok(true) => {
                     info!(
                         operation = "ssh_connectivity",
-                        host_ip = %self.ssh_config.host_ip,
+                        host_ip = %self.ssh_connection.host_ip,
                         status = "success",
                         "SSH connectivity established"
                     );
@@ -219,7 +220,7 @@ impl SshClient {
                     if (attempt + 1) % 5 == 0 {
                         info!(
                             operation = "ssh_connectivity",
-                            host_ip = %self.ssh_config.host_ip,
+                            host_ip = %self.ssh_connection.host_ip,
                             attempt = attempt + 1,
                             max_attempts = max_attempts,
                             "Still waiting for SSH connectivity"
@@ -236,7 +237,7 @@ impl SshClient {
         }
 
         Err(SshError::ConnectivityTimeout {
-            host_ip: self.ssh_config.host_ip.to_string(),
+            host_ip: self.ssh_connection.host_ip.to_string(),
             attempts: max_attempts,
             timeout_seconds,
         })
@@ -246,46 +247,53 @@ impl SshClient {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::config::ssh::SshCredentials;
     use std::net::{IpAddr, Ipv4Addr};
     use std::path::PathBuf;
 
     #[test]
     fn it_should_create_ssh_client_with_valid_parameters() {
         let host_ip = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1));
-        let ssh_config = SshConfig::new(
+        let credentials = SshCredentials::new(
             PathBuf::from("/path/to/key"),
             PathBuf::from("/path/to/key.pub"),
             "testuser".to_string(),
-            host_ip,
         );
-        let ssh_client = SshClient::new(ssh_config);
+        let ssh_connection = credentials.with_host(host_ip);
+        let ssh_client = SshClient::new(ssh_connection);
 
         assert_eq!(
-            ssh_client.ssh_config.ssh_priv_key_path.to_string_lossy(),
+            ssh_client
+                .ssh_connection
+                .ssh_priv_key_path()
+                .to_string_lossy(),
             "/path/to/key"
         );
-        assert_eq!(ssh_client.ssh_config.ssh_username, "testuser");
-        assert_eq!(ssh_client.ssh_config.host_ip, host_ip);
+        assert_eq!(ssh_client.ssh_connection.ssh_username(), "testuser");
+        assert_eq!(ssh_client.ssh_connection.host_ip, host_ip);
         // Note: verbose is now encapsulated in the CommandExecutor collaborator
     }
 
     #[test]
     fn it_should_create_ssh_client_with_connection_details() {
         let host_ip = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1));
-        let ssh_config = SshConfig::new(
+        let credentials = SshCredentials::new(
             PathBuf::from("/path/to/key"),
             PathBuf::from("/path/to/key.pub"),
             "testuser".to_string(),
-            host_ip,
         );
-        let ssh_client = SshClient::new(ssh_config);
+        let ssh_connection = credentials.with_host(host_ip);
+        let ssh_client = SshClient::new(ssh_connection);
 
         assert_eq!(
-            ssh_client.ssh_config.ssh_priv_key_path.to_string_lossy(),
+            ssh_client
+                .ssh_connection
+                .ssh_priv_key_path()
+                .to_string_lossy(),
             "/path/to/key"
         );
-        assert_eq!(ssh_client.ssh_config.ssh_username, "testuser");
-        assert_eq!(ssh_client.ssh_config.host_ip, host_ip);
+        assert_eq!(ssh_client.ssh_connection.ssh_username(), "testuser");
+        assert_eq!(ssh_client.ssh_connection.host_ip, host_ip);
         // Note: logging is now handled by the tracing crate via CommandExecutor
     }
 }

src/config/mod.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 pub mod ssh;
-pub use ssh::SshConfig;
+pub use ssh::{SshConnection, SshCredentials};
 
 /// Configuration parameters for deployment environments.
 ///
@@ -17,11 +17,12 @@ pub struct Config {
     /// will be left running for manual inspection or reuse.
     pub keep_env: bool,
 
-    /// SSH configuration for remote connections.
+    /// SSH credentials for remote connections.
     ///
-    /// Contains SSH key path and username settings for connecting to
-    /// deployed instances during the deployment process.
-    pub ssh_config: SshConfig,
+    /// Contains SSH key paths and username settings that will be used
+    /// when connecting to deployed instances. The host IP will be determined
+    /// later when instances are provisioned.
+    pub ssh_config: SshCredentials,
 
     /// Subdirectory name for Ansible-related files within the build directory.
     ///
@@ -72,16 +73,15 @@ impl Config {
     /// ```rust
     /// # use std::net::{IpAddr, Ipv4Addr};
     /// # use std::path::PathBuf;
-    /// # use torrust_tracker_deploy::config::{Config, SshConfig};
-    /// let ssh_config = SshConfig::new(
+    /// # use torrust_tracker_deploy::config::{Config, SshCredentials};
+    /// let ssh_credentials = SshCredentials::new(
     ///     PathBuf::from("/home/user/.ssh/deploy_key"),
     ///     PathBuf::from("/home/user/.ssh/deploy_key.pub"),
     ///     "ubuntu".to_string(),
-    ///     IpAddr::V4(Ipv4Addr::new(192, 168, 1, 100)),
     /// );
     /// let config = Config::new(
     ///     true,                           // keep environment for debugging
-    ///     ssh_config,
+    ///     ssh_credentials,
     ///     "templates".to_string(),
     ///     PathBuf::from("/path/to/project"),
     ///     PathBuf::from("/path/to/project/build"),
@@ -90,7 +90,7 @@ impl Config {
     #[must_use]
     pub fn new(
         keep_env: bool,
-        ssh_config: SshConfig,
+        ssh_config: SshCredentials,
         templates_dir: String,
         project_root: PathBuf,
         build_dir: PathBuf,