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

django_cfg/apps/maintenance/services/site_sync_service.py

@@ -0,0 +1,390 @@
+"""
+Site synchronization service for automatic Cloudflare zone discovery.
+
+Automatically discovers and syncs Cloudflare zones with Django models.
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+from django.utils import timezone
+from django.db import transaction
+
+from ..models import CloudflareApiKey, CloudflareSite, MaintenanceLog
+from .maintenance_service import MaintenanceService
+from ..utils.retry_utils import retry_on_failure, CloudflareRetryError
+
+try:
+    from cloudflare import Cloudflare
+except ImportError:
+    raise ImportError("cloudflare library is required. Install with: pip install cloudflare>=4.3.0")
+
+logger = logging.getLogger(__name__)
+
+
+class SiteSyncService:
+    """
+    Service for synchronizing CloudflareSite models with actual Cloudflare zones.
+    
+    Provides automatic discovery and sync of Cloudflare zones.
+    """
+    
+    def __init__(self, api_key: CloudflareApiKey):
+        """Initialize sync service with API key."""
+        self.api_key = api_key
+        self.client = Cloudflare(api_token=api_key.api_token)
+        
+    @retry_on_failure(max_retries=3)
+    def discover_zones(self) -> List[Dict[str, Any]]:
+        """
+        Discover all zones in the Cloudflare account.
+        
+        Returns:
+            List of zone data dictionaries
+        """
+        logger.info(f"Discovering zones for API key: {self.api_key.name}")
+        
+        try:
+            zones = []
+            for zone in self.client.zones.list():
+                zone_data = {
+                    'id': zone.id,
+                    'name': zone.name,
+                    'account_id': zone.account.id if zone.account else None,
+                    'status': zone.status,
+                    'paused': zone.paused,
+                    'type': zone.type,
+                    'development_mode': zone.development_mode,
+                    'name_servers': zone.name_servers,
+                    'created_on': zone.created_on,
+                    'modified_on': zone.modified_on,
+                }
+                zones.append(zone_data)
+                
+            logger.info(f"Discovered {len(zones)} zones")
+            return zones
+            
+        except Exception as e:
+            logger.error(f"Failed to discover zones: {e}")
+            raise CloudflareRetryError(f"Zone discovery failed: {e}")
+    
+    def sync_zones(self, 
+                   force_update: bool = False,
+                   dry_run: bool = False) -> Dict[str, Any]:
+        """
+        Sync discovered zones with Django models.
+        
+        Args:
+            force_update: Update existing sites even if they haven't changed
+            dry_run: Only show what would be changed without making changes
+            
+        Returns:
+            Dict with sync statistics and results
+        """
+        logger.info(f"Starting zone sync (dry_run={dry_run}, force_update={force_update})")
+        
+        stats = {
+            'discovered': 0,
+            'created': 0,
+            'updated': 0,
+            'skipped': 0,
+            'errors': 0,
+            'sites': []
+        }
+        
+        try:
+            # Discover zones from Cloudflare
+            cf_zones = self.discover_zones()
+            stats['discovered'] = len(cf_zones)
+            
+            # Get existing sites for this API key
+            existing_sites = {
+                site.zone_id: site 
+                for site in CloudflareSite.objects.filter(api_key=self.api_key)
+            }
+            
+            # Process each discovered zone
+            for zone_data in cf_zones:
+                try:
+                    result = self._sync_single_zone(
+                        zone_data=zone_data,
+                        existing_sites=existing_sites,
+                        force_update=force_update,
+                        dry_run=dry_run
+                    )
+                    
+                    stats[result['action']] += 1
+                    stats['sites'].append(result)
+                    
+                except Exception as e:
+                    logger.error(f"Error syncing zone {zone_data['name']}: {e}")
+                    stats['errors'] += 1
+                    stats['sites'].append({
+                        'domain': zone_data['name'],
+                        'action': 'error',
+                        'error': str(e)
+                    })
+            
+            # Mark API key as used
+            self.api_key.mark_used()
+            
+            logger.info(f"Zone sync completed: {stats}")
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Zone sync failed: {e}")
+            stats['errors'] += 1
+            return stats
+    
+    def _sync_single_zone(self,
+                         zone_data: Dict[str, Any],
+                         existing_sites: Dict[str, CloudflareSite],
+                         force_update: bool,
+                         dry_run: bool) -> Dict[str, Any]:
+        """Sync a single zone with Django model."""
+        zone_id = zone_data['id']
+        domain = zone_data['name']
+        
+        if zone_id in existing_sites:
+            # Site exists - check if update needed
+            site = existing_sites[zone_id]
+            
+            needs_update = (
+                force_update or
+                site.domain != domain or
+                site.account_id != zone_data.get('account_id')
+            )
+            
+            if needs_update:
+                if dry_run:
+                    return {
+                        'domain': domain,
+                        'action': 'would_update',
+                        'changes': self._get_site_changes(site, zone_data)
+                    }
+                else:
+                    # Update existing site
+                    site.domain = domain
+                    site.account_id = zone_data.get('account_id', site.account_id)
+                    site.save()
+                    
+                    # Log the sync
+                    MaintenanceLog.log_success(
+                        site=site,
+                        action=MaintenanceLog.Action.SYNC,
+                        reason="Automatic zone sync - updated existing site"
+                    )
+                    
+                    return {
+                        'domain': domain,
+                        'action': 'updated',
+                        'site_id': site.id
+                    }
+            else:
+                return {
+                    'domain': domain,
+                    'action': 'skipped',
+                    'reason': 'No changes needed'
+                }
+        else:
+            # New site - create it
+            if dry_run:
+                return {
+                    'domain': domain,
+                    'action': 'would_create',
+                    'zone_data': zone_data
+                }
+            else:
+                # Create new site
+                site = CloudflareSite.objects.create(
+                    name=self._generate_site_name(domain),
+                    domain=domain,
+                    zone_id=zone_id,
+                    account_id=zone_data.get('account_id', ''),
+                    api_key=self.api_key,
+                    is_active=not zone_data.get('paused', False)
+                )
+                
+                # Log the creation
+                MaintenanceLog.log_success(
+                    site=site,
+                    action=MaintenanceLog.Action.SYNC,
+                    reason="Automatic zone sync - created new site"
+                )
+                
+                return {
+                    'domain': domain,
+                    'action': 'created',
+                    'site_id': site.id
+                }
+    
+    def _get_site_changes(self, site: CloudflareSite, zone_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get changes that would be made to a site."""
+        changes = {}
+        
+        if site.domain != zone_data['name']:
+            changes['domain'] = {
+                'old': site.domain,
+                'new': zone_data['name']
+            }
+        
+        if site.account_id != zone_data.get('account_id'):
+            changes['account_id'] = {
+                'old': site.account_id,
+                'new': zone_data.get('account_id')
+            }
+        
+        return changes
+    
+    def _generate_site_name(self, domain: str) -> str:
+        """Generate a friendly site name from domain."""
+        # Remove common prefixes and TLD for cleaner name
+        name = domain.replace('www.', '').replace('api.', '').replace('app.', '')
+        
+        # Capitalize first letter
+        if '.' in name:
+            name = name.split('.')[0].capitalize()
+        else:
+            name = name.capitalize()
+        
+        return name
+    
+    def check_site_status(self, site: CloudflareSite) -> Dict[str, Any]:
+        """
+        Check current status of a site in Cloudflare.
+        
+        Args:
+            site: CloudflareSite to check
+            
+        Returns:
+            Dict with status information
+        """
+        try:
+            # Get zone info
+            zone = self.client.zones.get(zone_id=site.zone_id)
+            
+            # Check if maintenance worker is active
+            maintenance_active = self._check_maintenance_worker(site)
+            
+            status_info = {
+                'zone_status': zone.status,
+                'zone_paused': zone.paused,
+                'development_mode': zone.development_mode,
+                'maintenance_active': maintenance_active,
+                'last_checked': timezone.now().isoformat()
+            }
+            
+            # Update site status
+            site.maintenance_active = maintenance_active
+            site.is_active = not zone.paused
+            site.save()
+            
+            return status_info
+            
+        except Exception as e:
+            logger.error(f"Failed to check status for {site.domain}: {e}")
+            return {
+                'error': str(e),
+                'last_checked': timezone.now().isoformat()
+            }
+    
+    @retry_on_failure(max_retries=2)
+    def _check_maintenance_worker(self, site: CloudflareSite) -> bool:
+        """Check if maintenance worker is active for site."""
+        try:
+            # List worker routes for the zone
+            routes = self.client.workers.routes.list(zone_id=site.zone_id)
+            
+            # Check if any route matches our maintenance worker pattern
+            maintenance_service = MaintenanceService(site)
+            worker_name = maintenance_service.worker_name
+            
+            for route in routes.result:
+                if hasattr(route, 'script') and route.script == worker_name:
+                    return True
+            
+            return False
+            
+        except Exception as e:
+            logger.warning(f"Could not check maintenance worker for {site.domain}: {e}")
+            return False
+    
+    def bulk_sync_all_api_keys(self) -> Dict[str, Any]:
+        """
+        Sync zones for all active API keys.
+        
+        Returns:
+            Dict with overall sync results
+        """
+        logger.info("Starting bulk sync for all API keys")
+        
+        overall_stats = {
+            'api_keys_processed': 0,
+            'total_discovered': 0,
+            'total_created': 0,
+            'total_updated': 0,
+            'total_skipped': 0,
+            'total_errors': 0,
+            'api_key_results': []
+        }
+        
+        active_api_keys = CloudflareApiKey.objects.filter(is_active=True)
+        
+        for api_key in active_api_keys:
+            try:
+                sync_service = SiteSyncService(api_key)
+                result = sync_service.sync_zones()
+                
+                overall_stats['api_keys_processed'] += 1
+                overall_stats['total_discovered'] += result['discovered']
+                overall_stats['total_created'] += result['created']
+                overall_stats['total_updated'] += result['updated']
+                overall_stats['total_skipped'] += result['skipped']
+                overall_stats['total_errors'] += result['errors']
+                
+                overall_stats['api_key_results'].append({
+                    'api_key_name': api_key.name,
+                    'success': True,
+                    'stats': result
+                })
+                
+            except Exception as e:
+                logger.error(f"Failed to sync API key {api_key.name}: {e}")
+                overall_stats['total_errors'] += 1
+                overall_stats['api_key_results'].append({
+                    'api_key_name': api_key.name,
+                    'success': False,
+                    'error': str(e)
+                })
+        
+        logger.info(f"Bulk sync completed: {overall_stats}")
+        return overall_stats
+
+
+def sync_site_from_cloudflare(site: CloudflareSite) -> MaintenanceLog:
+    """
+    Convenience function to sync a single site from Cloudflare.
+    
+    Args:
+        site: CloudflareSite to sync
+        
+    Returns:
+        MaintenanceLog entry for the sync operation
+    """
+    try:
+        sync_service = SiteSyncService(site.api_key)
+        status_info = sync_service.check_site_status(site)
+        
+        return MaintenanceLog.log_success(
+            site=site,
+            action=MaintenanceLog.Action.SYNC,
+            reason="Manual site sync",
+            cloudflare_response=status_info
+        )
+        
+    except Exception as e:
+        return MaintenanceLog.log_failure(
+            site=site,
+            action=MaintenanceLog.Action.SYNC,
+            error_message=str(e)
+        )

