claude-mpm 3.9.11__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/infrastructure/daemon_manager.py

@@ -0,0 +1,279 @@
+from pathlib import Path
+
+#!/usr/bin/env python3
+"""
+Daemon Management Service for Socket.IO Server
+==============================================
+
+Provides daemon management functionality for the Socket.IO server including
+start, stop, restart, and status operations with proper process management.
+
+This service handles:
+- Process lifecycle management (start/stop/restart)
+- PID file management
+- Signal handling for graceful shutdown
+- Conflict detection with other server instances
+- Status monitoring and health checks
+"""
+
+import logging
+import os
+import signal
+import subprocess
+import sys
+import time
+from typing import Any, Dict, Optional
+
+try:
+    import psutil
+except ImportError:
+    # Auto-install psutil if not available
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "psutil"])
+    import psutil
+
+# from claude_mpm.core.base_service import BaseService
+from claude_mpm.services.socketio.server.main import SocketIOServer
+
+logger = logging.getLogger(__name__)
+
+
+class SocketIODaemonManager:
+    """
+    Daemon management service for Socket.IO server.
+
+    Provides comprehensive daemon lifecycle management including process
+    monitoring, conflict detection, and graceful shutdown handling.
+    """
+
+    def __init__(self, host: str = "localhost", port: int = 8765):
+        """
+        Initialize the daemon manager.
+
+        Args:
+            host: Host to bind the server to
+            port: Port to bind the server to
+        """
+        # super().__init__()
+        self.host = host
+        self.port = port
+
+        # Configuration paths
+        self.config_dir = Path.home() / ".claude-mpm"
+        self.pid_file = self.config_dir / "socketio-server.pid"
+        self.log_file = self.config_dir / "socketio-server.log"
+
+        # Ensure directories exist
+        self._ensure_directories()
+
+    def _ensure_directories(self) -> None:
+        """Ensure required directories exist."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def is_running(self) -> bool:
+        """
+        Check if the daemon server is currently running.
+
+        Returns:
+            True if server is running, False otherwise
+        """
+        if not self.pid_file.exists():
+            return False
+
+        try:
+            with open(self.pid_file) as f:
+                pid = int(f.read().strip())
+
+            # Check if process exists and is running
+            process = psutil.Process(pid)
+            return process.is_running()
+
+        except (ValueError, psutil.NoSuchProcess, psutil.AccessDenied):
+            # Clean up stale PID file
+            self.pid_file.unlink(missing_ok=True)
+            return False
+
+    def _check_port_conflict(self) -> Optional[Dict[str, Any]]:
+        """
+        Check for existing server on the target port.
+
+        Returns:
+            Server info if conflict detected, None otherwise
+        """
+        try:
+            import requests
+
+            response = requests.get(
+                f"http://{self.host}:{self.port}/health", timeout=1.0
+            )
+            if response.status_code == 200:
+                return response.json()
+        except:
+            pass
+        return None
+
+    def start(self) -> bool:
+        """
+        Start the Socket.IO server as a daemon.
+
+        Returns:
+            True if started successfully, False otherwise
+        """
+        if self.is_running():
+            logger.info("Socket.IO daemon server is already running")
+            return False
+
+        # Check for port conflicts
+        conflict_info = self._check_port_conflict()
+        if conflict_info and "server_id" in conflict_info:
+            logger.warning(
+                f"Port {self.port} already in use by: {conflict_info.get('server_id')}"
+            )
+            return False
+
+        try:
+            # Fork to create daemon process
+            pid = os.fork()
+            if pid > 0:
+                # Parent process - save PID and exit
+                with open(self.pid_file, "w") as f:
+                    f.write(str(pid))
+                logger.info(f"Socket.IO server started as daemon (PID: {pid})")
+                return True
+
+            # Child process - become daemon
+            self._daemonize()
+            self._run_server()
+
+        except Exception as e:
+            logger.error(f"Failed to start daemon: {e}")
+            return False
+
+    def _daemonize(self) -> None:
+        """Convert the current process into a daemon."""
+        # Create new session
+        os.setsid()
+        os.umask(0)
+
+        # Redirect stdout/stderr to log file
+        with open(self.log_file, "a") as log:
+            os.dup2(log.fileno(), sys.stdout.fileno())
+            os.dup2(log.fileno(), sys.stderr.fileno())
+
+    def _run_server(self) -> None:
+        """Run the Socket.IO server in daemon mode."""
+        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Starting Socket.IO server...")
+
+        # Create and configure server
+        server = SocketIOServer(host=self.host, port=self.port)
+
+        # Setup signal handlers
+        def signal_handler(signum, frame):
+            print(
+                f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Received signal {signum}, shutting down..."
+            )
+            server.stop()
+            self.pid_file.unlink(missing_ok=True)
+            sys.exit(0)
+
+        signal.signal(signal.SIGTERM, signal_handler)
+        signal.signal(signal.SIGINT, signal_handler)
+
+        # Start server and keep running
+        server.start()
+
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            signal_handler(signal.SIGINT, None)
+
+    def stop(self) -> bool:
+        """
+        Stop the daemon server.
+
+        Returns:
+            True if stopped successfully, False otherwise
+        """
+        if not self.is_running():
+            logger.info("Socket.IO daemon server is not running")
+            return False
+
+        try:
+            with open(self.pid_file) as f:
+                pid = int(f.read().strip())
+
+            logger.info(f"Stopping Socket.IO server (PID: {pid})")
+
+            # Send SIGTERM for graceful shutdown
+            os.kill(pid, signal.SIGTERM)
+
+            # Wait for graceful shutdown
+            for _ in range(10):
+                if not self.is_running():
+                    logger.info("Socket.IO server stopped successfully")
+                    self.pid_file.unlink(missing_ok=True)
+                    return True
+                time.sleep(0.5)
+
+            # Force kill if still running
+            logger.warning("Server didn't stop gracefully, forcing shutdown")
+            os.kill(pid, signal.SIGKILL)
+            self.pid_file.unlink(missing_ok=True)
+            return True
+
+        except Exception as e:
+            logger.error(f"Error stopping server: {e}")
+            return False
+
+    def restart(self) -> bool:
+        """
+        Restart the daemon server.
+
+        Returns:
+            True if restarted successfully, False otherwise
+        """
+        logger.info("Restarting Socket.IO daemon server")
+        self.stop()
+        time.sleep(1)
+        return self.start()
+
+    def status(self) -> Dict[str, Any]:
+        """
+        Get detailed status information about the daemon.
+
+        Returns:
+            Dictionary containing status information
+        """
+        status_info = {
+            "running": self.is_running(),
+            "pid_file": str(self.pid_file),
+            "log_file": str(self.log_file),
+            "host": self.host,
+            "port": self.port,
+            "management_style": "daemon",
+        }
+
+        if status_info["running"]:
+            with open(self.pid_file) as f:
+                status_info["pid"] = int(f.read().strip())
+
+            # Check port accessibility
+            try:
+                import socket
+
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                result = sock.connect_ex((self.host, self.port))
+                sock.close()
+                status_info["port_accessible"] = result == 0
+            except:
+                status_info["port_accessible"] = False
+
+            # Check for conflicts
+            conflict_info = self._check_port_conflict()
+            if conflict_info and "server_id" in conflict_info:
+                server_id = conflict_info.get("server_id")
+                if server_id != "daemon-socketio":
+                    status_info["conflict_detected"] = True
+                    status_info["conflicting_server"] = server_id
+
+        return status_info

claude_mpm/services/infrastructure/logging.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Logging Service for Claude MPM Framework
 ========================================
@@ -7,62 +9,61 @@ This module provides centralized logging services and utilities.
 Part of TSK-0046: Service Layer Architecture Reorganization
 """
 
