django-cfg 1.2.17__py3-none-any.whl → 1.2.19__py3-none-any.whl

django_cfg/apps/maintenance/management/commands/process_scheduled_maintenance.py

@@ -0,0 +1,241 @@
+"""
+Management command for processing scheduled maintenance events.
+
+Handles automatic start/stop of scheduled maintenance windows.
+"""
+
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+from datetime import timedelta
+
+from ...services.scheduled_maintenance_service import scheduled_maintenance_service
+from ...models import ScheduledMaintenance
+
+
+class Command(BaseCommand):
+    """Process scheduled maintenance events."""
+    
+    help = 'Process scheduled maintenance events (start due, complete overdue)'
+    
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be processed without making changes'
+        )
+        
+        parser.add_argument(
+            '--upcoming',
+            type=int,
+            default=24,
+            help='Show upcoming maintenances within N hours (default: 24)'
+        )
+        
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Enable verbose output'
+        )
+    
+    def handle(self, *args, **options):
+        """Handle the command execution."""
+        verbosity = 2 if options['verbose'] else 1
+        
+        if options['dry_run']:
+            self.stdout.write(
+                self.style.WARNING('🔍 DRY RUN MODE - No changes will be made')
+            )
+        
+        # Show current status
+        self._show_current_status(verbosity)
+        
+        if not options['dry_run']:
+            # Process due maintenances
+            self._process_due_maintenances(verbosity)
+            
+            # Process overdue maintenances
+            self._process_overdue_maintenances(verbosity)
+        else:
+            # Show what would be processed
+            self._show_dry_run_info()
+        
+        # Show upcoming maintenances
+        self._show_upcoming_maintenances(options['upcoming'], verbosity)
+    
+    def _show_current_status(self, verbosity: int):
+        """Show current maintenance status."""
+        self.stdout.write("\n" + "="*60)
+        self.stdout.write(self.style.SUCCESS("📊 SCHEDULED MAINTENANCE STATUS"))
+        self.stdout.write("="*60)
+        
+        # Active maintenances
+        active = scheduled_maintenance_service.get_active_maintenances()
+        if active:
+            self.stdout.write(f"\n🔧 Active Maintenances ({len(active)}):")
+            for maintenance in active:
+                time_left = ""
+                if maintenance['time_until_end']:
+                    hours = int(maintenance['time_until_end'] // 3600)
+                    minutes = int((maintenance['time_until_end'] % 3600) // 60)
+                    time_left = f" ({hours}h {minutes}m remaining)"
+                
+                overdue = " ⚠️ OVERDUE" if maintenance['is_overdue'] else ""
+                
+                self.stdout.write(
+                    f"   • {maintenance['title']}{time_left}{overdue}"
+                )
+                if verbosity >= 2:
+                    self.stdout.write(f"     Sites: {maintenance['sites_count']}, Priority: {maintenance['priority']}")
+        else:
+            self.stdout.write("\n✅ No active maintenances")
+        
+        # Due maintenances
+        due = ScheduledMaintenance.get_due_maintenances()
+        if due:
+            self.stdout.write(f"\n⏰ Due to Start ({due.count()}):")
+            for maintenance in due:
+                auto_text = " (auto)" if maintenance.auto_enable else " (manual)"
+                self.stdout.write(f"   • {maintenance.title}{auto_text}")
+                if verbosity >= 2:
+                    self.stdout.write(f"     Sites: {maintenance.affected_sites_count}, Scheduled: {maintenance.scheduled_start}")
+        
+        # Overdue maintenances
+        overdue = ScheduledMaintenance.get_overdue_maintenances()
+        if overdue:
+            self.stdout.write(f"\n⚠️  Overdue to Complete ({overdue.count()}):")
+            for maintenance in overdue:
+                auto_text = " (auto)" if maintenance.auto_disable else " (manual)"
+                self.stdout.write(f"   • {maintenance.title}{auto_text}")
+                if verbosity >= 2:
+                    overdue_time = timezone.now() - maintenance.scheduled_end
+                    hours = int(overdue_time.total_seconds() // 3600)
+                    minutes = int((overdue_time.total_seconds() % 3600) // 60)
+                    self.stdout.write(f"     Overdue by: {hours}h {minutes}m")
+    
+    def _process_due_maintenances(self, verbosity: int):
+        """Process maintenances that are due to start."""
+        self.stdout.write("\n" + "-"*40)
+        self.stdout.write("🚀 Processing Due Maintenances")
+        self.stdout.write("-"*40)
+        
+        results = scheduled_maintenance_service.process_due_maintenances()
+        
+        if results['processed'] == 0:
+            self.stdout.write("✅ No due maintenances to process")
+            return
+        
+        self.stdout.write(f"📊 Processed: {results['processed']}")
+        self.stdout.write(f"✅ Successful: {results['successful']}")
+        
+        if results['failed'] > 0:
+            self.stdout.write(f"❌ Failed: {results['failed']}")
+        
+        # Show details
+        if verbosity >= 2 and results['details']:
+            self.stdout.write("\n📋 Details:")
+            for detail in results['details']:
+                status = "✅" if detail['success'] else "❌"
+                self.stdout.write(f"   {status} {detail['title']}")
+                if detail.get('sites_affected'):
+                    self.stdout.write(f"      Sites affected: {detail['sites_affected']}")
+                if detail.get('error'):
+                    self.stdout.write(f"      Error: {detail['error']}")
+    
+    def _process_overdue_maintenances(self, verbosity: int):
+        """Process maintenances that are overdue to complete."""
+        self.stdout.write("\n" + "-"*40)
+        self.stdout.write("🏁 Processing Overdue Maintenances")
+        self.stdout.write("-"*40)
+        
+        results = scheduled_maintenance_service.process_overdue_maintenances()
+        
+        if results['processed'] == 0:
+            self.stdout.write("✅ No overdue maintenances to process")
+            return
+        
+        self.stdout.write(f"📊 Processed: {results['processed']}")
+        self.stdout.write(f"✅ Successful: {results['successful']}")
+        
+        if results['failed'] > 0:
+            self.stdout.write(f"❌ Failed: {results['failed']}")
+        
+        # Show details
+        if verbosity >= 2 and results['details']:
+            self.stdout.write("\n📋 Details:")
+            for detail in results['details']:
+                status = "✅" if detail['success'] else "❌"
+                self.stdout.write(f"   {status} {detail['title']}")
+                if detail.get('sites_affected'):
+                    self.stdout.write(f"      Sites affected: {detail['sites_affected']}")
+                if detail.get('actual_duration'):
+                    duration_hours = detail['actual_duration'] / 3600
+                    self.stdout.write(f"      Duration: {duration_hours:.1f}h")
+                if detail.get('error'):
+                    self.stdout.write(f"      Error: {detail['error']}")
+    
+    def _show_dry_run_info(self):
+        """Show what would be processed in dry run mode."""
+        self.stdout.write("\n" + "-"*40)
+        self.stdout.write("🔍 Dry Run - What Would Be Processed")
+        self.stdout.write("-"*40)
+        
+        # Due maintenances
+        due = ScheduledMaintenance.get_due_maintenances().filter(auto_enable=True)
+        if due:
+            self.stdout.write(f"\n🚀 Would start {due.count()} maintenances:")
+            for maintenance in due:
+                self.stdout.write(f"   • {maintenance.title} ({maintenance.affected_sites_count} sites)")
+        
+        # Overdue maintenances
+        overdue = ScheduledMaintenance.get_overdue_maintenances().filter(auto_disable=True)
+        if overdue:
+            self.stdout.write(f"\n🏁 Would complete {overdue.count()} maintenances:")
+            for maintenance in overdue:
+                self.stdout.write(f"   • {maintenance.title} ({maintenance.affected_sites_count} sites)")
+        
+        if not due and not overdue:
+            self.stdout.write("✅ Nothing to process")
+    
+    def _show_upcoming_maintenances(self, hours: int, verbosity: int):
+        """Show upcoming maintenance events."""
+        upcoming = scheduled_maintenance_service.get_upcoming_maintenances(hours=hours)
+        
+        if not upcoming:
+            self.stdout.write(f"\n📅 No maintenances scheduled in next {hours} hours")
+            return
+        
+        self.stdout.write(f"\n📅 Upcoming Maintenances (next {hours}h):")
+        
+        for maintenance in upcoming:
+            # Calculate time until start
+            time_until = maintenance['time_until_start']
+            if time_until:
+                hours_until = int(time_until // 3600)
+                minutes_until = int((time_until % 3600) // 60)
+                time_str = f"in {hours_until}h {minutes_until}m"
+            else:
+                time_str = "now"
+            
+            priority_emoji = {
+                'low': '🟢',
+                'normal': '🟡',
+                'high': '🟠',
+                'critical': '🔴'
+            }.get(maintenance['priority'], '⚪')
+            
+            auto_text = " (auto)" if maintenance['auto_enable'] else " (manual)"
+            
+            self.stdout.write(
+                f"   {priority_emoji} {maintenance['title']} - {time_str}{auto_text}"
+            )
+            
+            if verbosity >= 2:
+                start_time = maintenance['scheduled_start'][:16].replace('T', ' ')
+                duration_hours = maintenance['estimated_duration'] / 3600
+                self.stdout.write(
+                    f"      Start: {start_time}, Duration: {duration_hours:.1f}h, Sites: {maintenance['sites_count']}"
+                )
+        
+        self.stdout.write(f"\n💡 Run with --dry-run to see what would be processed")
+        self.stdout.write(f"⏰ Current time: {timezone.now().strftime('%Y-%m-%d %H:%M:%S %Z')}")

django_cfg/apps/maintenance/management/commands/sync_cloudflare.py

@@ -1,168 +1,209 @@
 """
-Django management command for synchronizing sites with Cloudflare.
+Management command for syncing sites with Cloudflare zones.
 
-Fetches zones from Cloudflare API and creates/updates CloudflareSite records.
+Automatically discovers and syncs Cloudflare zones with Django models.
 """
 
 from django.core.management.base import BaseCommand, CommandError
-from django.contrib.auth import get_user_model
-from django.db import transaction
 from django.utils import timezone
-from typing import Dict, List, Any, Optional
-import logging
+from typing import Optional
 
-from ...models import CloudflareSite
-from ...services import SyncCommandService
-
-User = get_user_model()
-logger = logging.getLogger(__name__)
+from ...models import CloudflareApiKey
+from ...services.site_sync_service import SiteSyncService
 
 
 class Command(BaseCommand):
-    """Synchronize sites with Cloudflare zones."""
+    """Sync sites with Cloudflare zones."""
     
-    help = 'Synchronize CloudflareSite records with Cloudflare zones'
+    help = 'Sync CloudflareSite models with actual Cloudflare zones'
     
     def add_arguments(self, parser):
         """Add command arguments."""
         parser.add_argument(
-            '--user',
+            '--api-key',
             type=str,
-            help='Username or email of the site owner (required)',
-            required=True
-        )
-        
-        parser.add_argument(
-            '--api-token',
-            type=str,
-            help='Cloudflare API token (if not provided, will try to get from user config)',
+            help='Name of specific API key to sync (default: all active keys)'
         )
         
         parser.add_argument(
             '--dry-run',
             action='store_true',
-            help='Show what would be synchronized without making changes',
+            help='Show what would be changed without making changes'
         )
         
         parser.add_argument(
-            '--force',
+            '--force-update',
             action='store_true',
-            help='Force update existing sites (overwrite local changes)',
-        )
-        
-        parser.add_argument(
-            '--environment',
-            type=str,
-            choices=['production', 'staging', 'development', 'testing'],
-            default='production',
-            help='Default environment for new sites (default: production)',
-        )
-        
-        parser.add_argument(
-            '--project',
-            type=str,
-            help='Default project name for new sites',
-        )
-        
-        parser.add_argument(
-            '--tags',
-            type=str,
-            nargs='*',
-            help='Default tags for new sites (space-separated)',
+            help='Update existing sites even if they haven\'t changed'
         )
         
         parser.add_argument(
             '--verbose',
             action='store_true',
-            help='Enable verbose output',
+            help='Enable verbose output'
         )
     
     def handle(self, *args, **options):
-        """Execute the command."""
-        try:
-            # Validate parameters
-            validation = self._validate_parameters(options)
-            if not validation['valid']:
-                for error in validation['errors']:
-                    self.stdout.write(self.style.ERROR(f"❌ {error}"))
-                raise CommandError("Invalid parameters")
-            
-            # Show warnings
-            for warning in validation['warnings']:
-                self.stdout.write(self.style.WARNING(f"⚠️  {warning}"))
-            
-            # Initialize service
-            sync_service = SyncCommandService.create_from_params(
-                api_token=validation['api_token']
+        """Handle the command execution."""
+        verbosity = 2 if options['verbose'] else 1
+        
+        if options['dry_run']:
+            self.stdout.write(
+                self.style.WARNING('🔍 DRY RUN MODE - No changes will be made')
             )
-            
-            # Perform sync
-            self.stdout.write("🔍 Syncing sites with Cloudflare...")
-            result = sync_service.sync_user_sites_command(
-                user=validation['user'],
-                dry_run=options['dry_run'],
-                force_update=options['force'],
-                environment=options['environment'],
-                project=options.get('project') or '',
-                tags=options.get('tags') or [],
-                verbose=options['verbose']
+        
+        # Get API keys to sync
+        if options['api_key']:
+            try:
+                api_keys = [CloudflareApiKey.objects.get(
+                    name=options['api_key'],
+                    is_active=True
+                )]
+                self.stdout.write(f"📡 Syncing specific API key: {options['api_key']}")
+            except CloudflareApiKey.DoesNotExist:
+                raise CommandError(f"API key '{options['api_key']}' not found or inactive")
+        else:
+            api_keys = CloudflareApiKey.objects.filter(is_active=True)
+            self.stdout.write(f"📡 Syncing all {api_keys.count()} active API keys")
+        
+        if not api_keys:
+            self.stdout.write(
+                self.style.WARNING('⚠️  No active API keys found')
             )
+            return
+        
+        # Sync each API key
+        total_stats = {
+            'discovered': 0,
+            'created': 0,
+            'updated': 0,
+            'skipped': 0,
+            'errors': 0
+        }
+        
+        for api_key in api_keys:
+            self.stdout.write(f"\n🔑 Processing API key: {api_key.name}")
             
-            if result['success']:
-                # Display results
-                self._display_results(result['stats'], options['dry_run'])
-            else:
-                self.stdout.write(self.style.ERROR(f"❌ Sync failed: {result['error']}"))
-                raise CommandError(result['error'])
-            
-        except Exception as e:
-            logger.exception("Command failed")
-            raise CommandError(f"Synchronization failed: {e}")
-    
-    def _validate_parameters(self, options: Dict[str, Any]) -> Dict[str, Any]:
-        """Validate command parameters using service."""
-        # Create temporary service for validation
-        temp_service = SyncCommandService.create_from_params("dummy_token")
-        
-        return temp_service.validate_sync_parameters(
-            user_identifier=options['user'],
-            api_token=options.get('api_token'),
-            environment=options['environment']
-        )
-    
-    # Old methods removed - logic moved to SyncCommandService
-    
-    def _display_results(self, stats: Dict[str, int], dry_run: bool) -> None:
-        """Display synchronization results."""
-        mode = "DRY RUN" if dry_run else "COMPLETED"
+            try:
+                sync_service = SiteSyncService(api_key)
+                stats = sync_service.sync_zones(
+                    force_update=options['force_update'],
+                    dry_run=options['dry_run']
+                )
+                
+                # Update totals
+                for key in total_stats:
+                    total_stats[key] += stats[key]
+                
+                # Display results for this API key
+                self._display_api_key_results(api_key.name, stats, verbosity)
+                
+            except Exception as e:
+                self.stdout.write(
+                    self.style.ERROR(f'❌ Failed to sync {api_key.name}: {e}')
+                )
+                total_stats['errors'] += 1
         
-        self.stdout.write(f"\n🎯 Synchronization {mode}")
-        self.stdout.write("=" * 40)
+        # Display overall summary
+        self._display_summary(total_stats, options['dry_run'])
+    
+    def _display_api_key_results(self, api_key_name: str, stats: dict, verbosity: int):
+        """Display results for a single API key."""
+        if stats['errors'] > 0:
+            self.stdout.write(
+                self.style.ERROR(
+                    f"   ❌ {stats['errors']} errors occurred"
+                )
+            )
         
         if stats['created'] > 0:
+            action = "Would create" if stats.get('dry_run') else "Created"
             self.stdout.write(
-                self.style.SUCCESS(f"✨ Created: {stats['created']} sites")
+                self.style.SUCCESS(
+                    f"   ✅ {action} {stats['created']} new sites"
+                )
             )
         
         if stats['updated'] > 0:
+            action = "Would update" if stats.get('dry_run') else "Updated"
             self.stdout.write(
-                self.style.SUCCESS(f"🔄 Updated: {stats['updated']} sites")
+                self.style.SUCCESS(
+                    f"   🔄 {action} {stats['updated']} existing sites"
+                )
             )
         
         if stats['skipped'] > 0:
             self.stdout.write(
-                self.style.WARNING(f"⏭️  Skipped: {stats['skipped']} sites")
+                self.style.WARNING(
+                    f"   ⏭️  Skipped {stats['skipped']} sites (no changes)"
+                )
             )
         
+        # Verbose output - show individual sites
+        if verbosity >= 2 and stats.get('sites'):
+            self.stdout.write("   📋 Site details:")
+            for site_info in stats['sites']:
+                if site_info['action'] == 'created':
+                    self.stdout.write(f"      ➕ Created: {site_info['domain']}")
+                elif site_info['action'] == 'updated':
+                    self.stdout.write(f"      🔄 Updated: {site_info['domain']}")
+                elif site_info['action'] == 'would_create':
+                    self.stdout.write(f"      ➕ Would create: {site_info['domain']}")
+                elif site_info['action'] == 'would_update':
+                    self.stdout.write(f"      🔄 Would update: {site_info['domain']}")
+                    if 'changes' in site_info:
+                        for field, change in site_info['changes'].items():
+                            self.stdout.write(
+                                f"         • {field}: {change['old']} → {change['new']}"
+                            )
+                elif site_info['action'] == 'error':
+                    self.stdout.write(
+                        self.style.ERROR(
+                            f"      ❌ Error: {site_info['domain']} - {site_info['error']}"
+                        )
+                    )
+    
+    def _display_summary(self, stats: dict, dry_run: bool):
+        """Display overall summary."""
+        self.stdout.write("\n" + "="*50)
+        self.stdout.write(
+            self.style.SUCCESS("📊 SYNC SUMMARY") if not dry_run 
+            else self.style.WARNING("📊 DRY RUN SUMMARY")
+        )
+        self.stdout.write("="*50)
+        
+        if stats['discovered'] > 0:
+            self.stdout.write(f"🔍 Zones discovered: {stats['discovered']}")
+        
+        if stats['created'] > 0:
+            action = "Would be created" if dry_run else "Created"
+            self.stdout.write(
+                self.style.SUCCESS(f"✅ Sites {action.lower()}: {stats['created']}")
+            )
+        
+        if stats['updated'] > 0:
+            action = "Would be updated" if dry_run else "Updated"
+            self.stdout.write(
+                self.style.SUCCESS(f"🔄 Sites {action.lower()}: {stats['updated']}")
+            )
+        
+        if stats['skipped'] > 0:
+            self.stdout.write(f"⏭️  Sites skipped: {stats['skipped']}")
+        
         if stats['errors'] > 0:
             self.stdout.write(
-                self.style.ERROR(f"❌ Errors: {stats['errors']} sites")
+                self.style.ERROR(f"❌ Errors: {stats['errors']}")
             )
         
-        total = sum(stats.values())
-        self.stdout.write(f"\n📊 Total processed: {total} zones")
+        total_processed = stats['created'] + stats['updated'] + stats['skipped']
+        if total_processed > 0:
+            self.stdout.write(f"\n📈 Total sites processed: {total_processed}")
         
-        if dry_run:
+        if dry_run and (stats['created'] > 0 or stats['updated'] > 0):
             self.stdout.write(
-                self.style.NOTICE("\n💡 Run without --dry-run to apply changes")
+                self.style.WARNING(
+                    "\n💡 Run without --dry-run to apply these changes"
+                )
             )
+        
+        self.stdout.write(f"⏰ Completed at: {timezone.now().strftime('%Y-%m-%d %H:%M:%S')}")

django_cfg/apps/maintenance/managers/__init__.py

@@ -1,20 +1,15 @@
 """
-Custom managers for maintenance app models.
+Custom managers for maintenance models.
 
-Provides enhanced querying capabilities and business logic methods
-for CloudflareSite, MaintenanceEvent, and related models.
+Simplified managers with useful query methods.
 """
 
-from .sites import CloudflareSiteManager, SiteGroupManager
-from .events import MaintenanceEventManager, MaintenanceLogManager
-from .monitoring import MonitoringTargetManager
-from .deployments import CloudflareDeploymentManager
+from .cloudflare_site_manager import CloudflareSiteManager, CloudflareSiteQuerySet
+from .maintenance_log_manager import MaintenanceLogManager, MaintenanceLogQuerySet
 
 __all__ = [
     'CloudflareSiteManager',
-    'SiteGroupManager', 
-    'MaintenanceEventManager',
-    'MaintenanceLogManager',
-    'MonitoringTargetManager',
-    'CloudflareDeploymentManager',
+    'CloudflareSiteQuerySet',
+    'MaintenanceLogManager', 
+    'MaintenanceLogQuerySet',
 ]