mur_core/remote/

ssh.rs

//! SSH-based remote execution.
//!
//! Builds SSH command strings and parses output for remote
//! workflow step execution on machines accessible via SSH.

use std::collections::HashMap;

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

use super::{RemoteExecutor, RemoteOutput};

/// SSH connection configuration for a remote machine.
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct SshConfig {
    pub host: String,
    pub port: u16,
    pub user: String,
    pub identity_file: Option<String>,
    /// Extra SSH options (e.g., StrictHostKeyChecking=no).
    #[serde(default)]
    pub options: HashMap<String, String>,
}

impl SshConfig {
    /// Build the SSH command prefix for this configuration.
    pub fn command_prefix(&self) -> Vec<String> {
        let mut args = vec!["ssh".to_string()];

        args.push("-p".to_string());
        args.push(self.port.to_string());

        if let Some(key) = &self.identity_file {
            args.push("-i".to_string());
            args.push(key.clone());
        }

        for (key, val) in &self.options {
            args.push("-o".to_string());
            args.push(format!("{key}={val}"));
        }

        args.push(format!("{}@{}", self.user, self.host));
        args
    }

    /// Build a full SSH command string for executing a remote command.
    pub fn build_command(&self, command: &str, working_dir: Option<&str>) -> String {
        let prefix = self.command_prefix().join(" ");
        match working_dir {
            Some(dir) => format!("{prefix} 'cd {dir} && {command}'"),
            None => format!("{prefix} '{command}'"),
        }
    }
}

/// SSH-based remote executor.
#[derive(Debug)]
pub struct SshExecutor {
    /// Machine ID → SSH config mapping.
    machines: HashMap<String, SshConfig>,
}

impl SshExecutor {
    /// Create a new SSH executor with no configured machines.
    pub fn new() -> Self {
        Self {
            machines: HashMap::new(),
        }
    }

    /// Register a machine with its SSH configuration.
    pub fn add_machine(&mut self, machine_id: String, config: SshConfig) {
        self.machines.insert(machine_id, config);
    }

    /// Remove a machine configuration.
    pub fn remove_machine(&mut self, machine_id: &str) -> Option<SshConfig> {
        self.machines.remove(machine_id)
    }

    /// Get the SSH config for a machine.
    pub fn get_config(&self, machine_id: &str) -> Option<&SshConfig> {
        self.machines.get(machine_id)
    }

    /// List all configured machine IDs.
    pub fn machine_ids(&self) -> Vec<String> {
        self.machines.keys().cloned().collect()
    }

    /// Build the full command string that would be executed for a given machine.
    pub fn build_command(
        &self,
        machine_id: &str,
        command: &str,
        working_dir: Option<&str>,
    ) -> anyhow::Result<String> {
        let config = self
            .machines
            .get(machine_id)
            .ok_or_else(|| anyhow::anyhow!("unknown machine: {machine_id}"))?;
        Ok(config.build_command(command, working_dir))
    }

    /// Parse SSH command output into a RemoteOutput struct.
    pub fn parse_output(
        machine_id: &str,
        stdout: &str,
        stderr: &str,
        exit_code: i32,
        duration_ms: u64,
    ) -> RemoteOutput {
        RemoteOutput {
            stdout: stdout.to_string(),
            stderr: stderr.to_string(),
            exit_code,
            duration_ms,
            machine_id: machine_id.to_string(),
        }
    }
}

impl Default for SshExecutor {
    fn default() -> Self {
        Self::new()
    }
}

impl RemoteExecutor for SshExecutor {
    fn execute(
        &self,
        machine_id: &str,
        command: &str,
        working_dir: Option<&str>,
    ) -> anyhow::Result<RemoteOutput> {
        let config = self
            .machines
            .get(machine_id)
            .ok_or_else(|| anyhow::anyhow!("unknown machine: {machine_id}"))?;

        let ssh_cmd = config.build_command(command, working_dir);
        tracing::info!(machine = machine_id, cmd = %ssh_cmd, "executing remote SSH command");

        // Build the actual command to run via the system shell
        let output = std::process::Command::new("sh")
            .arg("-c")
            .arg(&ssh_cmd)
            .output()
            .map_err(|e| anyhow::anyhow!("failed to execute SSH command: {e}"))?;

        Ok(RemoteOutput {
            stdout: String::from_utf8_lossy(&output.stdout).to_string(),
            stderr: String::from_utf8_lossy(&output.stderr).to_string(),
            exit_code: output.status.code().unwrap_or(-1),
            duration_ms: 0, // Timing would require wrapping with Instant
            machine_id: machine_id.to_string(),
        })
    }