-from typing import Any, Dict, Optional, List
-from pathlib import Path
-import logging
 import json
+import logging
 from datetime import datetime
+from typing import Any, Dict, List, Optional
 
-from claude_mpm.services.core import SyncBaseService, IStructuredLogger
 from claude_mpm.core.logger import get_logger
+from claude_mpm.services.core import IStructuredLogger, SyncBaseService
 
 
 class LoggingService(SyncBaseService, IStructuredLogger):
     """
     Centralized logging service for the Claude MPM framework.
-    
+
     This service provides:
     - Structured logging with JSON output
     - Log rotation and archival
     - Performance metrics logging
     - Audit trail capabilities
     """
-    
+
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         """
         Initialize logging service.
-        
+
         Args:
             config: Logging configuration
         """
         super().__init__("LoggingService", config)
-        self.log_dir = Path(self.get_config('log_dir', '.claude-mpm/logs'))
-        self.log_level = self.get_config('log_level', 'INFO')
-        self.structured_logging = self.get_config('structured_logging', True)
+        self.log_dir = Path(self.get_config("log_dir", ".claude-mpm/logs"))
+        self.log_level = self.get_config("log_level", "INFO")
+        self.structured_logging = self.get_config("structured_logging", True)
         self._log_handlers = []
-    
+
     def initialize(self) -> bool:
         """Initialize the logging service."""
         try:
             # Create log directory if it doesn't exist
             self.log_dir.mkdir(parents=True, exist_ok=True)
-            
+
             # Set up log rotation if configured
-            if self.get_config('enable_rotation', True):
+            if self.get_config("enable_rotation", True):
                 self._setup_rotation()
-            
+
             # Set up structured logging if enabled
             if self.structured_logging:
                 self._setup_structured_logging()
-            
+
             self._initialized = True
             self.log_info("Logging service initialized successfully")
             return True
-            
+
         except Exception as e:
             self.log_error(f"Failed to initialize logging service: {e}")
             return False
-    
+
     def shutdown(self) -> None:
         """Shutdown the logging service."""
         try:
@@ -70,133 +71,139 @@ class LoggingService(SyncBaseService, IStructuredLogger):
             for handler in self._log_handlers:
                 handler.flush()
                 handler.close()