django_cfg/apps/maintenance/utils/__init__.py

@@ -0,0 +1,12 @@
+"""
+Maintenance utilities.
+
+Helper functions and classes for maintenance operations.
+"""
+
+from .retry_utils import retry_on_failure, CloudflareRetryError
+
+__all__ = [
+    'retry_on_failure',
+    'CloudflareRetryError',
+]

django_cfg/apps/maintenance/utils/retry_utils.py

@@ -0,0 +1,109 @@
+"""
+Retry utilities for Cloudflare operations.
+
+Simple retry logic extracted from the complex old system.
+"""
+
+import time
+import random
+import logging
+from typing import Callable, Any, List
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+
+class CloudflareRetryError(Exception):
+    """Exception raised when all retry attempts fail."""
+    pass
+
+
+def retry_on_failure(
+    max_retries: int = 3,
+    base_delay: float = 1.0,
+    max_delay: float = 30.0,
+    backoff_factor: float = 2.0,
+    retry_on_status: List[int] = None,
+    jitter: bool = True
+):
+    """
+    Decorator for retrying Cloudflare operations with exponential backoff.
+    
+    Args:
+        max_retries: Maximum number of retry attempts
+        base_delay: Initial delay between retries in seconds
+        max_delay: Maximum delay between retries in seconds
+        backoff_factor: Factor to multiply delay by after each retry
+        retry_on_status: HTTP status codes to retry on (deprecated, kept for compatibility)
+        jitter: Whether to add random jitter to delays
+    """
+    if retry_on_status is None:
+        retry_on_status = [429, 502, 503, 504]
+    
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            last_exception = None
+            
+            for attempt in range(max_retries + 1):
+                try:
+                    return func(*args, **kwargs)
+                    
+                except Exception as e:
+                    last_exception = e
+                    
+                    # Don't retry on the last attempt
+                    if attempt == max_retries:
+                        break
+                    
+                    # Check if we should retry based on the error
+                    should_retry = True  # Default to retry
+                    
+                    # Check for HTTP status codes in the error message
+                    error_str = str(e).lower()
+                    
+                    # Check if any custom retry status codes are in the error
+                    has_custom_status = False
+                    for status in retry_on_status:
+                        if str(status) in error_str:
+                            has_custom_status = True
+                            break
+                    
+                    # If we have custom status codes and found one, always retry
+                    if has_custom_status:
+                        should_retry = True
+                    else:
+                        # Don't retry on certain non-retryable errors (only if no custom status found)
+                        if any(keyword in error_str for keyword in [
+                            'authentication', 'unauthorized', 'forbidden', 'not found',
+                            'invalid', 'malformed'
+                        ]):
+                            should_retry = False
+                    
+                    if not should_retry:
+                        # Don't retry on non-retryable errors
+                        break
+                    
+                    # Calculate delay with exponential backoff and optional jitter
+                    delay = min(base_delay * (backoff_factor ** attempt), max_delay)
+                    if jitter:
+                        jitter_amount = random.uniform(0.1, 0.3) * delay
+                        total_delay = delay + jitter_amount
+                    else:
+                        total_delay = delay
+                    
+                    logger.warning(
+                        f"Attempt {attempt + 1}/{max_retries + 1} failed for {func.__name__}: {e}. "
+                        f"Retrying in {total_delay:.2f}s..."
+                    )
+                    
+                    time.sleep(total_delay)
+            
+            # All retries failed
+            raise CloudflareRetryError(
+                f"All {max_retries + 1} attempts failed for {func.__name__}. "
+                f"Last error: {last_exception}"
+            ) from last_exception
+        
+        return wrapper
+    return decorator

