django-cfg 1.2.29__py3-none-any.whl → 1.3.1__py3-none-any.whl

django_cfg/apps/payments/services/core/fallback_service.py

@@ -1,432 +0,0 @@
-"""
-Provider Fallback Service.
-
-Handles automatic provider switching when providers become unavailable,
-ensuring payment system resilience and high availability.
-"""
-
-import logging
-from typing import Optional, List, Dict, Any
-from dataclasses import dataclass
-from enum import Enum
-
-from django.core.cache import cache
-from django.utils import timezone
-from pydantic import BaseModel, Field
-
-from ..monitoring.provider_health import get_health_monitor, HealthStatus
-from ..providers.registry import ProviderRegistry
-from ...models.events import PaymentEvent
-
-logger = logging.getLogger(__name__)
-
-
-class FallbackStrategy(Enum):
-    """Provider fallback strategies."""
-    ROUND_ROBIN = "round_robin"
-    PRIORITY_BASED = "priority_based"
-    HEALTH_BASED = "health_based"
-    RANDOM = "random"
-
-
-class ProviderPriority(BaseModel):
-    """Provider priority configuration."""
-    provider_name: str = Field(..., description="Provider name")
-    priority: int = Field(..., description="Priority (1=highest)")
-    enabled: bool = Field(default=True, description="Is provider enabled for fallback")
-    max_retry_attempts: int = Field(default=3, description="Max retry attempts before fallback")
-
-
-class FallbackResult(BaseModel):
-    """Result of fallback provider selection."""
-    success: bool = Field(..., description="Whether fallback was successful")
-    original_provider: str = Field(..., description="Original provider that failed")
-    fallback_provider: Optional[str] = Field(None, description="Selected fallback provider")
-    reason: str = Field(..., description="Reason for fallback")
-    retry_attempt: int = Field(default=0, description="Current retry attempt")
-    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
-
-
-class ProviderFallbackService:
-    """
-    Manages provider fallback logic for payment processing.
-    
-    Features:
-    - Multiple fallback strategies
-    - Provider priority management
-    - Health-based switching
-    - Retry logic with exponential backoff
-    - Fallback event tracking
-    """
-    
-    def __init__(self):
-        """Initialize fallback service."""
-        self.health_monitor = get_health_monitor()
-        self.provider_registry = ProviderRegistry()
-        
-        # Default provider priorities (can be configured)
-        self.provider_priorities = [
-            ProviderPriority(provider_name="cryptapi", priority=1, enabled=True),
-            ProviderPriority(provider_name="cryptomus", priority=2, enabled=True),
-            ProviderPriority(provider_name="nowpayments", priority=3, enabled=True),
-            ProviderPriority(provider_name="stripe", priority=4, enabled=True),
-        ]
-        
-        self.default_strategy = FallbackStrategy.HEALTH_BASED
-        self.max_fallback_attempts = 3
-        self.fallback_cache_timeout = 600  # 10 minutes
-    
-    def get_fallback_provider(
-        self,
-        failed_provider: str,
-        currency: str = None,
-        strategy: FallbackStrategy = None,
-        retry_attempt: int = 0
-    ) -> FallbackResult:
-        """
-        Get fallback provider when primary provider fails.
-        
-        Args:
-            failed_provider: Name of the provider that failed
-            currency: Required currency (for provider compatibility)
-            strategy: Fallback strategy to use
-            retry_attempt: Current retry attempt number
-            
-        Returns:
-            FallbackResult with fallback provider selection
-        """
-        if retry_attempt >= self.max_fallback_attempts:
-            return FallbackResult(
-                success=False,
-                original_provider=failed_provider,
-                reason=f"Max fallback attempts ({self.max_fallback_attempts}) exceeded",
-                retry_attempt=retry_attempt
-            )
-        
-        strategy = strategy or self.default_strategy
-        
-        try:
-            # Get available providers based on strategy
-            fallback_provider = self._select_fallback_provider(
-                failed_provider=failed_provider,
-                currency=currency,
-                strategy=strategy
-            )
-            
-            if not fallback_provider:
-                return FallbackResult(
-                    success=False,
-                    original_provider=failed_provider,
-                    reason="No healthy fallback providers available",
-                    retry_attempt=retry_attempt
-                )
-            
-            # Record fallback event
-            self._record_fallback_event(
-                failed_provider=failed_provider,
-                fallback_provider=fallback_provider,
-                strategy=strategy.value,
-                retry_attempt=retry_attempt
-            )
-            
-            # Cache fallback selection temporarily
-            cache_key = f"fallback_{failed_provider}_{fallback_provider}"
-            cache.set(cache_key, True, self.fallback_cache_timeout)
-            
-            logger.info(f"Fallback selected: {failed_provider} -> {fallback_provider} (attempt {retry_attempt + 1})")
-            
-            return FallbackResult(
-                success=True,
-                original_provider=failed_provider,
-                fallback_provider=fallback_provider,
-                reason=f"Fallback using {strategy.value} strategy",
-                retry_attempt=retry_attempt,
-                metadata={
-                    'strategy': strategy.value,
-                    'currency_filter': currency
-                }
-            )
-            
-        except Exception as e:
-            logger.error(f"Error selecting fallback provider: {e}")
-            return FallbackResult(
-                success=False,
-                original_provider=failed_provider,
-                reason=f"Fallback selection error: {str(e)}",
-                retry_attempt=retry_attempt
-            )
-    
-    def _select_fallback_provider(
-        self,
-        failed_provider: str,
-        currency: str = None,
-        strategy: FallbackStrategy = FallbackStrategy.HEALTH_BASED
-    ) -> Optional[str]:
-        """
-        Select fallback provider based on strategy.
-        
-        Args:
-            failed_provider: Provider that failed
-            currency: Required currency
-            strategy: Fallback strategy
-            
-        Returns:
-            Name of fallback provider or None
-        """
-        # Get all available providers
-        available_providers = list(self.provider_registry.get_all_providers().keys())
-        
-        # Remove failed provider
-        available_providers = [p for p in available_providers if p != failed_provider]
-        
-        if not available_providers:
-            return None
-        
-        # Filter by enabled providers
-        enabled_providers = [
-            p for p in available_providers 
-            if self._is_provider_enabled(p)
-        ]
-        
-        if not enabled_providers:
-            return None
-        
-        # Filter by currency support if specified
-        if currency:
-            currency_compatible = []
-            for provider_name in enabled_providers:
-                provider = self.provider_registry.get_provider(provider_name)
-                if provider and hasattr(provider, 'get_supported_currencies'):
-                    supported = provider.get_supported_currencies()
-                    if currency.upper() in [c.upper() for c in supported]:
-                        currency_compatible.append(provider_name)
-            enabled_providers = currency_compatible
-        
-        if not enabled_providers:
-            return None
-        
-        # Apply fallback strategy
-        if strategy == FallbackStrategy.HEALTH_BASED:
-            return self._select_by_health(enabled_providers)
-        elif strategy == FallbackStrategy.PRIORITY_BASED:
-            return self._select_by_priority(enabled_providers)
-        elif strategy == FallbackStrategy.ROUND_ROBIN:
-            return self._select_round_robin(enabled_providers)
-        elif strategy == FallbackStrategy.RANDOM:
-            import random
-            return random.choice(enabled_providers)
-        else:
-            # Default to health-based
-            return self._select_by_health(enabled_providers)
-    
-    def _select_by_health(self, providers: List[str]) -> Optional[str]:
-        """Select provider based on health status and response time."""
-        healthy_providers = self.health_monitor.get_healthy_providers()
-        
-        # Filter to only healthy providers from the available list
-        candidates = [p for p in providers if p in healthy_providers]
-        
-        if not candidates:
-            # No healthy providers, try degraded ones
-            all_health = self.health_monitor.check_all_providers()
-            degraded = [
-                p.provider_name for p in all_health.providers 
-                if p.status == HealthStatus.DEGRADED and p.provider_name in providers
-            ]
-            candidates = degraded
-        
-        if not candidates:
-            return None
-        
-        # Select provider with best response time among healthy ones
-        if len(candidates) == 1:
-            return candidates[0]
-        
-        # Get response times and select fastest
-        best_provider = None
-        best_response_time = float('inf')
-        
-        for provider_name in candidates:
-            health_check = self.health_monitor.check_provider_health(provider_name)
-            if health_check.response_time_ms < best_response_time:
-                best_response_time = health_check.response_time_ms
-                best_provider = provider_name
-        
-        return best_provider
-    
-    def _select_by_priority(self, providers: List[str]) -> Optional[str]:
-        """Select provider based on configured priority."""
-        # Sort providers by priority
-        provider_priorities = {p.provider_name: p.priority for p in self.provider_priorities}
-        
-        # Filter and sort available providers by priority
-        available_with_priority = [
-            (provider, provider_priorities.get(provider, 999))
-            for provider in providers
-            if provider in provider_priorities
-        ]
-        
-        if not available_with_priority:
-            # If no priorities configured, return first available
-            return providers[0] if providers else None
-        
-        # Sort by priority (lower number = higher priority)
-        available_with_priority.sort(key=lambda x: x[1])
-        
-        return available_with_priority[0][0]
-    
-    def _select_round_robin(self, providers: List[str]) -> Optional[str]:
-        """Select provider using round-robin algorithm."""
-        if not providers:
-            return None
-        
-        # Get current round-robin index from cache
-        cache_key = "fallback_round_robin_index"
-        current_index = cache.get(cache_key, 0)
-        
-        # Select provider at current index
-        selected_provider = providers[current_index % len(providers)]
-        
-        # Update index for next round
-        next_index = (current_index + 1) % len(providers)
-        cache.set(cache_key, next_index, 86400)  # Cache for 24 hours
-        
-        return selected_provider
-    
-    def _is_provider_enabled(self, provider_name: str) -> bool:
-        """Check if provider is enabled for fallback."""
-        for priority_config in self.provider_priorities:
-            if priority_config.provider_name == provider_name:
-                return priority_config.enabled
-        
-        # Default to enabled if not configured
-        return True
-    
-    def _record_fallback_event(
-        self,
-        failed_provider: str,
-        fallback_provider: str,
-        strategy: str,
-        retry_attempt: int
-    ):
-        """Record fallback event for audit trail."""
-        try:
-            PaymentEvent.objects.create(
-                payment_id=f"fallback_{timezone.now().timestamp()}",
-                event_type='provider_fallback',
-                sequence_number=1,
-                event_data={
-                    'failed_provider': failed_provider,
-                    'fallback_provider': fallback_provider,
-                    'strategy': strategy,
-                    'retry_attempt': retry_attempt,
-                    'timestamp': timezone.now().isoformat()
-                },
-                processed_by='fallback_service',
-                idempotency_key=f"fallback_{failed_provider}_{fallback_provider}_{timezone.now().timestamp()}"
-            )
-            
-        except Exception as e:
-            logger.error(f"Failed to record fallback event: {e}")
-    
-    def configure_provider_priority(self, provider_name: str, priority: int, enabled: bool = True):
-        """
-        Configure provider priority for fallback.
-        
-        Args:
-            provider_name: Name of the provider
-            priority: Priority level (1=highest)
-            enabled: Whether provider is enabled for fallback
-        """
-        # Update existing priority or create new one
-        for i, priority_config in enumerate(self.provider_priorities):
-            if priority_config.provider_name == provider_name:
-                self.provider_priorities[i] = ProviderPriority(
-                    provider_name=provider_name,
-                    priority=priority,
-                    enabled=enabled
-                )
-                return
-        
-        # Add new priority configuration
-        self.provider_priorities.append(ProviderPriority(
-            provider_name=provider_name,
-            priority=priority,
-            enabled=enabled
-        ))
-        
-        # Re-sort by priority
-        self.provider_priorities.sort(key=lambda x: x.priority)
-        
-        logger.info(f"Updated priority for {provider_name}: priority={priority}, enabled={enabled}")
-    
-    def get_fallback_statistics(self, days: int = 7) -> Dict[str, Any]:
-        """
-        Get fallback statistics for the specified period.
-        
-        Args:
-            days: Number of days to analyze
-            
-        Returns:
-            Dict with fallback statistics
-        """
-        try:
-            since_date = timezone.now() - timezone.timedelta(days=days)
-            
-            fallback_events = PaymentEvent.objects.filter(
-                event_type='provider_fallback',
-                created_at__gte=since_date
-            )
-            
-            stats = {
-                'total_fallbacks': fallback_events.count(),
-                'fallbacks_by_provider': {},
-                'fallbacks_by_strategy': {},
-                'most_failed_provider': None,
-                'most_used_fallback': None,
-                'period_days': days
-            }
-            
-            # Analyze fallback patterns
-            for event in fallback_events:
-                data = event.event_data
-                failed_provider = data.get('failed_provider')
-                fallback_provider = data.get('fallback_provider')
-                strategy = data.get('strategy')
-                
-                # Count by failed provider
-                if failed_provider:
-                    stats['fallbacks_by_provider'][failed_provider] = \
-                        stats['fallbacks_by_provider'].get(failed_provider, 0) + 1
-                
-                # Count by strategy
-                if strategy:
-                    stats['fallbacks_by_strategy'][strategy] = \
-                        stats['fallbacks_by_strategy'].get(strategy, 0) + 1
-            
-            # Find most problematic provider
-            if stats['fallbacks_by_provider']:
-                stats['most_failed_provider'] = max(
-                    stats['fallbacks_by_provider'].items(),
-                    key=lambda x: x[1]
-                )[0]
-            
-            return stats
-            
-        except Exception as e:
-            logger.error(f"Failed to get fallback statistics: {e}")
-            return {
-                'total_fallbacks': 0,
-                'fallbacks_by_provider': {},
-                'fallbacks_by_strategy': {},
-                'error': str(e)
-            }
-
-
-# Global fallback service instance
-fallback_service = ProviderFallbackService()
-
-
-def get_fallback_service() -> ProviderFallbackService:
-    """Get global fallback service instance."""
-    return fallback_service