xianyun_deploy/deploy/

orchestrator.rs

//! Orchestrates deployment operations across every declared deployer.
//!
//! Ported from `internal/deploy/orchestrator.go`.

use thiserror::Error;
use xianyun_core::config::container::Container;

use super::order::{self, OrderError};
use crate::deployer::{self, DeployerError};

/// A predicate function that determines whether a deployer should be
/// processed. It receives the deployer name and returns `true` if the
/// deployer should be processed, `false` to skip.
pub type DeployerFilterFunc<'a> = dyn Fn(&str) -> bool + 'a;

/// Errors from [`Orchestrator::deploy_all`].
#[derive(Debug, Error)]
pub enum OrchestratorError {
    /// Failed to order the declared deployers.
    #[error("listing deployers: {0}")]
    ListDeployers(#[from] OrderError),
    /// Failed to create a deployer manager for a deployer's type.
    #[error("creating deployer manager for {0}: {1}")]
    CreateManager(String, #[source] DeployerError),
    /// A deployer's `deploy` call failed.
    #[error("deploying {0}: {1}")]
    Deploy(String, #[source] Box<dyn std::error::Error + Send + Sync>),
}

/// Orchestrates deployment operations.
#[derive(Debug, Default)]
pub struct Orchestrator {
    // Future: inject deployer backends here for testing
}

impl Orchestrator {
    /// Creates a new deployment orchestrator.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Deploys all deployers matching the filter predicate.
    ///
    /// If `filter` is `None`, all deployers are deployed. Aborts on the
    /// first deployment failure.
    ///
    /// # Errors
    ///
    /// Returns [`OrchestratorError`] if ordering the deployers fails,
    /// creating a deployer manager for a deployer's type fails, or a
    /// deployer's `deploy` call fails.
    ///
    /// # Panics
    ///
    /// Panics if a deployer named by [`order::list_deployers_in_order`] is
    /// absent from `cfg`, which cannot happen because that function only
    /// returns names it read from `cfg` itself.
    pub fn deploy_all(
        &self,
        cfg: &Container,
        filter: Option<&DeployerFilterFunc<'_>>,
        kubeconfig: &str,
    ) -> Result<(), OrchestratorError> {
        let default_filter = default_deployer_filter();
        let filter: &DeployerFilterFunc<'_> = filter.unwrap_or(&default_filter);

        let deployers = order::list_deployers_in_order(cfg)?;

        for name in deployers {
            if !filter(&name) {
                continue;
            }

            // must exist because list_deployers_in_order returns only existing ones
            let deployer_config = cfg
                .caproni
                .deployers
                .as_ref()
                .and_then(|d| d.get(&name))
                .expect("listed deployer must exist in config");

            tracing::info!(
                deployer = %name,
                deployer_type = %deployer_config.deployer_type,
                "deploying"
            );

            let deployer_mgr =
                deployer::registry::new_manager(&deployer_config.deployer_type, kubeconfig)
                    .map_err(|e| OrchestratorError::CreateManager(name.clone(), e))?;

            deployer_mgr
                .deploy(deployer_config, Some(cfg))
                .map_err(|e| OrchestratorError::Deploy(name.clone(), e))?;

            tracing::info!(deployer = %name, "deployed successfully");
        }

        Ok(())
    }
}

/// Returns a filter that accepts all deployers.
fn default_deployer_filter() -> impl Fn(&str) -> bool {
    |_deployer_name: &str| true
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;
    use std::sync::atomic::{AtomicUsize, Ordering};

    use xianyun_core::config::container::new_container;
    use xianyun_core::config::global::GlobalConfig;
    use xianyun_core::config::latest::{CaproniConfig, DeployerConfig};
    use xianyun_core::config::types::NetworkConfig;
    use xianyun_core::orderedmap::OrderedMap;

    use super::*;
    use crate::deployer::{Manager, State, Status, registry};

    /// Wraps a [`CaproniConfig`] in a [`Container`] for use in tests,
    /// mirroring the Go test helper `newTestConfig`.
    fn new_test_config(mut caproni_config: CaproniConfig) -> Container {
        if caproni_config.cluster.network.is_none() {
            caproni_config.cluster.network = Some(NetworkConfig {
                hostname: "test.example.com".to_string(),
                additional_hostnames: Vec::new(),
                cluster_domain: String::new(),
            });
        }

        new_container(GlobalConfig::default(), caproni_config)
    }

    fn config_from(deployers: std::collections::HashMap<String, DeployerConfig>) -> CaproniConfig {
        CaproniConfig {
            deployers: Some(OrderedMap::from_map(deployers)),
            ..Default::default()
        }
    }

    /// A mock [`Manager`] that records how many times `deploy` is called
    /// and delegates to a caller-provided closure for the return value.
    struct MockManager<F> {
        deployer_type: String,
        on_deploy: F,
    }

    impl<F> Manager for MockManager<F>
    where
        F: Fn() -> Result<(), Box<dyn std::error::Error + Send + Sync>> + Send + Sync,
    {
        fn deployer_type(&self) -> String {
            self.deployer_type.clone()
        }

        fn deploy(
            &self,
            _deployer_config: &DeployerConfig,
            _cfg: Option<&Container>,
        ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
            (self.on_deploy)()
        }

        fn undeploy(
            &self,
            _deployer_config: &DeployerConfig,
            _caproni_config: &CaproniConfig,
        ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
            Ok(())
        }

        fn status(
            &self,
            _deployer_config: &DeployerConfig,
            _caproni_config: &CaproniConfig,
        ) -> Result<Status, Box<dyn std::error::Error + Send + Sync>> {
            Ok(Status {
                state: State::NotDeployed,
                deployer_type: self.deployer_type.clone(),
            })
        }

        fn validate(
            &self,
            _deployer_config: &DeployerConfig,
            _caproni_config: &CaproniConfig,
        ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
            Ok(())
        }
    }

    fn register_counting_mock(mock_type: &str) -> Arc<AtomicUsize> {
        let count = Arc::new(AtomicUsize::new(0));
        let counted = count.clone();
        let deployer_type = mock_type.to_string();

        registry::register(
            mock_type,
            Box::new(move |_kubeconfig| {
                let count = counted.clone();
                Box::new(MockManager {
                    deployer_type: deployer_type.clone(),
                    on_deploy: move || {
                        count.fetch_add(1, Ordering::SeqCst);
                        Ok(())
                    },
                })
            }),
        );

        count
    }

    // Ported from internal/deploy/orchestrator_test.go:33 (TestDefaultDeployerFilter)
    #[test]
    fn test_default_deployer_filter() {
        let filter = default_deployer_filter();

        assert!(filter("charts"));
        assert!(filter("gitlab"));
        assert!(filter("anything"));
        assert!(filter(""));
    }

    // Ported from internal/deploy/orchestrator_test.go:44 (TestNewOrchestrator)
    #[test]
    fn test_new_orchestrator() {
        let _orch = Orchestrator::new();
    }

    // Ported from internal/deploy/orchestrator_test.go:52 (TestOrchestrator_DeployAll_EmptyConfig)
    #[test]
    fn test_orchestrator_deploy_all_empty_config() {
        let orch = Orchestrator::new();

        let cfg = new_test_config(CaproniConfig::default());

        orch.deploy_all(&cfg, None, "").unwrap();
    }

    // Ported from internal/deploy/orchestrator_test.go:67 (TestOrchestrator_DeployAll_WithMockDeployer)
    #[test]
    fn test_orchestrator_deploy_all_with_mock_deployer() {
        let mock_type = "test-deploy-all-mock";
        let count = register_counting_mock(mock_type);

        let orch = Orchestrator::new();

        let mut deployers = std::collections::HashMap::new();
        deployers.insert(
            "test-deployer".to_string(),
            DeployerConfig {
                deployer_type: mock_type.to_string(),
                ..Default::default()
            },
        );

        let cfg = new_test_config(config_from(deployers));

        orch.deploy_all(&cfg, None, "").unwrap();

        assert_eq!(count.load(Ordering::SeqCst), 1);
    }

    // Ported from internal/deploy/orchestrator_test.go:97 (TestOrchestrator_DeployAll_WithFilter)
    #[test]
    fn test_orchestrator_deploy_all_with_filter() {
        let mock_type = "test-deploy-filter";
        let count = register_counting_mock(mock_type);

        let orch = Orchestrator::new();

        let mut deployers = std::collections::HashMap::new();
        for name in ["deployer1", "deployer2", "deployer3"] {
            deployers.insert(
                name.to_string(),
                DeployerConfig {
                    deployer_type: mock_type.to_string(),
                    ..Default::default()
                },
            );
        }

        let cfg = new_test_config(config_from(deployers));

        let filter: &DeployerFilterFunc<'_> = &|name: &str| name == "deployer2";

        orch.deploy_all(&cfg, Some(filter), "").unwrap();

        assert_eq!(count.load(Ordering::SeqCst), 1);
    }

    // Ported from internal/deploy/orchestrator_test.go:131 (TestOrchestrator_DeployAll_ErrorHandling)
    #[test]
    fn test_orchestrator_deploy_all_error_handling() {
        let mock_type = "test-deploy-error";
        let call_count = Arc::new(AtomicUsize::new(0));
        let counted = call_count.clone();
        let deployer_type = mock_type.to_string();

        registry::register(
            mock_type,
            Box::new(move |_kubeconfig| {
                let count = counted.clone();
                Box::new(MockManager {
                    deployer_type: deployer_type.clone(),
                    on_deploy: move || {
                        let n = count.fetch_add(1, Ordering::SeqCst) + 1;
                        if n == 2 {
                            Err(Box::from("deployment failed")
                                as Box<dyn std::error::Error + Send + Sync>)
                        } else {
                            Ok(())
                        }
                    },
                })
            }),
        );

        let orch = Orchestrator::new();

        let mut deployers = std::collections::HashMap::new();
        for name in ["deployer1", "deployer2", "deployer3"] {
            deployers.insert(
                name.to_string(),
                DeployerConfig {
                    deployer_type: mock_type.to_string(),
                    ..Default::default()
                },
            );
        }

        let cfg = new_test_config(config_from(deployers));

        let err = orch.deploy_all(&cfg, None, "").unwrap_err();

        assert!(err.to_string().contains("deployment failed"));
        assert_eq!(call_count.load(Ordering::SeqCst), 2);
    }

    // Ported from internal/deploy/orchestrator_test.go:171 (TestOrchestrator_DeployAll_UnknownDeployerType)
    #[test]
    fn test_orchestrator_deploy_all_unknown_deployer_type() {
        let orch = Orchestrator::new();

        let mut deployers = std::collections::HashMap::new();
        deployers.insert(
            "unknown".to_string(),
            DeployerConfig {
                deployer_type: "unknown-deployer-type-xyz".to_string(),
                ..Default::default()
            },
        );

        let cfg = new_test_config(config_from(deployers));

        let err = orch.deploy_all(&cfg, None, "").unwrap_err();

        assert!(err.to_string().contains("creating deployer manager"));
        assert!(err.to_string().contains("unknown"));
    }

    // Ported from internal/deploy/orchestrator_test.go:191 (TestOrchestrator_DeployAll_MultipleDeployers)
    #[test]
    fn test_orchestrator_deploy_all_multiple_deployers() {
        let mock_type1 = "test-multi-1";
        let mock_type2 = "test-multi-2";
        let count1 = register_counting_mock(mock_type1);
        let count2 = register_counting_mock(mock_type2);

        let orch = Orchestrator::new();

        let mut deployers = std::collections::HashMap::new();
        deployers.insert(
            "first".to_string(),
            DeployerConfig {
                deployer_type: mock_type1.to_string(),
                ..Default::default()
            },
        );
        deployers.insert(
            "second".to_string(),
            DeployerConfig {
                deployer_type: mock_type2.to_string(),
                ..Default::default()
            },
        );
        deployers.insert(
            "third".to_string(),
            DeployerConfig {
                deployer_type: mock_type1.to_string(),
                ..Default::default()
            },
        );

        let cfg = new_test_config(config_from(deployers));

        orch.deploy_all(&cfg, None, "").unwrap();

        assert_eq!(count1.load(Ordering::SeqCst), 2);
        assert_eq!(count2.load(Ordering::SeqCst), 1);
    }

    // Ported from internal/deploy/orchestrator_test.go:233 (TestOrchestrator_DeployAll_NilFilter)
    #[test]
    fn test_orchestrator_deploy_all_nil_filter() {
        let mock_type = "test-nil-filter";
        let count = register_counting_mock(mock_type);

        let orch = Orchestrator::new();

        let mut deployers = std::collections::HashMap::new();
        deployers.insert(
            "deployer1".to_string(),
            DeployerConfig {
                deployer_type: mock_type.to_string(),
                ..Default::default()
            },
        );
        deployers.insert(
            "deployer2".to_string(),
            DeployerConfig {
                deployer_type: mock_type.to_string(),
                ..Default::default()
            },
        );

        let cfg = new_test_config(config_from(deployers));

        orch.deploy_all(&cfg, None, "").unwrap();

        assert_eq!(count.load(Ordering::SeqCst), 2);
    }

    // Ported from internal/deploy/orchestrator_test.go:266 (TestDeployAllDeploysEveryDeclaredDeployer)
    #[test]
    fn test_deploy_all_deploys_every_declared_deployer() {
        let mock_type = "test-deploys-every-declared-deployer";
        let count = register_counting_mock(mock_type);

        let orch = Orchestrator::new();

        let mut deployers = std::collections::HashMap::new();
        // Names once carried by caproni's bundled infrastructure get no
        // special treatment; they are ordinary deployers now.
        for name in ["cert-manager", "traefik", "my-app"] {
            deployers.insert(
                name.to_string(),
                DeployerConfig {
                    deployer_type: mock_type.to_string(),
                    ..Default::default()
                },
            );
        }

        let cfg = new_test_config(config_from(deployers));

        orch.deploy_all(&cfg, None, "").unwrap();

        assert_eq!(count.load(Ordering::SeqCst), 3);
    }
}