django_cfg/config.py

@@ -17,6 +17,9 @@ LIB_GITHUB_URL = "https://github.com/django-cfg/django-cfg"
 LIB_SUPPORT_URL = "https://djangocfg.com/support"
 LIB_HEALTH_URL = "/cfg/health/"
 
+def get_maintenance_url(domain: str) -> str:
+    """Get the maintenance URL for the current site."""
+    return f"{LIB_SITE_URL}/maintenance/{domain}/"
 
 def get_default_dropdown_items() -> List[SiteDropdownItem]:
     """Get default dropdown menu items for Unfold admin."""

django_cfg/core/config.py

@@ -154,6 +154,10 @@ class DjangoConfig(BaseModel):
         default=False,
         description="Enable django-cfg AI Agents application (agent definitions, executions, workflows, tools)",
     )
+    enable_maintenance: bool = Field(
+        default=False,
+        description="Enable django-cfg Maintenance application (multi-site maintenance mode with Cloudflare)",
+    )
 
     # === URLs ===
     site_url: str = Field(default="http://localhost:3000", description="Frontend site URL")
@@ -270,12 +274,6 @@ class DjangoConfig(BaseModel):
         description="Application limits configuration (file uploads, requests, etc.)",
     )
 
-    # === Maintenance Mode Configuration ===
-    enable_maintenance: bool = Field(
-        default=False,
-        description="Enable django-cfg Maintenance application (multi-site maintenance mode with Cloudflare)",
-    )
-
     # === Middleware Configuration ===
     custom_middleware: List[str] = Field(
         default_factory=list,

django_cfg/modules/django_unfold/dashboard.py

@@ -156,11 +156,10 @@ class DashboardManager(BaseCfgModule):
                 separator=True,
                 collapsible=True,
                 items=[
-                    NavigationItem(title="Cloudflare Sites", icon=Icons.CLOUD, link="/admin/django_cfg_maintenance/cloudflaresite/"),
-                    NavigationItem(title="Site Groups", icon=Icons.GROUP, link="/admin/django_cfg_maintenance/sitegroup/"),
-                    NavigationItem(title="Maintenance Events", icon=Icons.BUILD, link="/admin/django_cfg_maintenance/maintenanceevent/"),
-                    NavigationItem(title="Monitoring Targets", icon=Icons.MONITOR, link="/admin/django_cfg_maintenance/monitoringtarget/"),
-                    NavigationItem(title="Deployments", icon=Icons.ROCKET_LAUNCH, link="/admin/django_cfg_maintenance/cloudflaredeployment/"),
+                    NavigationItem(title="Cloudflare Sites", icon=Icons.CLOUD, link="/admin/maintenance/cloudflaresite/"),
+                    NavigationItem(title="API Keys", icon=Icons.KEY, link="/admin/maintenance/cloudflareapikey/"),
+                    NavigationItem(title="Maintenance Logs", icon=Icons.HISTORY, link="/admin/maintenance/maintenancelog/"),
+                    NavigationItem(title="Scheduled Maintenance", icon=Icons.SCHEDULE, link="/admin/maintenance/scheduledmaintenance/"),
                 ]
             ))
         

