refactor: standardize network address handling with SocketAddr

- Update SshConnection struct to use SocketAddr instead of separate host_ip and port fields
- Rename socket_addr field to ssh_socket_addr in RenderAnsibleTemplatesStep for clarity
- Refactor validate_container_deployment_with_port to accept SocketAddr parameter
- Update ssh_details() method in RunningProvisionedContainer to return SocketAddr
- Standardize function signatures across SSH-related components to use SocketAddr
- Maintain backward compatibility while providing cleaner, more consistent API

Author: josecelano

src/application/commands/provision.rs

@@ -28,8 +28,8 @@ use crate::infrastructure::adapters::ansible::AnsibleClient;
 use crate::infrastructure::adapters::lxd::InstanceName;
 use crate::infrastructure::adapters::opentofu::client::{InstanceInfo, OpenTofuError};
 use crate::infrastructure::ansible::AnsibleTemplateRenderer;
-use crate::shared::executor::CommandError;
 use crate::infrastructure::tofu::{ProvisionTemplateError, TofuTemplateRenderer};
+use crate::shared::executor::CommandError;
 use crate::shared::ssh::{credentials::SshCredentials, SshError};
 
 /// Comprehensive error type for the `ProvisionCommand`
@@ -146,11 +146,11 @@ impl ProvisionCommand {
             GetInstanceInfoStep::new(Arc::clone(&self.opentofu_client)).execute()?;
         let instance_ip = instance_info.ip_address;
 
+        let socket_addr = std::net::SocketAddr::new(instance_ip, 22); // Default SSH port for VMs
         RenderAnsibleTemplatesStep::new(
             Arc::clone(&self.ansible_template_renderer),
             self.ssh_credentials.clone(),
-            instance_ip,
-            22, // Default SSH port for VMs
+            socket_addr,
         )
         .execute()
         .await?;

src/application/commands/test.rs

@@ -20,8 +20,8 @@ use crate::application::steps::{
     ValidateDockerComposeInstallationStep,
     ValidateDockerInstallationStep,
 };
-use crate::shared::executor::CommandError;
 use crate::infrastructure::remote_actions::RemoteActionError;
+use crate::shared::executor::CommandError;
 use crate::shared::ssh::credentials::SshCredentials;
 
 /// Comprehensive error type for the `TestCommand`

src/application/steps/connectivity/wait_ssh_connectivity.rs

@@ -52,7 +52,7 @@ impl WaitForSSHConnectivityStep {
     pub async fn execute(&self) -> Result<(), SshError> {
         info!(
             step = "wait_ssh_connectivity",
-            instance_ip = %self.ssh_connection.host_ip,
+            instance_ip = %self.ssh_connection.host_ip(),
             username = %self.ssh_connection.ssh_username(),
             "Waiting for SSH connectivity to be established"
         );
@@ -65,7 +65,7 @@ impl WaitForSSHConnectivityStep {
 
         info!(
             step = "wait_ssh_connectivity",
-            instance_ip = %self.ssh_connection.host_ip,
+            instance_ip = %self.ssh_connection.host_ip(),
             status = "success",
             "SSH connectivity successfully established"
         );
@@ -99,7 +99,7 @@ mod tests {
             "/tmp/test_key"
         );
         assert_eq!(step.ssh_connection.ssh_username(), "testuser");
-        assert_eq!(step.ssh_connection.host_ip, instance_ip);
+        assert_eq!(step.ssh_connection.host_ip(), instance_ip);
     }
 
     #[test]
@@ -119,7 +119,7 @@ mod tests {
             "/home/user/.ssh/id_rsa"
         );
         assert_eq!(step.ssh_connection.ssh_username(), "torrust");
-        assert_eq!(step.ssh_connection.host_ip, instance_ip);
+        assert_eq!(step.ssh_connection.host_ip(), instance_ip);
     }
 
     #[test]
@@ -139,6 +139,6 @@ mod tests {
             "/path/to/ssh/key"
         );
         assert_eq!(step.ssh_connection.ssh_username(), "admin");
-        assert_eq!(step.ssh_connection.host_ip, instance_ip);
+        assert_eq!(step.ssh_connection.host_ip(), instance_ip);
     }
 }

src/application/steps/rendering/ansible_templates.rs

@@ -18,7 +18,7 @@
 //! addresses are known, allowing for the generation of dynamic Ansible
 //! configurations for remote host management.
 
-use std::net::IpAddr;
+use std::net::SocketAddr;
 use std::sync::Arc;
 
 use thiserror::Error;
