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

django_cfg/apps/maintenance/models/__init__.py

@@ -0,0 +1,27 @@
+"""
+Maintenance app models.
+
+Following django-cfg patterns with proper imports and exports.
+"""
+
+from .maintenance import MaintenanceEvent, MaintenanceLog
+from .sites import CloudflareSite, SiteGroup
+from .monitoring import MonitoringTarget, HealthCheckResult
+from .cloudflare import CloudflareDeployment
+
+__all__ = [
+    # Maintenance models
+    'MaintenanceEvent',
+    'MaintenanceLog',
+    
+    # Site management models
+    'CloudflareSite',
+    'SiteGroup',
+    
+    # Monitoring models
+    'MonitoringTarget',
+    'HealthCheckResult',
+    
+    # Cloudflare integration models
+    'CloudflareDeployment',
+]

django_cfg/apps/maintenance/models/cloudflare.py

@@ -0,0 +1,316 @@
+"""
+Cloudflare integration models.
+
+Models for tracking Cloudflare deployments and configurations.
+Following CRITICAL_REQUIREMENTS - proper typing, no raw Dict usage.
+"""
+
+from django.db import models
+from django.utils import timezone
+from django.core.exceptions import ValidationError
+from typing import Optional, Dict, Any
+from datetime import timedelta
+import json
+
+
+class CloudflareDeployment(models.Model):
+    """
+    Cloudflare Worker deployment tracking.
+    
+    Tracks deployment of maintenance mode Workers to Cloudflare
+    with full audit trail and rollback capabilities.
+    """
+    
+    class Status(models.TextChoices):
+        """Deployment status choices."""
+        PENDING = "pending", "Pending"
+        DEPLOYING = "deploying", "Deploying"
+        DEPLOYED = "deployed", "Deployed"
+        FAILED = "failed", "Failed"
+        ROLLED_BACK = "rolled_back", "Rolled Back"
+    
+    class DeploymentType(models.TextChoices):
+        """Type of deployment."""
+        WORKER = "worker", "Cloudflare Worker"
+        PAGE_RULE = "page_rule", "Page Rule"
+        DNS_RECORD = "dns_record", "DNS Record"
+        SSL_SETTING = "ssl_setting", "SSL Setting"
+        CUSTOM_ERROR_PAGE = "custom_error_page", "Custom Error Page"
+    
+    # === Basic Information ===
+    site = models.ForeignKey(
+        'django_cfg_maintenance.CloudflareSite',
+        on_delete=models.CASCADE,
+        related_name='deployments',
+        help_text="Site this deployment belongs to"
+    )
+    deployment_type = models.CharField(
+        max_length=50,
+        choices=DeploymentType.choices,
+        default=DeploymentType.WORKER,
+        help_text="Type of Cloudflare resource being deployed"
+    )
+    
+    # === Deployment Details ===
+    resource_name = models.CharField(
+        max_length=200,
+        help_text="Name of the deployed resource (Worker name, Page Rule, etc.)"
+    )
+    resource_id = models.CharField(
+        max_length=100,
+        blank=True,
+        help_text="Cloudflare resource ID after deployment"
+    )
+    
+    # === Status Tracking ===
+    status = models.CharField(
+        max_length=20,
+        choices=Status.choices,
+        default=Status.PENDING,
+        help_text="Current deployment status"
+    )
+    
+    # === Timing ===
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        help_text="When deployment was initiated"
+    )
+    deployed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="When deployment completed successfully"
+    )
+    failed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="When deployment failed"
+    )
+    
+    # === Configuration ===
+    configuration = models.JSONField(
+        default=dict,
+        help_text="Deployment configuration (Worker script, Page Rule settings, etc.)"
+    )
+    
+    # === Results ===
+    cloudflare_response = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Full response from Cloudflare API"
+    )
+    error_message = models.TextField(
+        blank=True,
+        help_text="Error message if deployment failed"
+    )
+    
+    # === Rollback Support ===
+    previous_deployment = models.ForeignKey(
+        'self',
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='rollback_deployments',
+        help_text="Previous deployment for rollback"
+    )
+    rollback_data = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Data needed for rollback (previous configuration, etc.)"
+    )
+    
+    # === Maintenance Event Link ===
+    maintenance_event = models.ForeignKey(
+        'django_cfg_maintenance.MaintenanceEvent',
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='cloudflare_deployments',
+        help_text="Related maintenance event"
+    )
+    
+    # === Custom Manager ===
+    from ..managers.deployments import CloudflareDeploymentManager
+    objects = CloudflareDeploymentManager()
+    
+    class Meta:
+        ordering = ['-created_at']
+        verbose_name = "Cloudflare Deployment"
+        verbose_name_plural = "Cloudflare Deployments"
+        indexes = [
+            models.Index(fields=['site', '-created_at']),
+            models.Index(fields=['status', '-created_at']),
+            models.Index(fields=['deployment_type', '-created_at']),
+            models.Index(fields=['resource_id']),
+        ]
+    
+    def __str__(self) -> str:
+        return f"{self.get_deployment_type_display()}: {self.resource_name} ({self.get_status_display()})"
+    
+    @property
+    def is_active(self) -> bool:
+        """Check if deployment is currently active."""
+        return self.status == self.Status.DEPLOYED
+    
+    @property
+    def is_pending(self) -> bool:
+        """Check if deployment is pending."""
+        return self.status in [self.Status.PENDING, self.Status.DEPLOYING]
+    
+    @property
+    def deployment_duration(self) -> Optional[timedelta]:
+        """Calculate deployment duration."""
+        if self.deployed_at:
+            return self.deployed_at - self.created_at
+        elif self.failed_at:
+            return self.failed_at - self.created_at
+        elif self.status == self.Status.DEPLOYING:
+            return timezone.now() - self.created_at
+        return None
+    
+    @property
+    def can_rollback(self) -> bool:
+        """Check if deployment can be rolled back."""
+        return (
+            self.status == self.Status.DEPLOYED and
+            (self.previous_deployment is not None or self.rollback_data)
+        )
+    
+    def mark_deploying(self) -> None:
+        """Mark deployment as in progress."""
+        self.status = self.Status.DEPLOYING
+        self.save(update_fields=['status'])
+    
+    def mark_deployed(self, resource_id: str, cloudflare_response: Dict[str, Any]) -> None:
+        """Mark deployment as successful."""
+        self.status = self.Status.DEPLOYED
+        self.resource_id = resource_id
+        self.deployed_at = timezone.now()
+        self.cloudflare_response = cloudflare_response
+        self.save(update_fields=[
+            'status', 
+            'resource_id', 
+            'deployed_at', 
+            'cloudflare_response'
+        ])
+    
+    def mark_failed(self, error_message: str, cloudflare_response: Optional[Dict[str, Any]] = None) -> None:
+        """Mark deployment as failed."""
+        self.status = self.Status.FAILED
+        self.failed_at = timezone.now()
+        self.error_message = error_message
+        if cloudflare_response:
+            self.cloudflare_response = cloudflare_response
+        
+        self.save(update_fields=[
+            'status', 
+            'failed_at', 
+            'error_message', 
+            'cloudflare_response'
+        ])
+    
+    def rollback(self) -> bool:
+        """Attempt to rollback this deployment."""
+        if not self.can_rollback:
+            return False
+        
+        try:
+            # Create rollback deployment record
+            rollback_deployment = CloudflareDeployment.objects.create(
+                site=self.site,
+                deployment_type=self.deployment_type,
+                resource_name=f"rollback-{self.resource_name}",
+                configuration=self.rollback_data,
+                previous_deployment=self,
+                maintenance_event=self.maintenance_event
+            )
+            
+            # Mark this deployment as rolled back
+            self.status = self.Status.ROLLED_BACK
+            self.save(update_fields=['status'])
+            
+            return True
+            
+        except Exception:
+            return False
+    
+    def get_configuration_summary(self) -> str:
+        """Get human-readable configuration summary."""
+        if not self.configuration:
+            return "No configuration"
+        
+        if self.deployment_type == self.DeploymentType.WORKER:
+            return f"Worker script ({len(str(self.configuration.get('script', '')))} chars)"
+        elif self.deployment_type == self.DeploymentType.PAGE_RULE:
+            actions = self.configuration.get('actions', [])
+            return f"Page Rule with {len(actions)} actions"
+        elif self.deployment_type == self.DeploymentType.DNS_RECORD:
+            record_type = self.configuration.get('type', 'Unknown')
+            content = self.configuration.get('content', 'Unknown')
+            return f"{record_type} record: {content}"
+        else:
+            return f"{len(self.configuration)} configuration items"
+    
+    def get_error_summary(self) -> str:
+        """Get concise error summary."""
+        if not self.error_message:
+            return "No error"
+        
+        # Extract first line of error message
+        first_line = self.error_message.split('\n')[0]
+        return first_line[:200] if len(first_line) > 200 else first_line
+    
+    def clean(self) -> None:
+        """Validate model data."""
+        super().clean()
+        
+        # Validate resource name
+        if not self.resource_name.strip():
+            raise ValidationError({'resource_name': 'Resource name cannot be empty'})
+        
+        # Validate timing
+        if self.deployed_at and self.failed_at:
+            raise ValidationError("Deployment cannot be both successful and failed")
+        
+        if self.deployed_at and self.deployed_at < self.created_at:
+            raise ValidationError({'deployed_at': 'Deployed time cannot be before created time'})
+        
+        if self.failed_at and self.failed_at < self.created_at:
+            raise ValidationError({'failed_at': 'Failed time cannot be before created time'})
+    
+    @classmethod
+    def create_worker_deployment(cls, 
+                                site: 'CloudflareSite', 
+                                worker_name: str, 
+                                script_content: str,
+                                maintenance_event: Optional['MaintenanceEvent'] = None) -> 'CloudflareDeployment':
+        """Create Worker deployment record."""
+        return cls.objects.create(
+            site=site,
+            deployment_type=cls.DeploymentType.WORKER,
+            resource_name=worker_name,
+            configuration={
+                'script': script_content,
+                'name': worker_name
+            },
+            maintenance_event=maintenance_event
+        )
+    
+    @classmethod
+    def create_page_rule_deployment(cls,
+                                   site: 'CloudflareSite',
+                                   rule_name: str,
+                                   pattern: str,
+                                   actions: Dict[str, Any],
+                                   maintenance_event: Optional['MaintenanceEvent'] = None) -> 'CloudflareDeployment':
+        """Create Page Rule deployment record."""
+        return cls.objects.create(
+            site=site,
+            deployment_type=cls.DeploymentType.PAGE_RULE,
+            resource_name=rule_name,
+            configuration={
+                'targets': [{'target': 'url', 'constraint': {'operator': 'matches', 'value': pattern}}],
+                'actions': actions,
+                'status': 'active'
+            },
+            maintenance_event=maintenance_event
+        )

