gitops.rs

use crate::{GitHubAppConfig, GitHubError, GitHubTokenProvider};
use serde::de::DeserializeOwned;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use tracing::{debug, error, info, instrument, warn};

pub struct GitHubGitOps {
    config: GitHubAppConfig,
    token_provider: GitHubTokenProvider,
}

impl GitHubGitOps {
    pub fn new(config: GitHubAppConfig, token_provider: GitHubTokenProvider) -> Self {
        Self {
            config,
            token_provider,
        }
    }

    #[instrument(skip(self, args), fields(git_cmd = ?args))]
    fn run_git_command(&self, args: &[&str], cwd: Option<&Path>) -> Result<String, GitHubError> {
        debug!("Executing git command");

        let mut cmd = Command::new("git");
        cmd.args(args).stdout(Stdio::piped()).stderr(Stdio::piped());

        if let Some(dir) = cwd {
            cmd.current_dir(dir);
            debug!(directory = ?dir, "Set working directory");
        }

        let output = cmd.output()?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);

            // Log the error with tracing - the sanitizer will redact tokens automatically
            error!(
                exit_code = ?output.status.code(),
                stderr = %stderr,
                "Git command failed"
            );

            // Return a generic error to users (details are in logs)
            return Err(GitHubError::Git(format!(
                "Git command failed. Check logs for details. Exit code: {:?}",
                output.status.code()
            )));
        }

        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
        debug!(output_length = stdout.len(), "Git command succeeded");
        Ok(stdout)
    }

    #[instrument(skip(self), fields(repo = %self.config.repo, branch = %self.config.branch))]
    pub async fn initialize(&self) -> Result<(), GitHubError> {
        if self.config.git_clone_path.exists() {
            info!("Repository already exists, skipping clone");
            return Ok(());
        }

        info!("Initializing repository clone");

        std::fs::create_dir_all(&self.config.git_clone_path)?;
        debug!("Created clone directory");

        let token = self.token_provider.get_token().await?;
        let clone_url = format!(
            "https://x-access-token:{}@github.com/{}.git",
            token, self.config.repo
        );

        // Tracing will automatically sanitize the clone_url in logs
        debug!("Starting git clone operation");
        self.run_git_command(
            &["clone", "--branch", &self.config.branch, &clone_url, "."],
            Some(&self.config.git_clone_path),
        )?;

        info!("Repository clone completed successfully");
        Ok(())
    }

    #[instrument(skip(self), fields(repo = %self.config.repo, branch = %self.config.branch))]
    pub async fn sync(&self) -> Result<(), GitHubError> {
        if !self.config.git_clone_path.exists() {
            warn!("Repository not initialized");
            return Err(GitHubError::Git(
                "Repository not initialized. Call initialize() first.".to_string(),
            ));
        }

        info!("Syncing repository with remote");

        let token = self.token_provider.get_token().await?;
        let remote_url = format!(
            "https://x-access-token:{}@github.com/{}.git",
            token, self.config.repo
        );

        // Tracing will automatically sanitize the remote_url in logs
        debug!("Updating remote URL");
        self.run_git_command(
            &["remote", "set-url", "origin", &remote_url],
            Some(&self.config.git_clone_path),
        )?;

        debug!("Fetching from origin");
        self.run_git_command(&["fetch", "origin"], Some(&self.config.git_clone_path))?;

        let remote_branch = format!("origin/{}", self.config.branch);
        debug!(remote_branch = %remote_branch, "Resetting to remote branch");
        self.run_git_command(
            &["reset", "--hard", &remote_branch],
            Some(&self.config.git_clone_path),
        )?;

        info!("Repository sync completed successfully");
        Ok(())
    }

    #[instrument(skip(self), fields(repo = %self.config.repo, glob = %self.config.manifest_glob))]
    pub fn load_all_manifests<T: DeserializeOwned>(&self) -> Result<Vec<T>, GitHubError> {
        if !self.config.git_clone_path.exists() {
            warn!("Repository not initialized");
            return Err(GitHubError::Git(
                "Repository not initialized. Call initialize() first.".to_string(),
            ));
        }

        debug!("Loading manifests");

        let pattern = self
            .config
            .git_clone_path
            .join(&self.config.manifest_glob)
            .to_string_lossy()
            .to_string();

        let mut manifests = Vec::new();

        for entry in glob::glob(&pattern)? {
            let path = entry?;
            debug!(file = ?path, "Loading manifest file");

            let content = std::fs::read_to_string(&path)?;
            let manifest: T = serde_yaml::from_str(&content).map_err(GitHubError::Yaml)?;
            manifests.push(manifest);
        }

        info!(count = manifests.len(), "Loaded manifests");
        Ok(manifests)
    }

    pub fn repo_path(&self) -> &PathBuf {
        &self.config.git_clone_path
    }
}