docker_compose.rs

//! Docker Compose validation remote action
//!
//! This module provides the `DockerComposeValidator` which checks Docker Compose
//! installation and basic functionality on remote instances to ensure the
//! container orchestration tool is properly configured and operational.
//!
//! ## Key Features
//!
//! - Docker Compose plugin installation verification
//! - Version checking and compatibility validation
//! - Basic functionality testing (e.g., docker compose version command)
//! - Comprehensive error reporting for Docker Compose issues
//!
//! ## Validation Process
//!
//! The validator performs multiple checks:
//! - Docker Compose plugin availability and version (using modern plugin syntax)
//! - Integration with Docker engine
//! - Basic command execution functionality
//! - Service orchestration capabilities
//!
//! This ensures that subsequent deployment steps can rely on a working
//! Docker Compose environment for container orchestration.

use std::net::IpAddr;
use tracing::{info, instrument, warn};

use crate::adapters::ssh::SshClient;
use crate::adapters::ssh::SshConfig;
use crate::infrastructure::remote_actions::{RemoteAction, RemoteActionError};

/// Action that validates Docker Compose installation and basic functionality on the server
pub struct DockerComposeValidator {
    ssh_client: SshClient,
}

impl DockerComposeValidator {
    /// Create a new `DockerComposeValidator` with the specified SSH configuration
    ///
    /// # Arguments
    /// * `ssh_config` - SSH connection configuration containing credentials and host IP
    #[must_use]
    pub fn new(ssh_config: SshConfig) -> Self {
        let ssh_client = SshClient::new(ssh_config);
        Self { ssh_client }
    }
}

impl RemoteAction for DockerComposeValidator {
    fn name(&self) -> &'static str {
        "docker-compose-validation"
    }

    #[allow(clippy::too_many_lines)]
    #[instrument(
        name = "docker_compose_validation",
        skip(self),
        fields(
            action_type = "validation",
            component = "docker_compose",
            server_ip = %server_ip
        )
    )]
    async fn execute(&self, server_ip: &IpAddr) -> Result<(), RemoteActionError> {
        info!(
            action = "docker_compose_validation",
            "Validating Docker Compose installation"
        );

        // Check Docker Compose version (using modern plugin syntax)
        let compose_version =
            self.ssh_client
                .execute("docker compose version")
                .map_err(|source| RemoteActionError::SshCommandFailed {
                    action_name: self.name().to_string(),
                    source,
                })?;

        let compose_version = compose_version.trim();
        info!(
            action = "docker_compose_validation",
            status = "success",
            "Docker Compose installation validated"
        );
        info!(
            action = "docker_compose_validation",
            version = compose_version,
            "Docker Compose version detected"
        );

        // Test basic docker-compose functionality with a simple test file (only if Docker is working)
        let test_compose_content = r"services:
  test:
    image: hello-world
";

        // Create a temporary test docker-compose.yml file
        let create_test_success = self
            .ssh_client
            .check_command(&format!(
                "echo '{test_compose_content}' > /tmp/test-docker-compose.yml"
            ))
            .map_err(|source| RemoteActionError::SshCommandFailed {
                action_name: self.name().to_string(),
                source,
            })?;

        if !create_test_success {
            warn!(
                action = "docker_compose_validation",
                check = "test_file_creation",
                status = "failed",
                "Could not create test docker-compose.yml file"
            );
            return Ok(()); // Don't fail, just skip the functional test
        }

        // Validate docker-compose file (using modern plugin syntax)
        let validate_success = self
            .ssh_client
            .check_command("cd /tmp && docker compose -f test-docker-compose.yml config")
            .map_err(|source| RemoteActionError::SshCommandFailed {
                action_name: self.name().to_string(),
                source,
            })?;

        if validate_success {
            info!(
                action = "docker_compose_validation",
                check = "configuration_validation",
                status = "success",
                "Docker Compose configuration validation passed"
            );
        } else {
            warn!(
                action = "docker_compose_validation",
                check = "configuration_validation",
                status = "skipped",
                "Docker Compose configuration validation skipped"
            );
        }

        // Clean up test file
        drop(
            self.ssh_client
                .check_command("rm -f /tmp/test-docker-compose.yml"),
        );

        Ok(())
    }
}