django_cfg/apps/maintenance/models/maintenance.py

@@ -0,0 +1,334 @@
+"""
+Maintenance event models.
+
+Core models for tracking maintenance events and logs.
+Following CRITICAL_REQUIREMENTS - no raw Dict usage, proper typing.
+"""
+
+from django.db import models
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+from django.core.exceptions import ValidationError
+from typing import Optional
+from datetime import timedelta
+
+User = get_user_model()
+
+
+class MaintenanceEvent(models.Model):
+    """
+    Main maintenance event tracking model.
+    
+    Tracks maintenance events with full audit trail and Cloudflare integration.
+    """
+    
+    class Status(models.TextChoices):
+        """Maintenance event status choices."""
+        SCHEDULED = "scheduled", "Scheduled"
+        ACTIVE = "active", "Active"
+        COMPLETED = "completed", "Completed"
+        FAILED = "failed", "Failed"
+        CANCELLED = "cancelled", "Cancelled"
+    
+    class Reason(models.TextChoices):
+        """Maintenance reason choices."""
+        MANUAL = "manual", "Manual Activation"
+        SERVER_DOWN = "server_down", "Server Unreachable"
+        HIGH_ERROR_RATE = "high_error_rate", "High Error Rate"
+        DATABASE_ISSUES = "database_issues", "Database Issues"
+        DEPLOYMENT = "deployment", "Deployment"
+        SECURITY_UPDATE = "security_update", "Security Update"
+        SCHEDULED = "scheduled", "Scheduled Maintenance"
+        EMERGENCY = "emergency", "Emergency Maintenance"
+    
+    # === Basic Information ===
+    title = models.CharField(
+        max_length=200,
+        help_text="Human-readable maintenance event title"
+    )
+    description = models.TextField(
+        blank=True,
+        help_text="Detailed description of maintenance work"
+    )
+    reason = models.CharField(
+        max_length=50,
+        choices=Reason.choices,
+        default=Reason.MANUAL,
+        help_text="Reason for maintenance activation"
+    )
+    status = models.CharField(
+        max_length=20,
+        choices=Status.choices,
+        default=Status.ACTIVE,
+        help_text="Current maintenance status"
+    )
+    
+    # === Timing ===
+    started_at = models.DateTimeField(
+        default=timezone.now,
+        help_text="When maintenance was started"
+    )
+    ended_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="When maintenance was completed"
+    )
+    estimated_duration = models.DurationField(
+        null=True,
+        blank=True,
+        help_text="Estimated maintenance duration"
+    )
+    
+    # === User Tracking ===
+    initiated_by = models.ForeignKey(
+        User,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='initiated_maintenance_events',
+        help_text="User who initiated maintenance"
+    )
+    completed_by = models.ForeignKey(
+        User,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='completed_maintenance_events',
+        help_text="User who completed maintenance"
+    )
+    
+    # === Cloudflare Integration ===
+    cloudflare_worker_deployed = models.BooleanField(
+        default=False,
+        help_text="Whether Cloudflare Worker was deployed"
+    )
+    cloudflare_deployment_id = models.CharField(
+        max_length=100,
+        blank=True,
+        help_text="Cloudflare deployment identifier"
+    )
+    worker_deployment_success = models.BooleanField(
+        default=False,
+        help_text="Whether Worker deployment was successful"
+    )
+    
+    # === Metrics ===
+    affected_requests = models.PositiveIntegerField(
+        default=0,
+        help_text="Number of requests affected during maintenance"
+    )
+    error_count_before = models.PositiveIntegerField(
+        default=0,
+        help_text="Error count before maintenance"
+    )
+    error_count_during = models.PositiveIntegerField(
+        default=0,
+        help_text="Error count during maintenance"
+    )
+    
+    # === Sites (Many-to-Many relationship) ===
+    sites = models.ManyToManyField(
+        'django_cfg_maintenance.CloudflareSite',
+        blank=True,
+        related_name='maintenance_events',
+        help_text="Sites affected by this maintenance event"
+    )
+    
+    # === Metadata ===
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    
+    # === Custom Manager ===
+    from ..managers.events import MaintenanceEventManager
+    objects = MaintenanceEventManager()
+    
+    class Meta:
+        ordering = ['-started_at']
+        verbose_name = "Maintenance Event"
+        verbose_name_plural = "Maintenance Events"
+        indexes = [
+            models.Index(fields=['status', '-started_at']),
+            models.Index(fields=['reason', '-started_at']),
+            models.Index(fields=['initiated_by', '-started_at']),
+        ]
+    
+    def __str__(self) -> str:
+        return f"{self.title} ({self.get_status_display()})"
+    
+    @property
+    def duration(self) -> Optional[timedelta]:
+        """Calculate actual maintenance duration."""
+        if self.ended_at:
+            return self.ended_at - self.started_at
+        elif self.status == self.Status.ACTIVE:
+            return timezone.now() - self.started_at
+        return None
+    
+    @property
+    def is_active(self) -> bool:
+        """Check if maintenance is currently active."""
+        return self.status == self.Status.ACTIVE
+    
+    @property
+    def is_scheduled(self) -> bool:
+        """Check if maintenance is scheduled for future."""
+        return self.status == self.Status.SCHEDULED
+    
+    @property
+    def affected_sites_count(self) -> int:
+        """Count of affected sites."""
+        return self.sites.count()
+    
+    def complete(self, user: Optional[User] = None) -> None:
+        """Mark maintenance as completed."""
+        self.status = self.Status.COMPLETED
+        self.ended_at = timezone.now()
+        self.completed_by = user
+        self.save(update_fields=['status', 'ended_at', 'completed_by', 'updated_at'])
+    
+    def cancel(self, user: Optional[User] = None) -> None:
+        """Cancel maintenance event."""
+        self.status = self.Status.CANCELLED
+        self.ended_at = timezone.now()
+        self.completed_by = user
+        self.save(update_fields=['status', 'ended_at', 'completed_by', 'updated_at'])
+    
+    def fail(self, error_message: str = "") -> None:
+        """Mark maintenance as failed."""
+        self.status = self.Status.FAILED
+        self.ended_at = timezone.now()
+        self.save(update_fields=['status', 'ended_at', 'updated_at'])
+        
+        # Create failure log
+        MaintenanceLog.objects.create(
+            event=self,
+            level=MaintenanceLog.Level.ERROR,
+            message=f"Maintenance failed: {error_message}",
+            details={'error': error_message}
+        )
+    
+    def clean(self) -> None:
+        """Validate model data."""
+        super().clean()
+        
+        # Validate timing
+        if self.ended_at and self.ended_at < self.started_at:
+            raise ValidationError("End time cannot be before start time")
+        
+        # Validate estimated duration
+        if self.estimated_duration and self.estimated_duration.total_seconds() <= 0:
+            raise ValidationError("Estimated duration must be positive")
+
+
+class MaintenanceLog(models.Model):
+    """
+    Detailed logging for maintenance events.
+    
+    Provides audit trail and debugging information for maintenance operations.
+    """
+    
+    class Level(models.TextChoices):
+        """Log level choices."""
+        DEBUG = "debug", "Debug"
+        INFO = "info", "Info"
+        WARNING = "warning", "Warning"
+        ERROR = "error", "Error"
+        CRITICAL = "critical", "Critical"
+    
+    # === Relationships ===
+    event = models.ForeignKey(
+        MaintenanceEvent,
+        on_delete=models.CASCADE,
+        related_name='logs',
+        help_text="Related maintenance event"
+    )
+    
+    # === Log Data ===
+    level = models.CharField(
+        max_length=20,
+        choices=Level.choices,
+        default=Level.INFO,
+        help_text="Log level"
+    )
+    message = models.TextField(
+        help_text="Log message"
+    )
+    details = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Additional log details (JSON)"
+    )
+    
+    # === Context ===
+    component = models.CharField(
+        max_length=100,
+        blank=True,
+        help_text="Component that generated the log (e.g., 'cloudflare', 'monitoring')"
+    )
+    operation = models.CharField(
+        max_length=100,
+        blank=True,
+        help_text="Operation being performed (e.g., 'deploy_worker', 'health_check')"
+    )
+    
+    # === User Context ===
+    user = models.ForeignKey(
+        User,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        help_text="User associated with this log entry"
+    )
+    
+    # === Metadata ===
+    timestamp = models.DateTimeField(
+        default=timezone.now,
+        help_text="When the log entry was created"
+    )
+    
+    # === Custom Manager ===
+    from ..managers.events import MaintenanceLogManager
+    objects = MaintenanceLogManager()
+    
+    class Meta:
+        ordering = ['-timestamp']
+        verbose_name = "Maintenance Log"
+        verbose_name_plural = "Maintenance Logs"
+        indexes = [
+            models.Index(fields=['event', '-timestamp']),
+            models.Index(fields=['level', '-timestamp']),
+            models.Index(fields=['component', '-timestamp']),
+        ]
+    
+    def __str__(self) -> str:
+        return f"{self.get_level_display()}: {self.message[:100]}"
+    
+    @classmethod
+    def log_info(cls, event: MaintenanceEvent, message: str, **kwargs) -> 'MaintenanceLog':
+        """Create info log entry."""
+        return cls.objects.create(
+            event=event,
+            level=cls.Level.INFO,
+            message=message,
+            **kwargs
+        )
+    
+    @classmethod
+    def log_error(cls, event: MaintenanceEvent, message: str, **kwargs) -> 'MaintenanceLog':
+        """Create error log entry."""
+        return cls.objects.create(
+            event=event,
+            level=cls.Level.ERROR,
+            message=message,
+            **kwargs
+        )
+    
+    @classmethod
+    def log_warning(cls, event: MaintenanceEvent, message: str, **kwargs) -> 'MaintenanceLog':
+        """Create warning log entry."""
+        return cls.objects.create(
+            event=event,
+            level=cls.Level.WARNING,
+            message=message,
+            **kwargs
+        )