madbase/control-plane-api/src/providers/factory.rs

use anyhow::Result;
use std::sync::Arc;

use super::{VpsProvider as VpsProviderEnum, VpsProviderTrait};
use super::hetzner::HetznerProvider;
use super::generic::GenericProvider;

pub struct ProviderFactory;

impl ProviderFactory {
    pub async fn create_provider(
        provider: VpsProviderEnum,
        config: &ProviderConfig,
    ) -> Result<Arc<dyn VpsProviderTrait>> {
        match provider {
            VpsProviderEnum::Hetzner => {
                let api_key = config
                    .hetzner_api_key
                    .as_ref()
                    .ok_or_else(|| anyhow::anyhow!("Hetzner API key required"))?;
                Ok(Arc::new(HetznerProvider::new(api_key.clone())))
            }
            VpsProviderEnum::DigitalOcean => {
                // TODO: Implement DigitalOcean provider
                Ok(Arc::new(GenericProvider::new(
                    config.digital_ocean_endpoint.clone(),
                    config.digital_ocean_api_key.clone(),
                )))
            }
            VpsProviderEnum::Linode => {
                // TODO: Implement Linode provider
                Ok(Arc::new(GenericProvider::new(
                    config.linode_endpoint.clone(),
                    config.linode_api_key.clone(),
                )))
            }
            VpsProviderEnum::Vultr => {
                // TODO: Implement Vultr provider
                Ok(Arc::new(GenericProvider::new(
                    config.vultr_endpoint.clone(),
                    config.vultr_api_key.clone(),
                )))
            }
            VpsProviderEnum::Generic => {
                Ok(Arc::new(GenericProvider::new(
                    config.generic_endpoint.clone(),
                    config.generic_api_key.clone(),
                )))
            }
            _ => {
                Ok(Arc::new(GenericProvider::new(None, None)))
            }
        }
    }
}

#[derive(Debug, Clone)]
pub struct ProviderConfig {
    pub hetzner_api_key: Option<String>,
    pub digital_ocean_api_key: Option<String>,
    pub digital_ocean_endpoint: Option<String>,
    pub linode_api_key: Option<String>,
    pub linode_endpoint: Option<String>,
    pub vultr_api_key: Option<String>,
    pub vultr_endpoint: Option<String>,
    pub generic_endpoint: Option<String>,
    pub generic_api_key: Option<String>,
}

impl ProviderConfig {
    pub fn from_env() -> Self {
        Self {
            hetzner_api_key: std::env::var("HETZNER_API_KEY").ok(),
            digital_ocean_api_key: std::env::var("DIGITALOCEAN_API_KEY").ok(),
            digital_ocean_endpoint: std::env::var("DIGITALOCEAN_ENDPOINT").ok(),
            linode_api_key: std::env::var("LINODE_API_KEY").ok(),
            linode_endpoint: std::env::var("LINODE_ENDPOINT").ok(),
            vultr_api_key: std::env::var("VULTR_API_KEY").ok(),
            vultr_endpoint: std::env::var("VULTR_ENDPOINT").ok(),
            generic_endpoint: std::env::var("GENERIC_ENDPOINT").ok(),
            generic_api_key: std::env::var("GENERIC_API_KEY").ok(),
        }
    }
}