django-cfg 1.2.16__py3-none-any.whl → 1.2.18__py3-none-any.whl

django_cfg/apps/maintenance/services/bulk_operations_service.py

@@ -0,0 +1,400 @@
+"""
+Bulk operations service for managing multiple sites.
+
+Provides ORM-like interface for bulk maintenance operations across multiple sites.
+"""
+
+import logging
+import asyncio
+from typing import List, Dict, Any, Optional, Union
+from django.db.models import QuerySet, Q
+from django.utils import timezone
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from ..models import CloudflareSite, MaintenanceLog, CloudflareApiKey
+from .maintenance_service import MaintenanceService
+from ..utils.retry_utils import retry_on_failure
+
+logger = logging.getLogger(__name__)
+
+
+class SiteQuerySet:
+    """ORM-like interface for site operations."""
+    
+    def __init__(self, queryset: QuerySet[CloudflareSite]):
+        self.queryset = queryset
+    
+    def filter(self, **kwargs) -> 'SiteQuerySet':
+        """Filter sites with Django ORM syntax."""
+        return SiteQuerySet(self.queryset.filter(**kwargs))
+    
+    def exclude(self, **kwargs) -> 'SiteQuerySet':
+        """Exclude sites with Django ORM syntax."""
+        return SiteQuerySet(self.queryset.exclude(**kwargs))
+    
+    def active(self) -> 'SiteQuerySet':
+        """Filter active sites."""
+        return SiteQuerySet(self.queryset.filter(is_active=True))
+    
+    def in_maintenance(self) -> 'SiteQuerySet':
+        """Filter sites currently in maintenance."""
+        return SiteQuerySet(self.queryset.filter(maintenance_active=True))
+    
+    def not_in_maintenance(self) -> 'SiteQuerySet':
+        """Filter sites not in maintenance."""
+        return SiteQuerySet(self.queryset.filter(maintenance_active=False))
+    
+    def by_api_key(self, api_key: Union[CloudflareApiKey, str]) -> 'SiteQuerySet':
+        """Filter sites by API key."""
+        if isinstance(api_key, str):
+            return SiteQuerySet(self.queryset.filter(api_key__name=api_key))
+        return SiteQuerySet(self.queryset.filter(api_key=api_key))
+    
+    def search(self, query: str) -> 'SiteQuerySet':
+        """Search sites by name or domain."""
+        return SiteQuerySet(
+            self.queryset.filter(
+                Q(name__icontains=query) | Q(domain__icontains=query)
+            )
+        )
+    
+    def count(self) -> int:
+        """Count sites in queryset."""
+        return self.queryset.count()
+    
+    def all(self) -> List[CloudflareSite]:
+        """Get all sites in queryset."""
+        return list(self.queryset.all())
+    
+    def first(self) -> Optional[CloudflareSite]:
+        """Get first site in queryset."""
+        return self.queryset.first()
+    
+    def get(self, **kwargs) -> CloudflareSite:
+        """Get single site."""
+        return self.queryset.get(**kwargs)
+    
+    # Bulk Operations
+    def enable_maintenance(self, 
+                          reason: str = "Bulk maintenance operation",
+                          template: str = "modern",
+                          max_workers: int = 5,
+                          dry_run: bool = False) -> Dict[str, Any]:
+        """Enable maintenance mode for all sites in queryset."""
+        sites = self.queryset.filter(maintenance_active=False)
+        
+        if dry_run:
+            return {
+                'total': sites.count(),
+                'would_affect': [site.domain for site in sites],
+                'dry_run': True
+            }
+        
+        return self._execute_bulk_operation(
+            sites=sites,
+            operation='enable',
+            reason=reason,
+            template=template,
+            max_workers=max_workers
+        )
+    
+    def disable_maintenance(self, 
+                           max_workers: int = 5,
+                           dry_run: bool = False) -> Dict[str, Any]:
+        """Disable maintenance mode for all sites in queryset."""
+        sites = self.queryset.filter(maintenance_active=True)
+        
+        if dry_run:
+            return {
+                'total': sites.count(),
+                'would_affect': [site.domain for site in sites],
+                'dry_run': True
+            }
+        
+        return self._execute_bulk_operation(
+            sites=sites,
+            operation='disable',
+            max_workers=max_workers
+        )
+    
+    def check_status(self, max_workers: int = 10) -> Dict[str, Any]:
+        """Check status of all sites in queryset."""
+        sites = self.queryset.all()
+        
+        return self._execute_bulk_operation(
+            sites=sites,
+            operation='status',
+            max_workers=max_workers
+        )
+    
+    def sync_from_cloudflare(self, max_workers: int = 5) -> Dict[str, Any]:
+        """Sync all sites from Cloudflare."""
+        sites = self.queryset.all()
+        
+        return self._execute_bulk_operation(
+            sites=sites,
+            operation='sync',
+            max_workers=max_workers
+        )
+    
+    def _execute_bulk_operation(self,
+                               sites: QuerySet[CloudflareSite],
+                               operation: str,
+                               max_workers: int = 5,
+                               **kwargs) -> Dict[str, Any]:
+        """Execute bulk operation on sites with threading."""
+        results = {
+            'total': sites.count(),
+            'successful': [],
+            'failed': [],
+            'skipped': [],
+            'operation': operation,
+            'started_at': timezone.now().isoformat()
+        }
+        
+        if results['total'] == 0:
+            return results
+        
+        # Execute operations in parallel using ThreadPoolExecutor
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Submit all tasks
+            future_to_site = {
+                executor.submit(self._execute_single_operation, site, operation, **kwargs): site
+                for site in sites
+            }
+            
+            # Collect results
+            for future in as_completed(future_to_site):
+                site = future_to_site[future]
+                try:
+                    result = future.result()
+                    if result['success']:
+                        results['successful'].append({
+                            'domain': site.domain,
+                            'result': result.get('data')
+                        })
+                    else:
+                        results['failed'].append({
+                            'domain': site.domain,
+                            'error': result.get('error', 'Unknown error')
+                        })
+                except Exception as e:
+                    logger.error(f"Bulk operation failed for {site.domain}: {e}")
+                    results['failed'].append({
+                        'domain': site.domain,
+                        'error': str(e)
+                    })
+        
+        results['completed_at'] = timezone.now().isoformat()
+        results['success_rate'] = len(results['successful']) / results['total'] * 100
+        
+        logger.info(f"Bulk {operation} completed: {len(results['successful'])}/{results['total']} successful")
+        return results
+    
+    @retry_on_failure(max_retries=2)
+    def _execute_single_operation(self, 
+                                 site: CloudflareSite, 
+                                 operation: str, 
+                                 **kwargs) -> Dict[str, Any]:
+        """Execute single operation on a site."""
+        try:
+            service = MaintenanceService(site)
+            
+            if operation == 'enable':
+                log_entry = service.enable_maintenance(
+                    reason=kwargs.get('reason', 'Bulk operation'),
+                    template=kwargs.get('template', 'modern')
+                )
+                return {
+                    'success': log_entry.status == MaintenanceLog.Status.SUCCESS,
+                    'data': {
+                        'log_id': log_entry.id,
+                        'duration': log_entry.duration_seconds
+                    },
+                    'error': log_entry.error_message if log_entry.status == MaintenanceLog.Status.FAILED else None
+                }
+            
+            elif operation == 'disable':
+                log_entry = service.disable_maintenance()
+                return {
+                    'success': log_entry.status == MaintenanceLog.Status.SUCCESS,
+                    'data': {
+                        'log_id': log_entry.id,
+                        'duration': log_entry.duration_seconds
+                    },
+                    'error': log_entry.error_message if log_entry.status == MaintenanceLog.Status.FAILED else None
+                }
+            
+            elif operation == 'status':
+                status = service.get_status()
+                return {
+                    'success': True,
+                    'data': {
+                        'maintenance_active': status,
+                        'last_checked': timezone.now().isoformat()
+                    }
+                }
+            
+            elif operation == 'sync':
+                from .site_sync_service import sync_site_from_cloudflare
+                log_entry = sync_site_from_cloudflare(site)
+                return {
+                    'success': log_entry.status == MaintenanceLog.Status.SUCCESS,
+                    'data': {
+                        'log_id': log_entry.id,
+                        'response': log_entry.cloudflare_response
+                    },
+                    'error': log_entry.error_message if log_entry.status == MaintenanceLog.Status.FAILED else None
+                }
+            
+            else:
+                return {
+                    'success': False,
+                    'error': f'Unknown operation: {operation}'
+                }
+                
+        except Exception as e:
+            logger.error(f"Operation {operation} failed for {site.domain}: {e}")
+            return {
+                'success': False,
+                'error': str(e)
+            }
+
+
+class BulkOperationsService:
+    """Main service for bulk operations on sites."""
+    
+    def __init__(self):
+        """Initialize bulk operations service."""
+        pass
+    
+    def sites(self, queryset: Optional[QuerySet[CloudflareSite]] = None) -> SiteQuerySet:
+        """Get sites queryset for bulk operations."""
+        if queryset is None:
+            queryset = CloudflareSite.objects.all()
+        
+        return SiteQuerySet(queryset)
+    
+    def all_sites(self) -> SiteQuerySet:
+        """Get all sites."""
+        return self.sites()
+    
+    def active_sites(self) -> SiteQuerySet:
+        """Get all active sites."""
+        return self.sites().active()
+    
+    def maintenance_sites(self) -> SiteQuerySet:
+        """Get sites currently in maintenance."""
+        return self.sites().in_maintenance()
+    
+    def discover_and_create_sites(self, 
+                                 api_key: CloudflareApiKey,
+                                 dry_run: bool = False) -> Dict[str, Any]:
+        """Discover zones from Cloudflare and create sites."""
+        from .site_sync_service import SiteSyncService
+        
+        try:
+            sync_service = SiteSyncService(api_key)
+            return sync_service.sync_zones(dry_run=dry_run)
+        except Exception as e:
+            logger.error(f"Failed to discover sites for {api_key.name}: {e}")
+            return {
+                'success': False,
+                'error': str(e),
+                'discovered': 0,
+                'created': 0,
+                'updated': 0,
+                'skipped': 0,
+                'errors': 1
+            }
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get overall statistics for all sites."""
+        all_sites = CloudflareSite.objects.all()
+        
+        stats = {
+            'total_sites': all_sites.count(),
+            'active_sites': all_sites.filter(is_active=True).count(),
+            'maintenance_sites': all_sites.filter(maintenance_active=True).count(),
+            'api_keys_count': CloudflareApiKey.objects.filter(is_active=True).count(),
+            'recent_logs': MaintenanceLog.objects.count(),
+            'by_api_key': {}
+        }
+        
+        # Statistics by API key
+        for api_key in CloudflareApiKey.objects.filter(is_active=True):
+            key_sites = all_sites.filter(api_key=api_key)
+            stats['by_api_key'][api_key.name] = {
+                'total': key_sites.count(),
+                'active': key_sites.filter(is_active=True).count(),
+                'maintenance': key_sites.filter(maintenance_active=True).count()
+            }
+        
+        return stats
+    
+    def emergency_disable_all(self, 
+                             reason: str = "Emergency maintenance disable",
+                             max_workers: int = 10) -> Dict[str, Any]:
+        """Emergency disable maintenance for all sites."""
+        logger.warning("Emergency disable maintenance for ALL sites")
+        
+        return self.maintenance_sites().disable_maintenance(
+            max_workers=max_workers
+        )
+    
+    def emergency_enable_all(self, 
+                            reason: str = "Emergency maintenance enable",
+                            template: str = "minimal",
+                            max_workers: int = 10) -> Dict[str, Any]:
+        """Emergency enable maintenance for all sites."""
+        logger.warning("Emergency enable maintenance for ALL sites")
+        
+        return self.active_sites().not_in_maintenance().enable_maintenance(
+            reason=reason,
+            template=template,
+            max_workers=max_workers
+        )
+
+
+# Global instance
+bulk_operations = BulkOperationsService()
+
+
+# Convenience functions
+def enable_maintenance_for_domains(domains: List[str], 
+                                  reason: str = "Bulk operation",
+                                  template: str = "modern") -> Dict[str, Any]:
+    """Enable maintenance for specific domains."""
+    sites = CloudflareSite.objects.filter(domain__in=domains)
+    return bulk_operations.sites(sites).enable_maintenance(reason=reason, template=template)
+
+
+def disable_maintenance_for_domains(domains: List[str]) -> Dict[str, Any]:
+    """Disable maintenance for specific domains."""
+    sites = CloudflareSite.objects.filter(domain__in=domains)
+    return bulk_operations.sites(sites).disable_maintenance()
+
+
+def bulk_sync_all_sites() -> Dict[str, Any]:
+    """Sync all sites from Cloudflare."""
+    return bulk_operations.all_sites().sync_from_cloudflare()
+
+
+def get_maintenance_status_report() -> Dict[str, Any]:
+    """Get comprehensive maintenance status report."""
+    stats = bulk_operations.get_statistics()
+    
+    # Add recent activity
+    recent_logs = MaintenanceLog.objects.order_by('-created_at')[:10]
+    stats['recent_activity'] = [
+        {
+            'site': log.site.domain,
+            'action': log.get_action_display(),
+            'status': log.get_status_display(),
+            'created_at': log.created_at.isoformat(),
+            'duration': log.duration_seconds
+        }
+        for log in recent_logs
+    ]
+    
+    return stats

django_cfg/apps/maintenance/services/maintenance_service.py

@@ -0,0 +1,230 @@
+"""
+Super simple maintenance service using Page Rules.
+
+No Workers, no templates, no complexity - just Page Rules!
+"""
+
+import logging
+import time
+from typing import Dict, Any
+from cloudflare import Cloudflare
+
+from ..models import CloudflareSite, MaintenanceLog
+from ..utils import retry_on_failure
+
+logger = logging.getLogger(__name__)
+
+class MaintenanceService:
+    """
+    Simple maintenance via Cloudflare Page Rules.
+    
+    Enable: Create Page Rule redirect to maintenance.reforms.ai
+    Disable: Delete Page Rule
+    """
+    
+    def __init__(self, site: CloudflareSite):
+        """Initialize service for specific site."""
+        self.site = site
+        self.client = Cloudflare(api_token=site.api_key.api_token)
+    
+    def enable_maintenance(self, reason: str = "Scheduled maintenance") -> MaintenanceLog:
+        """
+        Enable maintenance mode using Page Rule redirect.
+        
+        Steps:
+        1. Create Page Rule redirect to maintenance.reforms.ai
+        2. Update site.maintenance_active = True
+        3. Log the operation
+        """
+        start_time = time.time()
+        log_entry = MaintenanceLog.log_pending(self.site, MaintenanceLog.Action.ENABLE, reason)
+        
+        try:
+            # 1. Create Page Rule for maintenance redirect
+            logger.info(f"Creating page rule for: {self.site.domain} → {self.site.get_maintenance_url()}")
+            page_rule_response = self._create_maintenance_page_rule()
+            
+            # 2. Update site status
+            self.site.enable_maintenance()
+            
+            # 3. Log success
+            duration = int(time.time() - start_time)
+            log_entry.status = MaintenanceLog.Status.SUCCESS
+            log_entry.duration_seconds = duration
+            log_entry.cloudflare_response = {
+                'page_rule_create': self._serialize_response(page_rule_response)
+            }
+            log_entry.save()
+            
+            return log_entry
+            
+        except Exception as e:
+            # Log failure
+            duration = int(time.time() - start_time)
+            log_entry.status = MaintenanceLog.Status.FAILED
+            log_entry.error_message = str(e)
+            log_entry.duration_seconds = duration
+            log_entry.save()
+            
+            raise e
+    
+    def disable_maintenance(self) -> MaintenanceLog:
+        """
+        Disable maintenance mode by removing Page Rule.
+        
+        Steps:
+        1. Remove Page Rule redirect
+        2. Update site.maintenance_active = False  
+        3. Log the operation
+        """
+        start_time = time.time()
+        log_entry = MaintenanceLog.log_pending(self.site, MaintenanceLog.Action.DISABLE)
+        
+        try:
+            # 1. Remove Page Rule
+            logger.info(f"Removing page rule for: {self.site.domain}")
+            page_rule_response = self._delete_maintenance_page_rule()
+            
+            # 2. Update site status
+            self.site.disable_maintenance()
+            
+            # 3. Log success
+            duration = int(time.time() - start_time)
+            log_entry.status = MaintenanceLog.Status.SUCCESS
+            log_entry.duration_seconds = duration
+            log_entry.cloudflare_response = {
+                'page_rule_delete': self._serialize_response(page_rule_response)
+            }
+            log_entry.save()
+            
+            return log_entry
+            
+        except Exception as e:
+            # Log failure
+            duration = int(time.time() - start_time)
+            log_entry.status = MaintenanceLog.Status.FAILED
+            log_entry.error_message = str(e)
+            log_entry.duration_seconds = duration
+            log_entry.save()
+            
+            raise e
+    
+    def get_status(self) -> bool:
+        """Get current maintenance status for site."""
+        return self.site.maintenance_active
+    
+    # Private helper methods
+    
+    def _serialize_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert Cloudflare API response to JSON serializable format."""
+        import json
+        from datetime import datetime
+        
+        def convert_datetime(obj):
+            if isinstance(obj, datetime):
+                return obj.isoformat()
+            elif isinstance(obj, dict):
+                return {k: convert_datetime(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [convert_datetime(item) for item in obj]
+            else:
+                return obj
+        
+        try:
+            # Convert all datetime objects to ISO strings
+            serializable = convert_datetime(response)
+            # Test JSON serialization
+            json.dumps(serializable)
+            return serializable
+        except Exception:
+            # If serialization fails, return simple success message
+            return {"success": True, "serialization_error": True}
+    
+    @retry_on_failure(max_retries=3, base_delay=1.0)
+    def _create_maintenance_page_rule(self) -> Dict[str, Any]:
+        """Create Page Rule to redirect all traffic to maintenance page."""
+        maintenance_url = self.site.get_maintenance_url()
+        pattern = f"{self.site.domain}/*"
+        
+        logger.info(f"Creating page rule: {pattern} → {maintenance_url}")
+        
+        response = self.client.page_rules.create(
+            zone_id=self.site.zone_id,
+            targets=[{
+                "target": "url",
+                "constraint": {
+                    "operator": "matches",
+                    "value": pattern
+                }
+            }],
+            actions=[{
+                "id": "forwarding_url",
+                "value": {
+                    "url": maintenance_url,
+                    "status_code": 302
+                }
+            }],
+            status="active"
+        )
+        return response.model_dump()
+    
+    @retry_on_failure(max_retries=3, base_delay=1.0)
+    def _delete_maintenance_page_rule(self) -> Dict[str, Any]:
+        """Delete maintenance Page Rule with retry logic."""
+        # Find the maintenance page rule
+        page_rules_response = self.client.page_rules.list(zone_id=self.site.zone_id)
+        
+        # Handle different API response formats
+        if hasattr(page_rules_response, 'result'):
+            page_rules = page_rules_response.result
+        else:
+            page_rules = page_rules_response
+        
+        maintenance_pattern = f"{self.site.domain}/*"
+        maintenance_url = self.site.get_maintenance_url()
+        
+        logger.info(f"Looking for page rule to delete: pattern={maintenance_pattern}, url={maintenance_url}")
+        logger.info(f"Found {len(page_rules)} page rules total")
+        
+        for rule in page_rules:
+            logger.info(f"Checking rule {rule.id}: targets={getattr(rule, 'targets', None)}, actions={getattr(rule, 'actions', None)}")
+            
+            # Simple check - look for forwarding_url action with maintenance URL
+            if (hasattr(rule, 'actions') and rule.actions and 
+                len(rule.actions) > 0 and 
+                hasattr(rule.actions[0], 'id') and 
+                rule.actions[0].id == "forwarding_url"):
+                
+                # Check if URL contains maintenance.reforms.ai
+                action_value = getattr(rule.actions[0], 'value', {})
+                action_url = getattr(action_value, 'url', '')
+                
+                logger.info(f"Found forwarding rule with URL: {action_url}")
+                
+                if "maintenance.reforms.ai" in action_url:
+                    logger.info(f"Deleting maintenance page rule: {rule.id}")
+                    response = self.client.page_rules.delete(
+                        zone_id=self.site.zone_id,
+                        pagerule_id=rule.id
+                    )
+                    return response.model_dump()
+        
+        logger.warning(f"No maintenance page rule found for {self.site.domain}")
+        return {"success": True, "message": "No page rule to delete"}
+    
+
+
+# Convenience functions for easy usage
+
+def enable_maintenance_for_domain(domain: str, reason: str = "Scheduled maintenance") -> MaintenanceLog:
+    """Enable maintenance for a domain."""
+    site = CloudflareSite.objects.get(domain=domain)
+    service = MaintenanceService(site)
+    return service.enable_maintenance(reason)
+
+
+def disable_maintenance_for_domain(domain: str) -> MaintenanceLog:
+    """Disable maintenance for a domain."""
+    site = CloudflareSite.objects.get(domain=domain)
+    service = MaintenanceService(site)
+    return service.disable_maintenance()