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

django_cfg/models/cloudflare.py

@@ -0,0 +1,316 @@
+"""
+Cloudflare configuration models for django_cfg.
+
+Type-safe Cloudflare maintenance mode configuration following CRITICAL_REQUIREMENTS.
+No raw Dict/Any usage - everything through Pydantic v2 models.
+"""
+
+from typing import Annotated, Optional, List, Dict, Any
+from pydantic import BaseModel, Field, SecretStr, field_validator, HttpUrl
+from enum import Enum
+from datetime import timedelta
+
+
+class MaintenanceTemplate(str, Enum):
+    """Available maintenance page templates."""
+    BASIC = "basic"
+    MODERN = "modern"
+    CUSTOM = "custom"
+
+
+class CloudflareConfig(BaseModel):
+    """
+    Zero-configuration Cloudflare maintenance mode setup.
+    
+    Following KISS principle - user provides only api_token and domain,
+    everything else is auto-discovered and configured.
+    """
+    
+    model_config = {
+        "env_prefix": "CLOUDFLARE_",
+        "case_sensitive": False,
+        "validate_assignment": True,
+        "extra": "forbid",
+        "str_strip_whitespace": True,
+    }
+    
+    # === Required Configuration (Zero-config approach) ===
+    api_token: SecretStr = Field(
+        description="Cloudflare API token with Zone:Edit permissions"
+    )
+    domain: Annotated[str, Field(
+        min_length=3,
+        max_length=253,
+        pattern=r"^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)*$",
+        description="Domain name (auto-discovers Zone ID)"
+    )]
+    
+    # === Auto-discovered Fields (set by system) ===
+    zone_id: Optional[str] = Field(
+        default=None, 
+        description="Auto-discovered Cloudflare Zone ID"
+    )
+    account_id: Optional[str] = Field(
+        default=None, 
+        description="Auto-discovered Cloudflare Account ID"
+    )
+    
+    # === Optional Customization ===
+    enabled: bool = Field(
+        default=True,
+        description="Enable Cloudflare maintenance mode integration"
+    )
+    
+    template: MaintenanceTemplate = Field(
+        default=MaintenanceTemplate.MODERN,
+        description="Maintenance page template"
+    )
+    
+    maintenance_title: str = Field(
+        default="Site Under Maintenance",
+        max_length=200,
+        description="Title for maintenance page"
+    )
+    
+    maintenance_message: str = Field(
+        default="We're performing scheduled maintenance. Please try again shortly.",
+        max_length=1000,
+        description="Message for maintenance page"
+    )
+    
+    # === Auto-configuration Flags ===
+    auto_ssl: bool = Field(
+        default=True, 
+        description="Automatically configure SSL/TLS settings"
+    )
+    auto_dns: bool = Field(
+        default=True, 
+        description="Create missing DNS records automatically"
+    )
+    auto_monitoring: bool = Field(
+        default=True, 
+        description="Enable external monitoring"
+    )
+    
+    # === Advanced Settings (Smart Defaults) ===
+    worker_name: str = Field(
+        default="maintenance-mode",
+        max_length=100,
+        pattern=r"^[a-zA-Z0-9\-_]+$",
+        description="Cloudflare Worker name"
+    )
+    
+    monitoring_interval: Annotated[int, Field(
+        ge=30, 
+        le=3600,
+        description="Health check interval in seconds"
+    )] = 60
+    
+    failure_threshold: Annotated[int, Field(
+        ge=1, 
+        le=10,
+        description="Consecutive failures before enabling maintenance"
+    )] = 3
+    
+    recovery_threshold: Annotated[int, Field(
+        ge=1, 
+        le=10,
+        description="Consecutive successes before disabling maintenance"
+    )] = 2
+    
+    # === Multi-site Support ===
+    multi_site_enabled: bool = Field(
+        default=False,
+        description="Enable multi-site management features"
+    )
+    
+    @field_validator('domain')
+    @classmethod
+    def validate_domain(cls, v: str) -> str:
+        """Validate and normalize domain name."""
+        domain = v.lower().strip()
+        
+        # Remove protocol if present
+        if domain.startswith(('http://', 'https://')):
+            raise ValueError('Domain should not include protocol (http:// or https://)')
+        
+        # Remove www prefix for consistency
+        if domain.startswith('www.'):
+            domain = domain[4:]
+        
+        # Basic domain validation
+        if not domain or '.' not in domain:
+            raise ValueError('Domain must be a valid domain name')
+        
+        return domain
+    
+    def get_api_token(self) -> str:
+        """Get decrypted API token."""
+        return self.api_token.get_secret_value()
+    
+    def is_configured(self) -> bool:
+        """Check if Cloudflare is fully configured."""
+        return bool(self.zone_id and self.account_id)
+
+
+class MultiSiteConfig(BaseModel):
+    """
+    Multi-site management configuration.
+    
+    Extends CloudflareConfig for managing multiple sites.
+    """
+    
+    model_config = {
+        "validate_assignment": True,
+        "extra": "forbid"
+    }
+    
+    # === Site Discovery ===
+    auto_discover_sites: bool = Field(
+        default=True,
+        description="Automatically discover all sites in Cloudflare account"
+    )
+    
+    site_filters: List[str] = Field(
+        default_factory=list,
+        description="Domain patterns to include (e.g., ['*.example.com', 'api.*.com'])"
+    )
+    
+    excluded_domains: List[str] = Field(
+        default_factory=list,
+        description="Domains to exclude from management"
+    )
+    
+    # === Default Site Settings ===
+    default_environment: str = Field(
+        default="production",
+        pattern=r"^(production|staging|development|testing)$",
+        description="Default environment for discovered sites"
+    )
+    
+    default_project: str = Field(
+        default="",
+        max_length=100,
+        description="Default project name for discovered sites"
+    )
+    
+    default_tags: List[str] = Field(
+        default_factory=list,
+        description="Default tags for discovered sites"
+    )
+    
+    # === Bulk Operations ===
+    max_concurrent_operations: Annotated[int, Field(
+        ge=1, 
+        le=50,
+        description="Maximum concurrent Cloudflare API operations"
+    )] = 10
+    
+    operation_timeout: Annotated[int, Field(
+        ge=5, 
+        le=300,
+        description="Timeout for individual operations in seconds"
+    )] = 30
+    
+    # === Notifications ===
+    notification_channels: List[str] = Field(
+        default_factory=lambda: ["email"],
+        description="Notification channels for maintenance events"
+    )
+    
+    webhook_url: Optional[HttpUrl] = Field(
+        default=None,
+        description="Webhook URL for maintenance notifications"
+    )
+
+
+class MonitoringConfig(BaseModel):
+    """
+    External monitoring configuration.
+    
+    Configures health checks and automatic maintenance triggers.
+    """
+    
+    model_config = {
+        "validate_assignment": True,
+        "extra": "forbid"
+    }
+    
+    # === Monitoring Settings ===
+    enabled: bool = Field(
+        default=True,
+        description="Enable external monitoring"
+    )
+    
+    check_interval: Annotated[int, Field(
+        ge=10, 
+        le=3600,
+        description="Health check interval in seconds"
+    )] = 60
+    
+    timeout: Annotated[int, Field(
+        ge=1, 
+        le=300,
+        description="Health check timeout in seconds"
+    )] = 10
+    
+    # === Health Check Configuration ===
+    health_check_path: str = Field(
+        default="/health/",
+        description="Health check endpoint path"
+    )
+    
+    expected_status_codes: List[int] = Field(
+        default_factory=lambda: [200, 201, 204],
+        description="Expected HTTP status codes for healthy response"
+    )
+    
+    expected_response_time_ms: Optional[int] = Field(
+        default=5000,
+        ge=100,
+        le=60000,
+        description="Maximum expected response time in milliseconds"
+    )
+    
+    # === Failure Detection ===
+    failure_threshold: Annotated[int, Field(
+        ge=1, 
+        le=20,
+        description="Consecutive failures before triggering maintenance"
+    )] = 3
+    
+    recovery_threshold: Annotated[int, Field(
+        ge=1, 
+        le=20,
+        description="Consecutive successes before disabling maintenance"
+    )] = 2
+    
+    # === Advanced Settings ===
+    user_agent: str = Field(
+        default="Django-CFG-Monitor/1.0",
+        description="User agent for health checks"
+    )
+    
+    follow_redirects: bool = Field(
+        default=True,
+        description="Follow HTTP redirects during health checks"
+    )
+    
+    verify_ssl: bool = Field(
+        default=True,
+        description="Verify SSL certificates during health checks"
+    )
+    
+    custom_headers: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Custom headers for health check requests"
+    )
+
+
+# Export all models
+__all__ = [
+    "CloudflareConfig",
+    "MultiSiteConfig", 
+    "MonitoringConfig",
+    "MaintenanceTemplate",
+]