{django_cfg-1.2.16.dist-info → django_cfg-1.2.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.2.16
+Version: 1.2.18
 Summary: 🚀 Next-gen Django configuration: type-safety, AI features, blazing-fast setup, and automated best practices — all in one.
 Project-URL: Homepage, https://djangocfg.com
 Project-URL: Documentation, https://docs.djangocfg.com
@@ -264,6 +264,7 @@ class EnterpriseConfig(DjangoConfig):
     enable_leads: bool = True         # CRM integration
     enable_agents: bool = True        # AI workflow automation
     enable_knowbase: bool = True      # AI knowledge management
+    enable_maintenance: bool = True   # Multi-site Cloudflare maintenance
 
 config = EnterpriseConfig()
 ```
@@ -315,6 +316,34 @@ workflow = Workflow([
 result = workflow.run({"document_id": "doc_123"})
 ```
 
+### 🌐 **Multi-Site Cloudflare Maintenance**
+**Zero-configuration maintenance mode** for enterprise applications with automated monitoring.
+
+```python
+from django_cfg.apps.maintenance.services import MaintenanceManager
+
+# Enable maintenance for all production sites
+manager = MaintenanceManager(user)
+manager.bulk_enable_maintenance(
+    sites=CloudflareSite.objects.filter(environment='production'),
+    reason="Database migration",
+    message="🚀 Upgrading our systems. Back online in 30 minutes!"
+)
+
+# CLI management
+# python manage.py maintenance enable --environment production
+# python manage.py sync_cloudflare --api-token your_token
+```
+
+**Features:**
+- ✅ **Zero-config setup** - Just provide API token and domain
+- ✅ **Multi-site management** - Handle hundreds of sites with ORM queries  
+- ✅ **Automated monitoring** - Health checks with auto-triggers
+- ✅ **Rich admin interface** - Bulk operations and real-time status
+- ✅ **CLI automation** - Perfect for CI/CD pipelines
+
+[**📚 View Maintenance Documentation →**](https://docs.djangocfg.com/features/built-in-apps/maintenance)
+
 ### 🏢 **Enterprise User Management**
 **Multi-channel authentication** with OTP, SMS, email verification, and audit trails.
 
@@ -531,6 +560,7 @@ docker-compose up -d
 
 ### **🚀 Enterprise Features**
 - [**Built-in Applications**](https://docs.djangocfg.com/features/built-in-apps/accounts) - User management, support, CRM
+- [**Maintenance Management**](https://docs.djangocfg.com/features/built-in-apps/maintenance) - Multi-site Cloudflare maintenance
 - [**Modular System**](https://docs.djangocfg.com/features/modules/overview) - Email, SMS, LLM, currency modules
 - [**Third-party Integrations**](https://docs.djangocfg.com/features/integrations/patterns) - Dramatiq, Twilio, ngrok
 
@@ -749,6 +779,27 @@ python manage.py generate_deployment --platform=docker --environment=production
 curl http://localhost:8000/health/
 ```
 
+### **🌐 Multi-Site Maintenance Management**
+```bash
+# Enable maintenance for all production sites
+python manage.py maintenance enable --environment production --reason "Database upgrade"
+
+# Disable maintenance for specific project
+python manage.py maintenance disable --project ecommerce
+
+# Check status of all sites
+python manage.py maintenance status --format json
+
+# Auto-discover sites from Cloudflare
+python manage.py sync_cloudflare --api-token your_token
+
+# Bulk operations with filters
+python manage.py maintenance enable --tag critical --reason "Security patch"
+
+# Dry run to preview changes
+python manage.py maintenance enable --environment staging --dry-run
+```
+
 ---
 
 ## 🔒 Enterprise Security & Compliance