xbp_cli/strategies/

deployment_executor.rs

//! Deployment execution module
//!
//! This module handles the actual deployment process including port management,
//! git operations, building, and process management.

use super::deployment_config::DeploymentConfig;
use super::project_detector::{ProjectDetector, ProjectType};
use crate::utils::{is_node_toolchain_command, node_toolchain_wrapper_path};
use std::time::Instant;
use tokio::process::Command;
use tracing::{debug, info};

pub struct DeploymentExecutor {
    config: DeploymentConfig,
    debug: bool,
    detected_project_type: Option<ProjectType>,
}

impl DeploymentExecutor {
    pub fn new(config: DeploymentConfig, debug: bool) -> Self {
        Self {
            config,
            debug,
            detected_project_type: None,
        }
    }

    /// Execute the full deployment process
    pub async fn deploy(&mut self) -> Result<(), String> {
        let start_time: Instant = Instant::now();

        self.validate_project_directory().await?;
        self.detect_and_configure_project().await?;
        if self.is_provider_managed_deploy() {
            self.deploy_provider_managed_project().await?;
            self.config.save_xbp_config(None).await?;

            let elapsed: std::time::Duration = start_time.elapsed();
            info!(
                "Successfully deployed {} via provider CLI in {:.2?}",
                self.config.app_name, elapsed
            );
            return Ok(());
        }

        self.ensure_port_available().await?;
        self.git_reset_and_pull().await?;
        if let Some(install_cmd) = &self.config.install_command.clone() {
            self.run_install_command(install_cmd).await?;
        }
        if let Some(build_cmd) = &self.config.build_command.clone() {
            self.run_build_command(build_cmd).await?;
        }
        self.stop_existing_processes().await?;
        self.start_application().await?;
        self.save_pm2_config().await?;
        self.config.save_xbp_config(None).await?;

        let elapsed: std::time::Duration = start_time.elapsed();
        info!(
            "Successfully deployed {} on port {} in {:.2?}",
            self.config.app_name, self.config.port, elapsed
        );

        Ok(())
    }

    /// Detect project type and configure deployment accordingly
    async fn detect_and_configure_project(&mut self) -> Result<(), String> {
        if self.debug {
            debug!(
                "Detecting project type in: {}",
                self.config.app_dir.display()
            );
        }

        let project_type = ProjectDetector::detect_project_type(&self.config.app_dir).await?;
        self.detected_project_type = Some(project_type.clone());

        match &project_type {
            ProjectType::Docker { .. } => {
                info!(" Detected Docker project (Dockerfile found)");
            }
            ProjectType::DockerCompose {
                compose_files,
                detected_ports,
            } => {
                info!(
                    " Detected Docker Compose project: {}",
                    compose_files.join(", ")
                );
                if !detected_ports.is_empty() {
                    info!("     Detected ports: {:?}", detected_ports);
                }
            }
            ProjectType::Railway {
                has_railway_json,
                has_railway_toml,
            } => {
                let mut parts = Vec::new();
                if *has_railway_json {
                    parts.push("railway.json");
                }
                if *has_railway_toml {
                    parts.push("railway.toml");
                }
                info!(" Detected Railway manifest: {}", parts.join(", "));
            }
            ProjectType::Vercel {
                has_vercel_json,
                has_project_link,
            } => {
                let mut parts = Vec::new();
                if *has_vercel_json {
                    parts.push("vercel.json");
                }
                if *has_project_link {
                    parts.push(".vercel/project.json");
                }
                info!(" Detected Vercel manifest: {}", parts.join(", "));
            }
            ProjectType::Python {
                has_requirements_txt,
                has_pyproject_toml,
            } => {
                let mut parts = Vec::new();
                if *has_requirements_txt {
                    parts.push("requirements.txt");
                }
                if *has_pyproject_toml {
                    parts.push("pyproject.toml");
                }
                info!(" Detected Python project: {}", parts.join(", "));
            }
            ProjectType::OpenApi { spec_files } => {
                info!(" Detected OpenAPI spec: {}", spec_files.join(", "));
            }
            ProjectType::Terraform { tf_file_count } => {
                info!(" Detected Terraform files: {}", tf_file_count);
            }
            ProjectType::NextJs {
                package_json,
                has_next_config,
            } => {
                info!(
                    " Detected Next.js project: {} v{}",
                    package_json.name, package_json.version
                );
                if *has_next_config {
                    info!("     Next.js configuration found");
                }
            }
            ProjectType::NodeJs { package_json } => {
                info!(
                    " Detected Node.js project: {} v{}",
                    package_json.name, package_json.version
                );
            }
            ProjectType::Rust { cargo_toml } => {
                info!(
                    " Detected Rust project: {} v{}",
                    cargo_toml.name, cargo_toml.version
                );
            }
            ProjectType::Unknown => {
                info!("  Unknown project type, using default configuration");
            }
        }

        let recommendations =
            ProjectDetector::get_deployment_recommendations(&self.config.app_dir, &project_type);
        self.config.merge_with_recommendations(&recommendations);

        if self.debug {
            debug!("Build command: {:?}", self.config.build_command);
            debug!("Start command: {:?}", self.config.start_command);
            debug!("Install command: {:?}", self.config.install_command);
        }

        Ok(())
    }