django_cfg/models/revolution.py

@@ -92,7 +92,7 @@ class ExtendedRevolutionConfig(BaseDjangoRevolutionConfig):
             leads_enabled = base_module.is_leads_enabled()
             knowbase_enabled = base_module.is_knowbase_enabled()
             agents_enabled = base_module.is_agents_enabled()
-            tasks_enabled = base_module.is_tasks_enabled()
+            tasks_enabled = base_module.should_enable_tasks()
             
             # Add Support zone if enabled
             default_support_zone = 'cfg_support'

django_cfg/models/tasks.py

@@ -11,6 +11,7 @@ from typing import Optional, List, Literal, Dict, Any
 from enum import Enum
 import os
 import logging
+from django_cfg.models.cfg import BaseCfgAutoModule
 
 logger = logging.getLogger(__name__)
 
@@ -239,7 +240,7 @@ class WorkerConfig(BaseModel):
     )
 
 
-class TaskConfig(BaseModel):
+class TaskConfig(BaseModel, BaseCfgAutoModule):
     """
     High-level task system configuration.
     
@@ -257,6 +258,12 @@ class TaskConfig(BaseModel):
         description="Task processing backend"
     )
     
+    def __init__(self, **data):
+        """Initialize TaskConfig with BaseCfgAutoModule support."""
+        super().__init__(**data)
+        # Initialize _config attribute for BaseCfgAutoModule
+        self._config = None
+    
     # === Backend-Specific Configuration ===
     dramatiq: DramatiqConfig = Field(
         default_factory=DramatiqConfig, 
@@ -371,6 +378,53 @@ class TaskConfig(BaseModel):
             "DRAMATIQ_QUEUES": self.dramatiq.queues,
         }
 
+    def get_smart_defaults(self):
+        """Get smart default configuration for this module."""
+        config = self.get_config()
+        debug = getattr(config, 'debug', False) if config else False
+        return get_default_task_config(debug=debug)
+
+    def get_module_config(self):
+        """Get the final configuration for this module."""
+        return self
+    
+    @classmethod
+    def auto_initialize_if_needed(cls) -> Optional['TaskConfig']:
+        """
+        Auto-initialize TaskConfig if needed based on config flags.
+        
+        Returns:
+            TaskConfig instance if should be initialized, None otherwise
+        """
+        # Get config through BaseCfgModule
+        from django_cfg.modules import BaseCfgModule
+        base_module = BaseCfgModule()
+        config = base_module.get_config()
+        
+        if not config:
+            return None
+        
+        # Check if TaskConfig already exists
+        if hasattr(config, 'tasks') and config.tasks is not None:
+            # Set config reference and return existing
+            config.tasks.set_config(config)
+            return config.tasks
+        
+        # Check if tasks should be enabled
+        if config.should_enable_tasks():
+            # Auto-initialize with smart defaults
+            task_config = cls().get_smart_defaults()
+            task_config.set_config(config)
+            config.tasks = task_config
+            
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.info("🚀 Auto-initialized TaskConfig (enabled by knowbase/agents/tasks flags)")
+            
+            return task_config
+        
+        return None
+
 
 # === Utility Functions ===
 

django_cfg/modules/base.py

@@ -155,7 +155,7 @@ class BaseCfgModule(ABC):
         """
         return self._get_config_key('enable_knowbase', False)
     