@@ -56,23 +56,20 @@ pub enum RenderAnsibleTemplatesError {
 pub struct RenderAnsibleTemplatesStep {
     ansible_template_renderer: Arc<AnsibleTemplateRenderer>,
     ssh_credentials: SshCredentials,
-    instance_ip: IpAddr,
-    ssh_port: u16,
+    ssh_socket_addr: SocketAddr,
 }
 
 impl RenderAnsibleTemplatesStep {
     #[must_use]
     pub fn new(
         ansible_template_renderer: Arc<AnsibleTemplateRenderer>,
         ssh_credentials: SshCredentials,
-        instance_ip: IpAddr,
-        ssh_port: u16,
+        ssh_socket_addr: SocketAddr,
     ) -> Self {
         Self {
             ansible_template_renderer,
             ssh_credentials,
-            instance_ip,
-            ssh_port,
+            ssh_socket_addr,
         }
     }
 
@@ -118,9 +115,9 @@ impl RenderAnsibleTemplatesStep {
     /// - SSH key path parsing fails
     /// - Inventory context creation fails
     fn create_inventory_context(&self) -> Result<InventoryContext, RenderAnsibleTemplatesError> {
-        let host = AnsibleHost::from(self.instance_ip);
+        let host = AnsibleHost::from(self.ssh_socket_addr.ip());
         let ssh_key = SshPrivateKeyFile::new(&self.ssh_credentials.ssh_priv_key_path)?;
-        let ssh_port = AnsiblePort::new(self.ssh_port)?;
+        let ssh_port = AnsiblePort::new(self.ssh_socket_addr.port())?;
 
         InventoryContext::builder()
             .with_host(host)

src/application/steps/validation/cloud_init.rs

@@ -62,7 +62,7 @@ impl ValidateCloudInitCompletionStep {
         let cloud_init_validator = CloudInitValidator::new(self.ssh_connection.clone());
 
         cloud_init_validator
-            .execute(&self.ssh_connection.host_ip)
+            .execute(&self.ssh_connection.host_ip())
             .await?;
 
         Ok(())
@@ -91,6 +91,6 @@ mod tests {
         let step = ValidateCloudInitCompletionStep::new(ssh_connection);
 
         // Test that the step can be created successfully
-        assert_eq!(step.ssh_connection.host_ip, host_ip);
+        assert_eq!(step.ssh_connection.host_ip(), host_ip);
     }
 }

src/application/steps/validation/docker.rs

@@ -61,7 +61,7 @@ impl ValidateDockerInstallationStep {
         let docker_validator = DockerValidator::new(self.ssh_connection.clone());
 
         docker_validator
-            .execute(&self.ssh_connection.host_ip)
+            .execute(&self.ssh_connection.host_ip())
             .await?;
 
         Ok(())
@@ -90,6 +90,6 @@ mod tests {
         let step = ValidateDockerInstallationStep::new(ssh_connection);
 
         // Test that the step can be created successfully
-        assert_eq!(step.ssh_connection.host_ip, host_ip);
+        assert_eq!(step.ssh_connection.host_ip(), host_ip);
     }
 }

src/application/steps/validation/docker_compose.rs

@@ -67,7 +67,7 @@ impl ValidateDockerComposeInstallationStep {
         let docker_compose_validator = DockerComposeValidator::new(self.ssh_connection.clone());
 
         docker_compose_validator
-            .execute(&self.ssh_connection.host_ip)
+            .execute(&self.ssh_connection.host_ip())
             .await?;
 
         Ok(())
@@ -96,6 +96,6 @@ mod tests {
         let step = ValidateDockerComposeInstallationStep::new(ssh_connection);
 
         // Test that the step can be created successfully
-        assert_eq!(step.ssh_connection.host_ip, host_ip);
+        assert_eq!(step.ssh_connection.host_ip(), host_ip);
     }
 }

src/bin/e2e_config_tests.rs

@@ -25,6 +25,7 @@
 
 use anyhow::{Context, Result};
 use clap::Parser;
+use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::runtime::Runtime;
@@ -147,10 +148,10 @@ fn run_configuration_tests() -> Result<()> {
         .context("Failed to start provisioned instance container")?;
 
     // Step 2: Wait for SSH server and setup connectivity (only available when running)
-    let (ssh_host, ssh_port) = running_container.ssh_details();
+    let socket_addr = running_container.ssh_details();
     let ssh_wait_action = SshWaitAction::new(Duration::from_secs(30), 10);
     ssh_wait_action
-        .execute(&ssh_host, ssh_port)
+        .execute(socket_addr)
         .context("SSH server failed to start")?;
 
     // Get SSH credentials from test environment and setup keys
@@ -161,8 +162,7 @@ fn run_configuration_tests() -> Result<()> {
         .context("Failed to setup SSH authentication")?;
 
     info!(
-        ssh_host = %ssh_host,
-        ssh_port = ssh_port,
+        socket_addr = %socket_addr,
         ssh_user = %ssh_credentials.ssh_username,
         container_id = %running_container.container_id(),
         "Container ready for Ansible configuration"
@@ -194,11 +194,10 @@ fn run_configuration_tests() -> Result<()> {
 async fn run_provision_simulation(
     running_container: &torrust_tracker_deploy::e2e::containers::RunningProvisionedContainer,
 ) -> Result<()> {
-    let (ssh_host, ssh_port) = running_container.ssh_details();
+    let socket_addr = running_container.ssh_details();
 
     info!(
-        ssh_host = %ssh_host,
-        ssh_port = ssh_port,
+        socket_addr = %socket_addr,
         "Running provision simulation for container"
     );
 
@@ -211,8 +210,7 @@ async fn run_provision_simulation(
     provision_docker_infrastructure(
         Arc::clone(&services.ansible_template_renderer),
         ssh_credentials,
-        ssh_host.parse()?,
-        ssh_port,
+        socket_addr,
     )
     .await
     .context("Failed to complete Docker infrastructure provision simulation")?;
@@ -229,11 +227,10 @@ async fn run_provision_simulation(
 fn run_ansible_configuration(
     running_container: &torrust_tracker_deploy::e2e::containers::RunningProvisionedContainer,
 ) -> Result<()> {
-    let (ssh_host, ssh_port) = running_container.ssh_details();
+    let socket_addr = running_container.ssh_details();
 
     info!(
-        ssh_host = %ssh_host,
-        ssh_port = ssh_port,
+        socket_addr = %socket_addr,
         "Running Ansible configuration on container"
     );
 
@@ -291,11 +288,10 @@ fn run_ansible_configuration(
 async fn run_deployment_validation(
     running_container: &torrust_tracker_deploy::e2e::containers::RunningProvisionedContainer,
 ) -> Result<()> {
-    let (ssh_host, ssh_port) = running_container.ssh_details();
+    let socket_addr = running_container.ssh_details();
 
     info!(
-        ssh_host = %ssh_host,
-        ssh_port = ssh_port,
+        socket_addr = %socket_addr,
         "Running deployment validation on container"
     );
 
@@ -304,10 +300,7 @@ async fn run_deployment_validation(
     match credentials_result {
         Ok(ssh_credentials) => {
             // Create SSH connection with the container's dynamic port
-            let host_ip = ssh_host.parse().context("Failed to parse SSH host as IP")?;
-
-            match validate_container_deployment_with_port(&ssh_credentials, host_ip, ssh_port).await
-            {
+            match validate_container_deployment_with_port(&ssh_credentials, socket_addr).await {
                 Ok(()) => {
                     info!(status = "success", "All deployment validations passed");
                 }
@@ -378,29 +371,30 @@ fn create_container_ssh_credentials() -> Result<SshCredentials> {
 /// Validate container deployment using SSH infrastructure with custom port
 async fn validate_container_deployment_with_port(
     ssh_credentials: &SshCredentials,
-    host_ip: std::net::IpAddr,
-    ssh_port: u16,
+    socket_addr: SocketAddr,
 ) -> Result<()> {
     use torrust_tracker_deploy::infrastructure::remote_actions::{
         DockerComposeValidator, DockerValidator, RemoteAction,
     };
 
+    let ip_addr = socket_addr.ip();
+
     // Create SSH connection with the container's dynamic port using the new port support
     let ssh_connection = ssh_credentials
         .clone()
-        .with_host_and_port(host_ip, ssh_port);
+        .with_host_and_port(ip_addr, socket_addr.port());
 
     // Validate Docker installation
     let docker_validator = DockerValidator::new(ssh_connection.clone());
     docker_validator
-        .execute(&host_ip)
+        .execute(&ip_addr)
         .await
         .context("Docker validation failed")?;
 
     // Validate Docker Compose installation
     let compose_validator = DockerComposeValidator::new(ssh_connection);
     compose_validator
-        .execute(&host_ip)
+        .execute(&ip_addr)
         .await
         .context("Docker Compose validation failed")?;
 

src/e2e/containers/actions/mod.rs

@@ -22,20 +22,20 @@
 //! use torrust_tracker_deploy::e2e::containers::{ContainerExecutor, actions::{SshKeySetupAction, SshWaitAction}};
 //! use torrust_tracker_deploy::shared::ssh::SshCredentials;
 //! use std::time::Duration;
+//! use std::net::SocketAddr;
 //!
 //! fn setup_container_ssh<T: ContainerExecutor>(
 //!     container: &T,
 //!     ssh_credentials: &SshCredentials,
-//!     host: &str,
-//!     port: u16,
+//!     socket_addr: SocketAddr,
 //! ) -> Result<(), Box<dyn std::error::Error>> {
 //!     // Setup SSH keys inside the container
 //!     let ssh_setup = SshKeySetupAction::new();
 //!     ssh_setup.execute(container, ssh_credentials)?;
 //!     
 //!     // Wait for SSH to be accessible
 //!     let ssh_wait = SshWaitAction::new(Duration::from_secs(30), 10);
-//!     ssh_wait.execute(host, port)?;
+//!     ssh_wait.execute(socket_addr)?;
 //!     
 //!     Ok(())
 //! }