    fn is_provider_managed_deploy(&self) -> bool {
        matches!(
            self.detected_project_type,
            Some(ProjectType::Railway { .. }) | Some(ProjectType::Vercel { .. })
        )
    }

    async fn deploy_provider_managed_project(&self) -> Result<(), String> {
        if let Some(install_cmd) = &self.config.install_command {
            self.run_install_command(install_cmd).await?;
        }
        if let Some(build_cmd) = &self.config.build_command {
            self.run_build_command(build_cmd).await?;
        }

        let (program, args, install_target, label) = match self.detected_project_type.as_ref() {
            Some(ProjectType::Railway { .. }) => (
                "railway",
                vec!["up".to_string()],
                "railway",
                "Railway deploy",
            ),
            Some(ProjectType::Vercel { .. }) => (
                "vercel",
                Vec::new(),
                "vercel",
                "Vercel deploy (default CLI command)",
            ),
            _ => {
                return Err(
                    "Provider-managed deployment requested without provider project type"
                        .to_string(),
                )
            }
        };

        if !crate::utils::command_exists(program) {
            return Err(format!(
                "{} requires `{}` on PATH. Install it with `xbp install {}` first.",
                label, program, install_target
            ));
        }

        let command_display = if args.is_empty() {
            program.to_string()
        } else {
            format!("{} {}", program, args.join(" "))
        };
        info!(" Running {}: {}", label, command_display);

        let output = Command::new(program)
            .args(&args)
            .envs(&self.config.environment)
            .current_dir(&self.config.app_dir)
            .output()
            .await
            .map_err(|e| format!("Failed to execute {}: {}", label, e))?;

        if !output.status.success() {
            return Err(format!(
                "{} failed: {}",
                label,
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        let stdout = String::from_utf8_lossy(&output.stdout);
        if !stdout.trim().is_empty() {
            info!("{}", stdout.trim());
        }

        Ok(())
    }

    /// Ensure the target port is available, kill existing processes or find new port
    async fn ensure_port_available(&mut self) -> Result<(), String> {
        info!(" Checking port {} availability...", self.config.port);

        let port_check = Command::new("sh")
            .arg("-c")
            .arg(format!("sudo fuser {}/tcp", self.config.port))
            .output()
            .await;

        match port_check {
            Ok(output) if output.status.success() => {
                info!(
                    "  Port {} is in use, attempting to kill process...",
                    self.config.port
                );

                let kill_output = Command::new("sh")
                    .arg("-c")
                    .arg(format!("sudo fuser -k {}/tcp", self.config.port))
                    .output()
                    .await
                    .map_err(|e| {
                        format!("Failed to kill process on port {}: {}", self.config.port, e)
                    })?;

                if kill_output.status.success() {
                    info!(" Successfully killed process on port {}", self.config.port);
                } else {
                    info!("  Failed to kill process, searching for available port...");
                    let new_port = self.find_available_port().await?;
                    self.config.update_port(new_port);
                    info!(" Found available port: {}", new_port);
                }
            }
            _ => {
                info!(" Port {} is available", self.config.port);
            }
        }

        Ok(())
    }

    /// Find an available port in the range 1025-65535
    async fn find_available_port(&self) -> Result<u16, String> {
        for port in 1025..=65535 {
            let check_output = Command::new("sh")
                .arg("-c")
                .arg(format!("sudo fuser {}/tcp", port))
                .output()
                .await;

            if let Ok(output) = check_output {
                if !output.status.success() {
                    return Ok(port);
                }
            }
        }

        Err("No available ports found in range 1025-65535".to_string())
    }

    /// Validate that the project directory exists and is accessible
    async fn validate_project_directory(&self) -> Result<(), String> {
        if !self.config.app_dir.exists() {
            return Err(format!(
                "Project directory does not exist: {}",
                self.config.app_dir.display()
            ));
        }

        if !self.config.app_dir.is_dir() {
            return Err(format!(
                "Project path is not a directory: {}",
                self.config.app_dir.display()
            ));
        }

        info!(" Project directory: {}", self.config.app_dir.display());
        Ok(())
    }

    /// Reset git repository and pull latest changes
    async fn git_reset_and_pull(&self) -> Result<(), String> {
        info!(" Resetting git repository...");

        let reset_output = Command::new("git")
            .arg("reset")
            .arg("--hard")
            .current_dir(&self.config.app_dir)
            .output()
            .await
            .map_err(|e| format!("Failed to execute git reset: {}", e))?;

        if !reset_output.status.success() {
            return Err(format!(
                "Git reset failed: {}",
                String::from_utf8_lossy(&reset_output.stderr)
            ));
        }

        info!("  Pulling latest changes...");

        let pull_output = Command::new("git")
            .arg("pull")
            .arg("origin")
            .arg("main")
            .current_dir(&self.config.app_dir)
            .output()
            .await
            .map_err(|e| format!("Failed to execute git pull: {}", e))?;

        if !pull_output.status.success() {
            return Err(format!(
                "Git pull failed: {}",
                String::from_utf8_lossy(&pull_output.stderr)
            ));
        }

        info!(" Git operations completed");
        Ok(())
    }

    /// Run the install command (e.g., pnpm install, cargo fetch)
    async fn run_install_command(&self, install_cmd: &str) -> Result<(), String> {
        info!(" Installing dependencies: {}", install_cmd);

        let install_output = self
            .run_shell_command(install_cmd)
            .await
            .map_err(|e| format!("Failed to execute install command: {}", e))?;

        if !install_output.status.success() {
            return Err(format!(
                "Install command failed: {}",
                String::from_utf8_lossy(&install_output.stderr)
            ));
        }

        info!(" Dependencies installed successfully");
        Ok(())
    }

    /// Run the build command
    async fn run_build_command(&self, build_cmd: &str) -> Result<(), String> {
        info!(" Building project: {}", build_cmd);

        let build_output = self
            .run_shell_command(build_cmd)
            .await
            .map_err(|e| format!("Failed to execute build command: {}", e))?;

        if !build_output.status.success() {
            return Err(format!(
                "Build command failed: {}",
                String::from_utf8_lossy(&build_output.stderr)
            ));
        }

        info!("Project built successfully");
        Ok(())
    }

    async fn run_shell_command(
        &self,
        command: &str,
    ) -> Result<std::process::Output, std::io::Error> {
        let mut command_builder = if is_node_toolchain_command(command) {
            if let Some(wrapper_path) = node_toolchain_wrapper_path(&self.config.app_dir) {
                let mut command_builder = Command::new("node");
                command_builder
                    .arg(wrapper_path)
                    .arg("sh")
                    .arg("-lc")
                    .arg(command);
                command_builder
            } else {
                let mut command_builder = Command::new("sh");
                command_builder.arg("-c").arg(command);
                command_builder
            }
        } else {
            let mut command_builder = Command::new("sh");
            command_builder.arg("-c").arg(command);
            command_builder
        };

        command_builder
            .envs(&self.config.environment)
            .current_dir(&self.config.app_dir)
            .output()
            .await
    }

    /// Stop existing PM2 processes and kill processes on the target port
    async fn stop_existing_processes(&self) -> Result<(), String> {
        info!("Stopping existing processes...");

        let pm2_stop = Command::new("pm2")
            .arg("stop")
            .arg(&self.config.app_name)
            .output()
            .await;

        match pm2_stop {
            Ok(output) if output.status.success() => {
                info!("  Stopped PM2 process: {}", self.config.app_name);
            }
            _ => {
                info!(" No existing PM2 process found");
            }
        }

        let kill_port = Command::new("sh")
            .arg("-c")
            .arg(format!("sudo fuser -k {}/tcp", self.config.port))
            .output()
            .await;

        match kill_port {
            Ok(output) if output.status.success() => {
                info!("  Killed processes on port {}", self.config.port);
            }
            _ => {
                info!(" No processes found on port {}", self.config.port);
            }
        }

        Ok(())
    }

    /// Start the application using PM2
    async fn start_application(&self) -> Result<(), String> {
        let start_cmd = self
            .config
            .start_command
            .as_ref()
            .ok_or("No start command configured")?;

        info!(" Starting application: {}", start_cmd);

        // Construct PM2 start command with port
        let pm2_cmd = format!("{} --port {}", start_cmd, self.config.port);

        let start_output = Command::new("pm2")
            .arg("start")
            .arg(&pm2_cmd)
            .arg("--name")
            .arg(&self.config.app_name)
            .arg("--")
            .arg("--port")
            .arg(self.config.port.to_string())
            .envs(&self.config.environment)
            .current_dir(&self.config.app_dir)
            .output()
            .await
            .map_err(|e| format!("Failed to start PM2 process: {}", e))?;

        if !start_output.status.success() {
            return Err(format!(
                "Failed to start application: {}",
                String::from_utf8_lossy(&start_output.stderr)
            ));
        }

        info!("Application started successfully");
        Ok(())
    }

    /// Save PM2 process list
    async fn save_pm2_config(&self) -> Result<(), String> {
        info!("Saving PM2 configuration...");

        let save_output = Command::new("pm2")
            .arg("save")
            .output()
            .await
            .map_err(|e| format!("Failed to save PM2 config: {}", e))?;

        if !save_output.status.success() {
            return Err(format!(
                "PM2 save failed: {}",
                String::from_utf8_lossy(&save_output.stderr)
            ));
        }

        info!("PM2 configuration saved");
        Ok(())
    }
}