    fn ping(&self, machine_id: &str) -> anyhow::Result<bool> {
        let result = self.execute(machine_id, "echo pong", None)?;
        Ok(result.success() && result.stdout.trim() == "pong")
    }

    fn executor_type(&self) -> &str {
        "ssh"
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn make_config() -> SshConfig {
        SshConfig {
            host: "10.0.0.5".into(),
            port: 22,
            user: "deploy".into(),
            identity_file: Some("/home/user/.ssh/id_ed25519".into()),
            options: HashMap::new(),
        }
    }

    #[test]
    fn test_ssh_config_command_prefix() {
        let config = make_config();
        let prefix = config.command_prefix();
        assert_eq!(prefix[0], "ssh");
        assert!(prefix.contains(&"-p".to_string()));
        assert!(prefix.contains(&"22".to_string()));
        assert!(prefix.contains(&"-i".to_string()));
        assert!(prefix.contains(&"/home/user/.ssh/id_ed25519".to_string()));
        assert_eq!(prefix.last().unwrap(), "deploy@10.0.0.5");
    }

    #[test]
    fn test_ssh_config_build_command() {
        let config = make_config();
        let cmd = config.build_command("ls -la", None);
        assert!(cmd.contains("ssh"));
        assert!(cmd.contains("deploy@10.0.0.5"));
        assert!(cmd.contains("'ls -la'"));
    }

    #[test]
    fn test_ssh_config_build_command_with_dir() {
        let config = make_config();
        let cmd = config.build_command("make build", Some("/opt/project"));
        assert!(cmd.contains("cd /opt/project && make build"));
    }

    #[test]
    fn test_ssh_config_with_options() {
        let mut config = make_config();
        config
            .options
            .insert("StrictHostKeyChecking".into(), "no".into());
        let prefix = config.command_prefix();
        assert!(prefix.contains(&"-o".to_string()));
        assert!(prefix.contains(&"StrictHostKeyChecking=no".to_string()));
    }

    #[test]
    fn test_ssh_executor_add_and_list() {
        let mut executor = SshExecutor::new();
        executor.add_machine("prod-1".into(), make_config());
        executor.add_machine("prod-2".into(), make_config());

        let mut ids = executor.machine_ids();
        ids.sort();
        assert_eq!(ids, vec!["prod-1", "prod-2"]);
    }

    #[test]
    fn test_ssh_executor_remove() {
        let mut executor = SshExecutor::new();
        executor.add_machine("prod-1".into(), make_config());
        let removed = executor.remove_machine("prod-1");
        assert!(removed.is_some());
        assert!(executor.machine_ids().is_empty());
    }

    #[test]
    fn test_ssh_executor_get_config() {
        let mut executor = SshExecutor::new();
        executor.add_machine("prod-1".into(), make_config());
        let config = executor.get_config("prod-1").unwrap();
        assert_eq!(config.host, "10.0.0.5");
    }

    #[test]
    fn test_ssh_executor_build_command() {
        let mut executor = SshExecutor::new();
        executor.add_machine("prod-1".into(), make_config());

        let cmd = executor
            .build_command("prod-1", "cargo test", Some("/app"))
            .unwrap();
        assert!(cmd.contains("cd /app && cargo test"));
    }

    #[test]
    fn test_ssh_executor_build_command_unknown() {
        let executor = SshExecutor::new();
        assert!(executor.build_command("unknown", "ls", None).is_err());
    }

    #[test]
    fn test_parse_output() {
        let output = SshExecutor::parse_output("m1", "hello\n", "", 0, 150);
        assert!(output.success());
        assert_eq!(output.stdout, "hello\n");
        assert_eq!(output.machine_id, "m1");
        assert_eq!(output.duration_ms, 150);
    }

    #[test]
    fn test_ssh_executor_type() {
        let executor = SshExecutor::new();
        assert_eq!(executor.executor_type(), "ssh");
    }

    #[test]
    fn test_ssh_config_serialization() {
        let config = make_config();
        let json = serde_json::to_string(&config).unwrap();
        let back: SshConfig = serde_json::from_str(&json).unwrap();
        assert_eq!(config.host, back.host);
        assert_eq!(config.port, back.port);
        assert_eq!(config.user, back.user);
    }

    #[test]
    fn test_ssh_executor_default() {
        let executor = SshExecutor::default();
        assert!(executor.machine_ids().is_empty());
    }
}