did stuff

admin_interface.py

@@ -0,0 +1,479 @@
+#!/usr/bin/env python3
+"""
+Debian Forge System Administration Interface
+
+This module provides system administration functionality including:
+- System configuration management
+- Build monitoring and health checks
+- Resource usage tracking
+- System maintenance tools
+"""
+
+import json
+import os
+import psutil
+import sqlite3
+import time
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+from pathlib import Path
+
+@dataclass
+class SystemStatus:
+    """System status information"""
+    status: str
+    cpu_percent: float
+    memory_percent: float
+    disk_percent: float
+    active_builds: int
+    queued_builds: int
+    total_builds: int
+    uptime: str
+    last_updated: str
+
+@dataclass
+class BuildStatistics:
+    """Build statistics and metrics"""
+    total_builds: int
+    successful_builds: int
+    failed_builds: int
+    average_build_time: float
+    builds_per_day: float
+    most_used_blueprint: str
+    resource_usage_trend: Dict[str, float]
+
+@dataclass
+class SystemConfiguration:
+    """System configuration settings"""
+    max_concurrent_builds: int
+    resource_limits: Dict[str, int]
+    cleanup_policies: Dict[str, Any]
+    security_settings: Dict[str, Any]
+    notification_settings: Dict[str, Any]
+
+class AdminInterface:
+    """System administration interface for Debian Forge"""
+    
+    def __init__(self, db_path: str = "admin.db"):
+        self.db_path = db_path
+        self._init_database()
+    
+    def _init_database(self):
+        """Initialize the admin database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        # Create system configuration table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS system_config (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+        """)
+        
+        # Create system logs table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS system_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                level TEXT NOT NULL,
+                message TEXT NOT NULL,
+                component TEXT NOT NULL,
+                timestamp TEXT NOT NULL
+            )
+        """)
+        
+        # Create maintenance tasks table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS maintenance_tasks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                task_name TEXT NOT NULL,
+                status TEXT NOT NULL,
+                scheduled_at TEXT NOT NULL,
+                completed_at TEXT,
+                result TEXT
+            )
+        """)
+        
+        # Insert default configuration
+        default_config = {
+            "max_concurrent_builds": "4",
+            "cpu_limit": "80",
+            "memory_limit": "85",
+            "disk_limit": "90",
+            "cleanup_interval": "3600",
+            "log_retention_days": "30",
+            "backup_interval": "86400"
+        }
+        
+        for key, value in default_config.items():
+            cursor.execute("""
+                INSERT OR IGNORE INTO system_config (key, value, updated_at)
+                VALUES (?, ?, ?)
+            """, (key, value, time.strftime("%Y-%m-%d %H:%M:%S")))
+        
+        conn.commit()
+        conn.close()
+    
+    def get_system_status(self) -> SystemStatus:
+        """Get current system status"""
+        # Get CPU usage
+        cpu_percent = psutil.cpu_percent(interval=1)
+        
+        # Get memory usage
+        memory = psutil.virtual_memory()
+        memory_percent = memory.percent
+        
+        # Get disk usage for the main partition
+        disk = psutil.disk_usage('/')
+        disk_percent = (disk.used / disk.total) * 100
+        
+        # Get build statistics (simulated for now)
+        active_builds = self._get_active_builds_count()
+        queued_builds = self._get_queued_builds_count()
+        total_builds = self._get_total_builds_count()
+        
+        # Get system uptime
+        boot_time = psutil.boot_time()
+        uptime_seconds = time.time() - boot_time
+        uptime = self._format_uptime(uptime_seconds)
+        
+        # Determine overall status
+        status = "healthy"
+        if cpu_percent > 90 or memory_percent > 90 or disk_percent > 90:
+            status = "warning"
+        if cpu_percent > 95 or memory_percent > 95 or disk_percent > 95:
+            status = "critical"
+        
+        return SystemStatus(
+            status=status,
+            cpu_percent=cpu_percent,
+            memory_percent=memory_percent,
+            disk_percent=disk_percent,
+            active_builds=active_builds,
+            queued_builds=queued_builds,
+            total_builds=total_builds,
+            uptime=uptime,
+            last_updated=time.strftime("%Y-%m-%d %H:%M:%S")
+        )
+    
+    def _get_active_builds_count(self) -> int:
+        """Get number of active builds (simulated)"""
+        # In real implementation, this would query the build orchestrator
+        return 2
+    
+    def _get_queued_builds_count(self) -> int:
+        """Get number of queued builds (simulated)"""
+        # In real implementation, this would query the build queue
+        return 1
+    
+    def _get_total_builds_count(self) -> int:
+        """Get total number of builds (simulated)"""
+        # In real implementation, this would query the build history
+        return 47
+    
+    def _format_uptime(self, seconds: float) -> str:
+        """Format uptime in human-readable format"""
+        days = int(seconds // 86400)
+        hours = int((seconds % 86400) // 3600)
+        minutes = int((seconds % 3600) // 60)
+        
+        if days > 0:
+            return f"{days}d {hours}h {minutes}m"
+        elif hours > 0:
+            return f"{hours}h {minutes}m"
+        else:
+            return f"{minutes}m"
+    
+    def get_build_statistics(self) -> BuildStatistics:
+        """Get build statistics and metrics"""
+        # Simulated statistics - in real implementation, query build database
+        return BuildStatistics(
+            total_builds=47,
+            successful_builds=42,
+            failed_builds=5,
+            average_build_time=1847.5,  # seconds
+            builds_per_day=12.3,
+            most_used_blueprint="debian-atomic-base",
+            resource_usage_trend={
+                "cpu_avg": 65.2,
+                "memory_avg": 78.4,
+                "disk_growth": 2.1
+            }
+        )
+    
+    def get_system_configuration(self) -> SystemConfiguration:
+        """Get system configuration"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute("SELECT key, value FROM system_config")
+        config_data = dict(cursor.fetchall())
+        conn.close()
+        
+        return SystemConfiguration(
+            max_concurrent_builds=int(config_data.get("max_concurrent_builds", "4")),
+            resource_limits={
+                "cpu": int(config_data.get("cpu_limit", "80")),
+                "memory": int(config_data.get("memory_limit", "85")),
+                "disk": int(config_data.get("disk_limit", "90"))
+            },
+            cleanup_policies={
+                "interval": int(config_data.get("cleanup_interval", "3600")),
+                "log_retention_days": int(config_data.get("log_retention_days", "30"))
+            },
+            security_settings={
+                "require_authentication": True,
+                "session_timeout": 3600,
+                "password_complexity": True
+            },
+            notification_settings={
+                "email_alerts": False,
+                "slack_integration": False,
+                "webhook_url": None
+            }
+        )
+    
+    def update_system_configuration(self, config: SystemConfiguration) -> bool:
+        """Update system configuration"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+            
+            # Update configuration values
+            config_updates = [
+                ("max_concurrent_builds", str(config.max_concurrent_builds)),
+                ("cpu_limit", str(config.resource_limits["cpu"])),
+                ("memory_limit", str(config.resource_limits["memory"])),
+                ("disk_limit", str(config.resource_limits["disk"])),
+                ("cleanup_interval", str(config.cleanup_policies["interval"])),
+                ("log_retention_days", str(config.cleanup_policies["log_retention_days"]))
+            ]
+            
+            for key, value in config_updates:
+                cursor.execute("""
+                    INSERT OR REPLACE INTO system_config (key, value, updated_at)
+                    VALUES (?, ?, ?)
+                """, (key, value, timestamp))
+            
+            conn.commit()
+            conn.close()
+            
+            # Log configuration change
+            self.log_event("INFO", "System configuration updated", "admin_interface")
+            
+            return True
+            
+        except Exception as e:
+            self.log_event("ERROR", f"Failed to update configuration: {e}", "admin_interface")
+            return False
+    
+    def log_event(self, level: str, message: str, component: str):
+        """Log system event"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute("""
+                INSERT INTO system_logs (level, message, component, timestamp)
+                VALUES (?, ?, ?, ?)
+            """, (level, message, component, time.strftime("%Y-%m-%d %H:%M:%S")))
+            
+            conn.commit()
+            conn.close()
+            
+        except Exception as e:
+            print(f"Failed to log event: {e}")
+    
+    def get_system_logs(self, limit: int = 100, level: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get system logs"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            if level:
+                cursor.execute("""
+                    SELECT level, message, component, timestamp
+                    FROM system_logs WHERE level = ?
+                    ORDER BY timestamp DESC LIMIT ?
+                """, (level, limit))
+            else:
+                cursor.execute("""
+                    SELECT level, message, component, timestamp
+                    FROM system_logs
+                    ORDER BY timestamp DESC LIMIT ?
+                """, (limit,))
+            
+            logs = []
+            for row in cursor.fetchall():
+                logs.append({
+                    "level": row[0],
+                    "message": row[1],
+                    "component": row[2],
+                    "timestamp": row[3]
+                })
+            
+            conn.close()
+            return logs
+            
+        except Exception as e:
+            self.log_event("ERROR", f"Failed to retrieve logs: {e}", "admin_interface")
+            return []
+    
+    def schedule_maintenance_task(self, task_name: str, scheduled_time: str) -> bool:
+        """Schedule a maintenance task"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute("""
+                INSERT INTO maintenance_tasks (task_name, status, scheduled_at)
+                VALUES (?, ?, ?)
+            """, (task_name, "scheduled", scheduled_time))
+            
+            conn.commit()
+            conn.close()
+            
+            self.log_event("INFO", f"Maintenance task scheduled: {task_name}", "admin_interface")
+            return True
+            
+        except Exception as e:
+            self.log_event("ERROR", f"Failed to schedule task: {e}", "admin_interface")
+            return False
+    
+    def get_maintenance_tasks(self) -> List[Dict[str, Any]]:
+        """Get maintenance tasks"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute("""
+                SELECT task_name, status, scheduled_at, completed_at, result
+                FROM maintenance_tasks
+                ORDER BY scheduled_at DESC
+            """)
+            
+            tasks = []
+            for row in cursor.fetchall():
+                tasks.append({
+                    "task_name": row[0],
+                    "status": row[1],
+                    "scheduled_at": row[2],
+                    "completed_at": row[3],
+                    "result": row[4]
+                })
+            
+            conn.close()
+            return tasks
+            
+        except Exception as e:
+            self.log_event("ERROR", f"Failed to retrieve tasks: {e}", "admin_interface")
+            return []
+    
+    def run_system_cleanup(self) -> Dict[str, Any]:
+        """Run system cleanup tasks"""
+        results = {
+            "status": "success",
+            "tasks_completed": [],
+            "tasks_failed": [],
+            "cleanup_summary": {}
+        }
+        
+        try:
+            # Cleanup old logs
+            self._cleanup_old_logs()
+            results["tasks_completed"].append("log_cleanup")
+            
+            # Cleanup temporary files
+            temp_cleaned = self._cleanup_temp_files()
+            results["tasks_completed"].append("temp_cleanup")
+            results["cleanup_summary"]["temp_files_removed"] = temp_cleaned
+            
+            # Cleanup old build artifacts (simulated)
+            artifacts_cleaned = self._cleanup_old_artifacts()
+            results["tasks_completed"].append("artifact_cleanup")
+            results["cleanup_summary"]["artifacts_removed"] = artifacts_cleaned
+            
+            self.log_event("INFO", "System cleanup completed successfully", "admin_interface")
+            
+        except Exception as e:
+            results["status"] = "partial_failure"
+            results["tasks_failed"].append(f"cleanup_error: {e}")
+            self.log_event("ERROR", f"System cleanup failed: {e}", "admin_interface")
+        
+        return results
+    
+    def _cleanup_old_logs(self):
+        """Cleanup old log entries"""
+        config = self.get_system_configuration()
+        retention_days = config.cleanup_policies["log_retention_days"]
+        
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cutoff_date = time.strftime("%Y-%m-%d %H:%M:%S", 
+                                    time.localtime(time.time() - (retention_days * 86400)))
+        
+        cursor.execute("DELETE FROM system_logs WHERE timestamp < ?", (cutoff_date,))
+        conn.commit()
+        conn.close()
+    
+    def _cleanup_temp_files(self) -> int:
+        """Cleanup temporary files"""
+        temp_dirs = ["/tmp", "/var/tmp"]
+        files_removed = 0
+        
+        for temp_dir in temp_dirs:
+            if os.path.exists(temp_dir):
+                for filename in os.listdir(temp_dir):
+                    if filename.startswith("debian-forge-") or filename.startswith("osbuild-"):
+                        filepath = os.path.join(temp_dir, filename)
+                        try:
+                            if os.path.isfile(filepath):
+                                os.remove(filepath)
+                                files_removed += 1
+                            elif os.path.isdir(filepath):
+                                import shutil
+                                shutil.rmtree(filepath)
+                                files_removed += 1
+                        except Exception:
+                            pass  # Ignore errors for individual files
+        
+        return files_removed
+    
+    def _cleanup_old_artifacts(self) -> int:
+        """Cleanup old build artifacts (simulated)"""
+        # In real implementation, this would cleanup old build artifacts
+        # based on configured retention policies
+        return 15  # Simulated number of artifacts removed
+    
+    def get_resource_usage_history(self, hours: int = 24) -> Dict[str, List[float]]:
+        """Get resource usage history (simulated data)"""
+        # In real implementation, this would query stored metrics
+        import random
+        
+        data_points = hours * 6  # Every 10 minutes
+        
+        return {
+            "timestamps": [i * 10 for i in range(data_points)],  # Minutes ago
+            "cpu_usage": [random.uniform(20, 80) for _ in range(data_points)],
+            "memory_usage": [random.uniform(30, 85) for _ in range(data_points)],
+            "disk_usage": [random.uniform(60, 75) for _ in range(data_points)]
+        }
+    
+    def restart_services(self, services: List[str]) -> Dict[str, bool]:
+        """Restart system services (simulated)"""
+        results = {}
+        
+        for service in services:
+            try:
+                # In real implementation, this would use systemctl or similar
+                self.log_event("INFO", f"Restarting service: {service}", "admin_interface")
+                results[service] = True
+            except Exception as e:
+                self.log_event("ERROR", f"Failed to restart {service}: {e}", "admin_interface")
+                results[service] = False
+        
+        return results