-            
+
             self._log_handlers.clear()
             self._shutdown = True
             self.log_info("Logging service shutdown successfully")
-            
+
         except Exception as e:
             self.log_error(f"Error during logging service shutdown: {e}")
-    
+
     def log(self, level: str, message: str, **context) -> None:
         """
         Log a message with context.
-        
+
         Args:
             level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
             message: Log message
             **context: Additional context to include
         """
-        logger = get_logger(context.get('component', 'default'))
-        
+        logger = get_logger(context.get("component", "default"))
+
         if self.structured_logging:
             log_entry = {
-                'timestamp': datetime.utcnow().isoformat(),
-                'level': level,
-                'message': message,
-                'context': context
+                "timestamp": datetime.utcnow().isoformat(),
+                "level": level,
+                "message": message,
+                "context": context,
             }
             message = json.dumps(log_entry)
-        
+
         log_method = getattr(logger, level.lower(), logger.info)
         log_method(message)
-    
+
     def log_performance(self, operation: str, duration: float, **metrics) -> None:
         """
         Log performance metrics.
-        
+
         Args:
             operation: Name of the operation
             duration: Duration in seconds
             **metrics: Additional performance metrics
         """
-        self.log('INFO', f"Performance: {operation}", 
-                operation=operation, 
-                duration_ms=duration * 1000,
-                **metrics)
-    
+        self.log(
+            "INFO",
+            f"Performance: {operation}",
+            operation=operation,
+            duration_ms=duration * 1000,
+            **metrics,
+        )
+
     def log_audit(self, action: str, user: str, **details) -> None:
         """
         Log an audit event.
-        
+
         Args:
             action: Action performed
             user: User who performed the action
             **details: Additional audit details
         """
-        self.log('INFO', f"Audit: {action} by {user}",
-                audit=True,
-                action=action,
-                user=user,
-                **details)
-    
-    def get_logs(self, level: Optional[str] = None, 
-                 component: Optional[str] = None,
-                 limit: int = 100) -> List[Dict[str, Any]]:
+        self.log(
+            "INFO",
+            f"Audit: {action} by {user}",
+            audit=True,
+            action=action,
+            user=user,
+            **details,
+        )
+
+    def get_logs(
+        self,
+        level: Optional[str] = None,
+        component: Optional[str] = None,
+        limit: int = 100,
+    ) -> List[Dict[str, Any]]:
         """
         Retrieve recent logs.
-        
+
         Args:
             level: Filter by log level
             component: Filter by component
             limit: Maximum number of logs to return
-            
+
         Returns:
             List of log entries
         """
         # This would typically read from log files or a log aggregation service
         # For now, return empty list as placeholder
         return []
-    
+
     def _setup_rotation(self) -> None:
         """Set up log rotation."""
         from logging.handlers import RotatingFileHandler
-        
-        max_bytes = self.get_config('max_bytes', 10 * 1024 * 1024)  # 10MB
-        backup_count = self.get_config('backup_count', 5)
-        
+
+        max_bytes = self.get_config("max_bytes", 10 * 1024 * 1024)  # 10MB
+        backup_count = self.get_config("backup_count", 5)
+
         handler = RotatingFileHandler(
-            self.log_dir / 'claude_mpm.log',
+            self.log_dir / "claude_mpm.log",
             maxBytes=max_bytes,
-            backupCount=backup_count
+            backupCount=backup_count,
         )
-        
+
         formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
         )
         handler.setFormatter(formatter)
-        
+
         self._log_handlers.append(handler)
         logging.getLogger().addHandler(handler)
-    
+
     def _setup_structured_logging(self) -> None:
         """Set up structured JSON logging."""
         import logging.config
-        
+
         config = {
-            'version': 1,
-            'disable_existing_loggers': False,
-            'formatters': {
-                'json': {
-                    'class': 'pythonjsonlogger.jsonlogger.JsonFormatter',
-                    'format': '%(asctime)s %(name)s %(levelname)s %(message)s'
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "json": {
+                    "class": "pythonjsonlogger.jsonlogger.JsonFormatter",
+                    "format": "%(asctime)s %(name)s %(levelname)s %(message)s",
                 }
             },
-            'handlers': {
-                'json_file': {
-                    'class': 'logging.FileHandler',
-                    'filename': str(self.log_dir / 'structured.json'),
-                    'formatter': 'json'
+            "handlers": {
+                "json_file": {
+                    "class": "logging.FileHandler",
+                    "filename": str(self.log_dir / "structured.json"),
+                    "formatter": "json",
                 }
             },
-            'root': {
-                'handlers': ['json_file'],
-                'level': self.log_level
-            }
+            "root": {"handlers": ["json_file"], "level": self.log_level},
         }
-        
+
         try:
             logging.config.dictConfig(config)
         except ImportError:
             # If pythonjsonlogger is not available, fall back to regular logging
-            self.log_warning("pythonjsonlogger not available, using standard logging")
+            self.log_warning("pythonjsonlogger not available, using standard logging")