sal-kubernetes 0.1.0

//! Configuration for production safety features

use std::time::Duration;

/// Configuration for Kubernetes operations with production safety features
#[derive(Debug, Clone)]
pub struct KubernetesConfig {
    /// Timeout for individual API operations
    pub operation_timeout: Duration,
    
    /// Maximum number of retry attempts for failed operations
    pub max_retries: u32,
    
    /// Base delay for exponential backoff retry strategy
    pub retry_base_delay: Duration,
    
    /// Maximum delay between retries
    pub retry_max_delay: Duration,
    
    /// Rate limiting: maximum requests per second
    pub rate_limit_rps: u32,
    
    /// Rate limiting: burst capacity
    pub rate_limit_burst: u32,
}

impl Default for KubernetesConfig {
    fn default() -> Self {
        Self {
            // Conservative timeout for production
            operation_timeout: Duration::from_secs(30),
            
            // Reasonable retry attempts
            max_retries: 3,
            
            // Exponential backoff starting at 1 second
            retry_base_delay: Duration::from_secs(1),
            
            // Maximum 30 seconds between retries
            retry_max_delay: Duration::from_secs(30),
            
            // Conservative rate limiting: 10 requests per second
            rate_limit_rps: 10,
            
            // Allow small bursts
            rate_limit_burst: 20,
        }
    }
}

impl KubernetesConfig {
    /// Create a new configuration with custom settings
    pub fn new() -> Self {
        Self::default()
    }
    
    /// Set operation timeout
    pub fn with_timeout(mut self, timeout: Duration) -> Self {
        self.operation_timeout = timeout;
        self
    }
    
    /// Set retry configuration
    pub fn with_retries(mut self, max_retries: u32, base_delay: Duration, max_delay: Duration) -> Self {
        self.max_retries = max_retries;
        self.retry_base_delay = base_delay;
        self.retry_max_delay = max_delay;
        self
    }
    
    /// Set rate limiting configuration
    pub fn with_rate_limit(mut self, rps: u32, burst: u32) -> Self {
        self.rate_limit_rps = rps;
        self.rate_limit_burst = burst;
        self
    }
    
    /// Create configuration optimized for high-throughput environments
    pub fn high_throughput() -> Self {
        Self {
            operation_timeout: Duration::from_secs(60),
            max_retries: 5,
            retry_base_delay: Duration::from_millis(500),
            retry_max_delay: Duration::from_secs(60),
            rate_limit_rps: 50,
            rate_limit_burst: 100,
        }
    }
    
    /// Create configuration optimized for low-latency environments
    pub fn low_latency() -> Self {
        Self {
            operation_timeout: Duration::from_secs(10),
            max_retries: 2,
            retry_base_delay: Duration::from_millis(100),
            retry_max_delay: Duration::from_secs(5),
            rate_limit_rps: 20,
            rate_limit_burst: 40,
        }
    }
    
    /// Create configuration for development/testing
    pub fn development() -> Self {
        Self {
            operation_timeout: Duration::from_secs(120),
            max_retries: 1,
            retry_base_delay: Duration::from_millis(100),
            retry_max_delay: Duration::from_secs(2),
            rate_limit_rps: 100,
            rate_limit_burst: 200,
        }
    }
}