django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/apps/maintenance/services/bulk_operations_service.py

@@ -5,51 +5,51 @@ Provides ORM-like interface for bulk maintenance operations across multiple site
 """
 
 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 typing import Any, Dict, List, Optional, Union
 
-from ..models import CloudflareSite, MaintenanceLog, CloudflareApiKey
-from .maintenance_service import MaintenanceService
+from django.db.models import Q, QuerySet
+from django.utils import timezone
+
+from ..models import CloudflareApiKey, CloudflareSite, MaintenanceLog
 from ..utils.retry_utils import retry_on_failure
+from .maintenance_service import MaintenanceService
 
 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(
@@ -57,39 +57,39 @@ class SiteQuerySet:
                 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, 
+    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',
@@ -97,46 +97,46 @@ class SiteQuerySet:
             template=template,
             max_workers=max_workers
         )
-    
-    def disable_maintenance(self, 
+
+    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,
@@ -151,10 +151,10 @@ class SiteQuerySet:
             '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
@@ -162,7 +162,7 @@ class SiteQuerySet:
                 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]
@@ -184,22 +184,22 @@ class SiteQuerySet:
                         '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, 
+    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'),
@@ -213,7 +213,7 @@ class SiteQuerySet:
                     },
                     'error': log_entry.error_message if log_entry.status == MaintenanceLog.Status.FAILED else None
                 }
-            
+
             elif operation == 'disable':
                 log_entry = service.disable_maintenance()
                 return {
@@ -224,7 +224,7 @@ class SiteQuerySet:
                     },
                     'error': log_entry.error_message if log_entry.status == MaintenanceLog.Status.FAILED else None
                 }
-            
+
             elif operation == 'status':
                 status = service.get_status()
                 return {
@@ -234,7 +234,7 @@ class SiteQuerySet:
                         'last_checked': timezone.now().isoformat()
                     }
                 }
-            
+
             elif operation == 'sync':
                 from .site_sync_service import sync_site_from_cloudflare
                 log_entry = sync_site_from_cloudflare(site)
@@ -246,13 +246,13 @@ class SiteQuerySet:
                     },
                     '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 {
@@ -263,36 +263,36 @@ class SiteQuerySet:
 
 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, 
+
+    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)
@@ -307,11 +307,11 @@ class BulkOperationsService:
                 '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(),
@@ -320,7 +320,7 @@ class BulkOperationsService:
             '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)
@@ -329,26 +329,26 @@ class BulkOperationsService:
                 'active': key_sites.filter(is_active=True).count(),
                 'maintenance': key_sites.filter(maintenance_active=True).count()
             }
-        
+
         return stats
-    
-    def emergency_disable_all(self, 
+
+    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, 
+
+    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,
@@ -361,7 +361,7 @@ bulk_operations = BulkOperationsService()
 
 
 # Convenience functions
-def enable_maintenance_for_domains(domains: List[str], 
+def enable_maintenance_for_domains(domains: List[str],
                                   reason: str = "Bulk operation",
                                   template: str = "modern") -> Dict[str, Any]:
     """Enable maintenance for specific domains."""
@@ -383,7 +383,7 @@ def bulk_sync_all_sites() -> Dict[str, Any]:
 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'] = [
@@ -396,5 +396,5 @@ def get_maintenance_status_report() -> Dict[str, Any]:
         }
         for log in recent_logs
     ]
-    
+
     return stats