-    def is_tasks_enabled(self) -> bool:
+    def should_enable_tasks(self) -> bool:
         """
         Check if django-cfg Tasks is enabled.
         Auto-enables if knowbase or agents are enabled.
@@ -163,10 +163,17 @@ class BaseCfgModule(ABC):
         Returns:
             True if Tasks is enabled, False otherwise
         """
-        # Auto-enable if knowbase or agents are enabled
-        if self.is_knowbase_enabled() or self.is_agents_enabled():
-            return True
-        return self._get_config_key('enable_tasks', False)
+
+        return self.get_config().should_enable_tasks()
+    
+    def is_maintenance_enabled(self) -> bool:
+        """
+        Check if django-cfg Maintenance is enabled.
+        
+        Returns:
+            True if Maintenance is enabled, False otherwise
+        """
+        return self._get_config_key('enable_maintenance', False)
 
 
 # Export the base class

django_cfg/modules/django_tasks.py

@@ -9,16 +9,14 @@ from typing import Optional, Dict, Any, List
 import logging
 from urllib.parse import urlparse
 
-from django_cfg.modules.base import BaseCfgModule
+from . import BaseCfgModule
 from django_cfg.models.tasks import TaskConfig, validate_task_config
 from django_cfg.models.constance import ConstanceField
 
 # Django imports (will be available when Django is configured)
 try:
-    from django.conf import settings
     from django.apps import apps
 except ImportError:
-    settings = None
     apps = None
 
 # Optional imports
@@ -426,6 +424,46 @@ def extend_constance_config_with_tasks():
 
 # === Exports ===
 
+def generate_dramatiq_settings_from_config() -> Optional[Dict[str, Any]]:
+    """
+    Generate Dramatiq settings from auto-discovered DjangoConfig.
+    
+    Returns:
+        Dictionary of Dramatiq settings or None if tasks disabled
+    """
+    try:
+        # Get config through BaseCfgModule
+        base_module = BaseCfgModule()
+        config = base_module.get_config()
+        
+        if not config or not hasattr(config, 'tasks') or not config.tasks or not config.tasks.enabled:
+            return None
+        
+        # Get Redis URL from cache config or environment
+        redis_url = None
+        if hasattr(config, 'cache_default') and config.cache_default:
+            redis_url = getattr(config.cache_default, 'redis_url', None)
+        
+        if not redis_url:
+            # Fallback to environment or default
+            import os
+            redis_url = os.getenv('REDIS_URL', 'redis://localhost:6379/1')
+        
+        # Generate Dramatiq settings
+        dramatiq_settings = config.tasks.get_dramatiq_settings(redis_url)
+        
+        # Ensure we only use Redis broker (no RabbitMQ)
+        if 'DRAMATIQ_BROKER' in dramatiq_settings:
+            dramatiq_settings['DRAMATIQ_BROKER']['BROKER'] = 'dramatiq.brokers.redis.RedisBroker'
+        
+        logger.info(f"✅ Generated Dramatiq settings with Redis broker and {len(config.tasks.dramatiq.queues)} queues")
+        return dramatiq_settings
+        
+    except Exception as e:
+        logger.error(f"Failed to generate Dramatiq settings: {e}")
+        return None
+
+
 __all__ = [
     "DjangoTasks",
     "get_task_service",

django_cfg/modules/django_unfold/dashboard.py

@@ -138,7 +138,7 @@ class DashboardManager(BaseCfgModule):
             ))
         
         # Add Tasks section if knowbase or agents are enabled
-        if self.is_tasks_enabled():
+        if self.should_enable_tasks():
             navigation_sections.append(NavigationSection(
                 title="Background Tasks",
                 separator=True,
@@ -149,6 +149,21 @@ class DashboardManager(BaseCfgModule):
                 ]
             ))
         
+        # Add Maintenance section if enabled
+        if self.is_maintenance_enabled():
+            navigation_sections.append(NavigationSection(
+                title="Maintenance Mode",
+                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/"),
+                ]
+            ))
+        
         # Convert all NavigationSection objects to dictionaries
         return [section.to_dict() for section in navigation_sections]
     

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.2.14
+Version: 1.2.16
 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
@@ -33,6 +33,7 @@ Requires-Python: <4.0,>=3.12
 Requires-Dist: beautifulsoup4<5.0,>=4.13.0
 Requires-Dist: cachetools<7.0,>=5.3.0
 Requires-Dist: click<9.0,>=8.2.0
+Requires-Dist: cloudflare<5.0,>=4.3.0
 Requires-Dist: colorlog<7.0,>=6.9.0
 Requires-Dist: coolname<3.0,>=2.2.0
 Requires-Dist: currencyconverter<1.0,>=0.18.0