dynamic-mcp 0.2.0__py3-none-any.whl

dynamic_mcp/bpftrace_executor.py

@@ -0,0 +1,210 @@
+"""BPFtrace script execution and management."""
+
+import asyncio
+import logging
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BPFtraceExecutor:
+    """Executes BPFtrace scripts with proper permission handling."""
+
+    def __init__(self, timeout: int = 30):
+        """Initialize BPFtrace executor.
+        
+        Args:
+            timeout: Default timeout for script execution in seconds
+        """
+        self.timeout = timeout
+        self.bpftrace_path = self._find_bpftrace()
+
+    def _find_bpftrace(self) -> Optional[str]:
+        """Find bpftrace binary in system PATH."""
+        try:
+            result = subprocess.run(
+                ["which", "bpftrace"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                path = result.stdout.strip()
+                logger.info(f"Found bpftrace at: {path}")
+                return path
+        except Exception as e:
+            logger.warning(f"Could not find bpftrace: {e}")
+        return None
+
+    def is_available(self) -> bool:
+        """Check if bpftrace is available on the system."""
+        return self.bpftrace_path is not None
+
+    def get_version(self) -> Optional[str]:
+        """Get bpftrace version."""
+        if not self.bpftrace_path:
+            return None
+        try:
+            result = subprocess.run(
+                [self.bpftrace_path, "--version"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True,
+                timeout=5
+            )
+            return result.stdout.strip() if result.returncode == 0 else None
+        except Exception as e:
+            logger.warning(f"Could not get bpftrace version: {e}")
+            return None
+
+    async def execute_script(
+        self,
+        script: str,
+        timeout: Optional[int] = None,
+        use_sudo: bool = True
+    ) -> Tuple[str, str, int]:
+        """Execute a BPFtrace script.
+        
+        Args:
+            script: BPFtrace script content
+            timeout: Execution timeout in seconds (uses default if None)
+            use_sudo: Whether to use sudo for execution
+            
+        Returns:
+            Tuple of (stdout, stderr, return_code)
+        """
+        if not self.bpftrace_path:
+            return "", "BPFtrace not available on system", 1
+
+        timeout = timeout or self.timeout
+
+        # Write script to temporary file
+        try:
+            with tempfile.NamedTemporaryFile(
+                mode='w',
+                suffix='.bt',
+                delete=False
+            ) as f:
+                f.write(script)
+                script_path = f.name
+
+            return await self._execute_script_file(
+                script_path,
+                timeout,
+                use_sudo
+            )
+        finally:
+            # Clean up temporary file
+            try:
+                os.unlink(script_path)
+            except Exception as e:
+                logger.warning(f"Could not delete temp script: {e}")
+
+    async def _execute_script_file(
+        self,
+        script_path: str,
+        timeout: int,
+        use_sudo: bool
+    ) -> Tuple[str, str, int]:
+        """Execute a BPFtrace script from file."""
+        cmd = [self.bpftrace_path, script_path]
+
+        if use_sudo:
+            cmd = ["sudo", "-n"] + cmd
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+
+            try:
+                stdout, stderr = await asyncio.wait_for(
+                    process.communicate(),
+                    timeout=timeout
+                )
+                return (
+                    stdout.decode('utf-8', errors='ignore'),
+                    stderr.decode('utf-8', errors='ignore'),
+                    process.returncode
+                )
+            except asyncio.TimeoutError:
+                logger.info(f"BPFtrace script execution timeout after {timeout}s, terminating process")
+
+                # Try graceful termination first with SIGTERM
+                process.terminate()
+                logger.debug("Sent SIGTERM to process")
+                try:
+                    # Wait for graceful termination with a short timeout
+                    logger.debug("Waiting for graceful termination...")
+                    await asyncio.wait_for(process.wait(), timeout=2)
+                    logger.debug("Process terminated gracefully")
+                except asyncio.TimeoutError:
+                    # If graceful termination fails, force kill
+                    logger.warning("Graceful termination failed, force killing process")
+                    process.kill()
+                    logger.debug("Sent SIGKILL to process")
+                    try:
+                        logger.debug("Waiting for process to be killed...")
+                        await asyncio.wait_for(process.wait(), timeout=1)
+                        logger.debug("Process killed successfully")
+                    except asyncio.TimeoutError:
+                        logger.error("Process did not respond to SIGKILL")
+
+                # Capture any partial output that was produced before timeout
+                # Don't try to read from streams as they may block
+                stdout_text = ""
+                stderr_text = f"Script execution timed out after {timeout}s"
+
+                logger.debug(f"Returning timeout result: exit_code=124")
+                return stdout_text, stderr_text, 124
+
+        except Exception as e:
+            logger.error(f"Error executing BPFtrace script: {e}")
+            return "", str(e), 1
+
+    def validate_script(self, script: str) -> Tuple[bool, str]:
+        """Validate BPFtrace script syntax.
+        
+        Args:
+            script: BPFtrace script content
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not self.bpftrace_path:
+            return False, "BPFtrace not available"
+
+        try:
+            with tempfile.NamedTemporaryFile(
+                mode='w',
+                suffix='.bt',
+                delete=False
+            ) as f:
+                f.write(script)
+                script_path = f.name
+
+            try:
+                result = subprocess.run(
+                    ["sudo", "-n", self.bpftrace_path, "-c", script_path],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    universal_newlines=True,
+                    timeout=5
+                )
+                if result.returncode == 0:
+                    return True, ""
+                else:
+                    return False, result.stderr
+            finally:
+                os.unlink(script_path)
+
+        except Exception as e:
+            return False, str(e)
+

dynamic_mcp/config.py

@@ -0,0 +1,106 @@
+"""Configuration for dynamic MCP server."""
+
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import Dict, Any
+
+from dynamic_mcp.permission_manager import check_crash_dump_access, configure_crash_dump_permissions
+
+
+class Config:
+    """Configuration class for crash MCP server."""
+    
+    def __init__(self):
+        self.crash_dump_path = Path(os.getenv("CRASH_DUMP_PATH", "/var/crash"))
+        self.kernel_path = Path(os.getenv("KERNEL_PATH", "/boot"))
+        self.log_level = os.getenv("LOG_LEVEL", "INFO")
+        self.crash_timeout = int(os.getenv("CRASH_TIMEOUT", "360"))
+        self.max_crash_dumps = int(os.getenv("MAX_CRASH_DUMPS", "10"))
+        self.session_init_timeout = int(os.getenv("SESSION_INIT_TIMEOUT", "1024"))
+
+
+def setup_logging():
+    """Setup logging configuration."""
+    logging.basicConfig(
+        level=getattr(logging, os.getenv("LOG_LEVEL", "INFO")),
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+
+def check_system_requirements() -> Dict[str, Any]:
+    """Check system requirements for crash analysis."""
+    requirements = {
+        "crash_utility": False,
+        "crash_dump_access": False,
+        "kernel_access": False,
+        "root_access": False,
+        "crash_dump_readable": False
+    }
+
+    # Check crash utility
+    try:
+        result = subprocess.run(["crash", "--version"], capture_output=True, text=True, timeout=10)
+        requirements["crash_utility"] = result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        pass
+
+    # Check crash dump access
+    crash_path = Path("/var/crash")
+    requirements["crash_dump_access"] = crash_path.exists() and crash_path.is_dir()
+
+    # Check if crash dump directory is readable
+    requirements["crash_dump_readable"] = check_crash_dump_access(crash_path)
+
+    # Check kernel access
+    kernel_path = Path("/boot")
+    requirements["kernel_access"] = kernel_path.exists() and kernel_path.is_dir()
+
+    # Check root access
+    requirements["root_access"] = os.geteuid() == 0
+
+    return requirements
+
+
+def validate_crash_utility() -> str:
+    """Validate crash utility availability and return version."""
+    try:
+        result = subprocess.run(["crash", "--version"], capture_output=True, text=True, timeout=10)
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        pass
+    return ""
+
+
+def ensure_crash_dump_access(crash_path: Path = Path("/var/crash")) -> bool:
+    """Ensure crash dump directory is readable at runtime.
+
+    Attempts to configure permissions if not already readable.
+
+    Args:
+        crash_path: Path to crash dump directory
+
+    Returns:
+        True if readable or successfully configured, False otherwise
+    """
+    logger = logging.getLogger(__name__)
+
+    # Check if already readable
+    if check_crash_dump_access(crash_path):
+        logger.debug(f"Crash dump directory already readable: {crash_path}")
+        return True
+
+    logger.info(f"Crash dump directory not readable, attempting to configure permissions...")
+
+    # Try to configure permissions
+    success, message = configure_crash_dump_permissions(crash_path)
+
+    if success:
+        logger.info(f"Permission configuration: {message}")
+        # Verify it worked
+        return check_crash_dump_access(crash_path)
+    else:
+        logger.warning(f"Permission configuration failed: {message}")
+        return False

dynamic_mcp/crash_discovery.py

@@ -0,0 +1,134 @@
+"""Crash dump discovery functionality."""
+
+import logging
+import os
+from pathlib import Path
+from typing import List, NamedTuple, Optional
+from datetime import datetime
+
+
+logger = logging.getLogger(__name__)
+
+
+class CrashDump(NamedTuple):
+    """Represents a crash dump file."""
+    name: str
+    path: Path
+    size: int
+    timestamp: datetime
+
+    @property
+    def mtime(self) -> datetime:
+        """Get modification time (alias for timestamp)."""
+        return self.timestamp
+
+    def to_dict(self) -> dict:
+        """Convert crash dump to dictionary."""
+        return {
+            "name": self.name,
+            "path": str(self.path),
+            "size": self.size,
+            "size_mb": round(self.size / (1024 * 1024), 2),
+            "timestamp": self.timestamp.isoformat(),
+            "mtime": self.mtime.isoformat(),
+            "readable": os.access(self.path, os.R_OK)
+        }
+
+
+class CrashDumpDiscovery:
+    """Discovers crash dump files in the system."""
+    
+    def __init__(self, crash_dump_path: str):
+        self.crash_dump_path = Path(crash_dump_path)
+        self.dump_patterns = [
+            "vmcore*",
+            "core*", 
+            "crash*",
+            "dump*"
+        ]
+    
+    def find_crash_dumps(self, max_dumps: int = 10) -> List[CrashDump]:
+        """Find crash dump files in the system."""
+        dumps = []
+        
+        if not self.crash_dump_path.exists():
+            logger.warning(f"Crash dump path does not exist: {self.crash_dump_path}")
+            return dumps
+        
+        try:
+            # Search in main directory and subdirectories
+            for root, dirs, files in os.walk(self.crash_dump_path):
+                root_path = Path(root)
+                
+                for file in files:
+                    file_path = root_path / file
+                    
+                    # Check if file matches dump patterns
+                    if any(file_path.match(pattern) for pattern in self.dump_patterns):
+                        try:
+                            stat = file_path.stat()
+                            dump = CrashDump(
+                                name=file,
+                                path=file_path,
+                                size=stat.st_size,
+                                timestamp=datetime.fromtimestamp(stat.st_mtime)
+                            )
+                            dumps.append(dump)
+                        except (OSError, PermissionError) as e:
+                            logger.warning(f"Cannot access dump file {file_path}: {e}")
+                            continue
+                
+                # Limit search depth to avoid excessive recursion
+                if len(str(root_path).split(os.sep)) - len(str(self.crash_dump_path).split(os.sep)) > 2:
+                    dirs.clear()
+        
+        except PermissionError as e:
+            logger.error(f"Permission denied accessing crash dump directory: {e}")
+        
+        # Sort by timestamp (newest first) and limit results
+        dumps.sort(key=lambda x: x.timestamp, reverse=True)
+        return dumps[:max_dumps]
+    
+    def get_dump_info(self, dump: CrashDump) -> dict:
+        """Get detailed information about a crash dump."""
+        return {
+            "name": dump.name,
+            "path": str(dump.path),
+            "size": dump.size,
+            "size_mb": round(dump.size / (1024 * 1024), 2),
+            "timestamp": dump.timestamp.isoformat(),
+            "readable": os.access(dump.path, os.R_OK)
+        }
+
+    def get_latest_crash_dump(self) -> Optional[CrashDump]:
+        """Get the most recent crash dump."""
+        dumps = self.find_crash_dumps(max_dumps=1)
+        return dumps[0] if dumps else None
+
+    def get_crash_dump_by_name(self, name: str) -> Optional[CrashDump]:
+        """Get a crash dump by name."""
+        dumps = self.find_crash_dumps()
+        for dump in dumps:
+            if dump.name == name:
+                return dump
+        return None
+
+    def is_valid_crash_dump(self, dump) -> bool:
+        """Check if a file is a valid crash dump."""
+        try:
+            # Handle both string paths and CrashDump objects
+            if isinstance(dump, CrashDump):
+                path = dump.path
+                filename = dump.name
+            else:
+                path = Path(dump)
+                filename = path.name
+
+            if not path.exists() or not path.is_file():
+                return False
+
+            # Check if filename matches dump patterns
+            return any(Path(filename).match(pattern) for pattern in self.dump_patterns)
+        except Exception as e:
+            logger.warning(f"Error validating crash dump {getattr(dump, 'name', str(dump))}: {e}")
+            return False

dynamic_mcp/crash_session.py

@@ -0,0 +1,209 @@
+"""Crash session management."""
+
+import logging
+import pexpect
+import subprocess
+import time
+from typing import Optional, Tuple
+
+
+logger = logging.getLogger(__name__)
+
+
+class CrashSession:
+    """Represents an active crash analysis session."""
+
+    def __init__(self, dump_path: str, kernel_path: str):
+        self.dump_path = dump_path
+        self.kernel_path = kernel_path
+        self.process = None
+        self.session_id = f"crash_{int(time.time())}"
+        self.active = False
+        self.prompt_patterns = [
+            r'crash> ',           # Standard prompt with space
+            r'crash>',            # Prompt without space
+            r'crash>\s*',         # Prompt with optional whitespace
+        ]
+
+    def is_active(self) -> bool:
+        """Check if the session is active."""
+        return self.active
+
+    def start(self, timeout: int = 180) -> bool:
+        """Start the crash session.
+
+        Detects kernel file type and uses appropriate crash command format:
+        - For debug symbols (vmlinux): crash --no_scroll vmcore vmlinux
+        - For compressed kernels (vmlinuz): crash --no_scroll -f vmlinuz vmcore
+        """
+        try:
+            # Detect kernel file type and build appropriate command
+            kernel_name = self.kernel_path.split('/')[-1]
+            is_debug_symbol = kernel_name == "vmlinux" or kernel_name.startswith("vmlinux-")
+
+            if is_debug_symbol:
+                # Debug symbols: crash --no_scroll vmcore vmlinux (no -f flag needed)
+                cmd_parts = ['crash', '--no_scroll', self.dump_path, self.kernel_path]
+            else:
+                # Compressed kernel: crash --no_scroll -f vmlinuz vmcore
+                cmd_parts = ['crash', '--no_scroll', '-f', self.kernel_path, self.dump_path]
+
+            cmd = ' '.join(cmd_parts)
+
+            logger.info(f"Starting crash process: {cmd}")
+
+            # Start crash process
+            self.process = pexpect.spawn(cmd, timeout=timeout)
+
+            # Wait for initial prompt
+            expect_list = self.prompt_patterns + ['crash: .*', pexpect.TIMEOUT, pexpect.EOF]
+
+            index = self.process.expect(expect_list, timeout=timeout)
+
+            if index < len(self.prompt_patterns):
+                logger.info(f"Crash session started successfully: {self.session_id}")
+                self.active = True
+                return True
+            elif index == len(self.prompt_patterns):
+                # Error pattern
+                error_msg = self.process.after.decode('utf-8', errors='ignore')
+                logger.error(f"Crash startup error: {error_msg}")
+                return False
+            elif index == len(self.prompt_patterns) + 1:
+                # Timeout
+                logger.error(f"Crash startup timed out after {timeout} seconds")
+                return False
+            else:
+                # EOF
+                logger.error("Crash process terminated during startup")
+                return False
+
+        except Exception as e:
+            logger.error(f"Failed to start crash session: {e}")
+            return False
+    
+    def execute_command(self, command: str, timeout: int = 120) -> Tuple[str, str, int]:
+        """Execute a command in the crash session."""
+        if not self.is_active() or not self.process:
+            return "", "Session not active", 1
+
+        try:
+            logger.info(f"Executing crash command: {command}")
+
+            # Send command to crash process
+            self.process.sendline(command)
+
+            # Wait for prompt to return
+            expect_list = self.prompt_patterns + ['crash: .*', pexpect.TIMEOUT, pexpect.EOF]
+
+            index = self.process.expect(expect_list, timeout=timeout)
+
+            if index < len(self.prompt_patterns):
+                # Successfully got prompt back
+                output = self.process.before.decode('utf-8', errors='ignore')
+                # Clean up the output by removing the command echo
+                lines = output.split('\n')
+                if lines and lines[0].strip() == command.strip():
+                    output = '\n'.join(lines[1:])
+                return output.strip(), "", 0
+            elif index == len(self.prompt_patterns):
+                # Error pattern matched
+                error_msg = self.process.after.decode('utf-8', errors='ignore')
+                return "", f"Crash error: {error_msg}", 1
+            elif index == len(self.prompt_patterns) + 1:
+                # Timeout
+                return "", f"Command '{command}' timed out after {timeout} seconds", 1
+            else:
+                # EOF - crash process died
+                self.active = False
+                return "", "Crash process terminated unexpectedly", 1
+
+        except Exception as e:
+            logger.error(f"Error executing command '{command}': {e}")
+            return "", str(e), 1
+    
+    def close(self):
+        """Close the crash session."""
+        if self.process:
+            try:
+                # Try to quit gracefully first
+                if self.active:
+                    try:
+                        self.process.sendline('quit')
+                        self.process.expect(pexpect.EOF, timeout=5)
+                    except:
+                        pass
+
+                # Force close if still alive
+                if self.process.isalive():
+                    self.process.terminate()
+                    if self.process.isalive():
+                        self.process.kill()
+
+            except Exception as e:
+                logger.error(f"Error closing session: {e}")
+            finally:
+                self.process = None
+        self.active = False
+
+
+class CrashSessionManager:
+    """Manages crash analysis sessions."""
+    
+    def __init__(self):
+        self.active_session: Optional[CrashSession] = None
+    
+    def start_session(self, crash_dump, kernel_file, timeout: int = 180) -> bool:
+        """Start a new crash analysis session."""
+        # Close existing session if any
+        if self.active_session:
+            self.close_session()
+
+        try:
+            logger.info(f"Starting crash session with dump: {crash_dump.name}, kernel: {kernel_file.name}")
+
+            # Create new session
+            session = CrashSession(str(crash_dump.path), str(kernel_file.path))
+
+            # Actually start the crash process
+            if session.start(timeout):
+                self.active_session = session
+                logger.info(f"Crash session started successfully: {session.session_id}")
+                return True
+            else:
+                logger.error("Failed to start crash process")
+                return False
+
+        except Exception as e:
+            logger.error(f"Failed to start crash session: {e}")
+            return False
+    
+    def execute_command(self, command: str, timeout: int = 120) -> Tuple[str, str, int]:
+        """Execute a command in the active session."""
+        if not self.active_session:
+            return "", "No active crash session", 1
+        
+        return self.active_session.execute_command(command, timeout)
+    
+    def is_session_active(self) -> bool:
+        """Check if there's an active session."""
+        return self.active_session is not None and self.active_session.is_active()
+    
+    def get_session_info(self) -> dict:
+        """Get information about the active session."""
+        if not self.active_session:
+            return {"active": False}
+        
+        return {
+            "active": True,
+            "session_id": self.active_session.session_id,
+            "dump_path": self.active_session.dump_path,
+            "kernel_path": self.active_session.kernel_path
+        }
+    
+    def close_session(self):
+        """Close the active session."""
+        if self.active_session:
+            logger.info(f"Closing crash session: {self.active_session.session_id}")
+            self.active_session.close()
+            self.active_session = None