mcli-framework 7.0.0__py3-none-any.whl

mcli/lib/services/redis_service.py

@@ -0,0 +1,387 @@
+"""
+Redis Service Manager - Manages Redis as a background process
+"""
+
+import asyncio
+import os
+import signal
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import psutil
+import redis.asyncio as redis
+
+from mcli.lib.logger.logger import get_logger
+from mcli.workflow.daemon.async_process_manager import AsyncProcessManager, ProcessStatus
+
+logger = get_logger(__name__)
+
+
+class RedisService:
+    """
+    Manages Redis server as a background process integrated with MCLI's job system
+    """
+
+    def __init__(
+        self,
+        port: int = 6379,
+        host: str = "127.0.0.1",
+        data_dir: Optional[Path] = None,
+        process_manager: Optional[AsyncProcessManager] = None,
+    ):
+        self.port = port
+        self.host = host
+        self.data_dir = data_dir or Path.home() / ".mcli" / "redis-data"
+        self.config_file = None
+        self.process_manager = process_manager or AsyncProcessManager()
+        self.process_id = None
+        self.redis_client = None
+
+        # Ensure data directory exists
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+    async def start(self) -> bool:
+        """Start Redis server as a managed background process"""
+        try:
+            # Check if Redis is already running on this port
+            if await self.is_running():
+                logger.info(f"Redis already running on {self.host}:{self.port}")
+                return True
+
+            # Find Redis server executable
+            redis_server_path = self._find_redis_server()
+            if not redis_server_path:
+                logger.error("Redis server not found. Install with: brew install redis")
+                return False
+
+            # Generate Redis configuration
+            config_file = await self._generate_config()
+
+            # Start Redis process through the process manager
+            command_args = [str(redis_server_path), str(config_file)]
+
+            logger.info(f"Starting Redis server: {' '.join(command_args)}")
+
+            self.process_id = await self.process_manager.start_process(
+                name="redis-server",
+                command=str(redis_server_path),
+                args=command_args[1:],  # Skip the executable name
+                working_dir=str(self.data_dir),
+                environment={"REDIS_PORT": str(self.port)},
+            )
+
+            # Wait a moment for startup
+            await asyncio.sleep(1)
+
+            # Verify Redis is running
+            if await self.is_running():
+                logger.info(f"✅ Redis server started successfully on {self.host}:{self.port}")
+                logger.info(f"   Process ID: {self.process_id}")
+                logger.info(f"   Data directory: {self.data_dir}")
+                return True
+            else:
+                logger.error("Failed to start Redis server")
+                return False
+
+        except Exception as e:
+            logger.error(f"Error starting Redis server: {e}")
+            return False
+
+    async def stop(self) -> bool:
+        """Stop Redis server"""
+        try:
+            if self.process_id:
+                # Use process manager to stop cleanly
+                success = await self.process_manager.stop_process(self.process_id)
+                if success:
+                    logger.info("✅ Redis server stopped successfully")
+                    self.process_id = None
+                    return True
+                else:
+                    logger.warning("Process manager couldn't stop Redis, trying direct approach")
+
+            # Fallback: find and stop Redis process directly
+            return await self._stop_redis_direct()
+
+        except Exception as e:
+            logger.error(f"Error stopping Redis server: {e}")
+            return False
+
+    async def restart(self) -> bool:
+        """Restart Redis server"""
+        logger.info("Restarting Redis server...")
+        await self.stop()
+        await asyncio.sleep(1)
+        return await self.start()
+
+    async def is_running(self) -> bool:
+        """Check if Redis server is running and accepting connections"""
+        try:
+            if not self.redis_client:
+                self.redis_client = redis.Redis(
+                    host=self.host,
+                    port=self.port,
+                    decode_responses=True,
+                    socket_connect_timeout=2,
+                    socket_timeout=2,
+                )
+
+            await self.redis_client.ping()
+            return True
+        except (redis.ConnectionError, redis.TimeoutError, asyncio.TimeoutError):
+            return False
+        except Exception as e:
+            logger.debug(f"Redis connection check failed: {e}")
+            return False
+
+    async def get_status(self) -> Dict[str, Any]:
+        """Get detailed Redis server status"""
+        status = {
+            "running": False,
+            "host": self.host,
+            "port": self.port,
+            "data_dir": str(self.data_dir),
+            "process_id": self.process_id,
+            "process_status": None,
+            "memory_usage": None,
+            "connected_clients": None,
+            "uptime": None,
+        }
+
+        # Check if running
+        status["running"] = await self.is_running()
+
+        if not status["running"]:
+            return status
+
+        try:
+            # Get process information from process manager
+            if self.process_id:
+                process_info = await self.process_manager.get_process_info(self.process_id)
+                if process_info:
+                    status["process_status"] = process_info.status.value
+
+            # Get Redis server info
+            if self.redis_client:
+                info = await self.redis_client.info()
+                status.update(
+                    {
+                        "memory_usage": info.get("used_memory_human", "unknown"),
+                        "connected_clients": info.get("connected_clients", 0),
+                        "uptime": info.get("uptime_in_seconds", 0),
+                        "version": info.get("redis_version", "unknown"),
+                        "total_commands": info.get("total_commands_processed", 0),
+                        "keyspace_hits": info.get("keyspace_hits", 0),
+                        "keyspace_misses": info.get("keyspace_misses", 0),
+                    }
+                )
+
+        except Exception as e:
+            logger.debug(f"Failed to get Redis status details: {e}")
+
+        return status
+
+    async def get_connection_url(self) -> str:
+        """Get Redis connection URL"""
+        return f"redis://{self.host}:{self.port}"
+
+    async def test_connection(self) -> Dict[str, Any]:
+        """Test Redis connection and performance"""
+        if not await self.is_running():
+            return {"status": "failed", "error": "Redis not running"}
+
+        try:
+            start_time = time.perf_counter()
+
+            # Test basic operations
+            test_key = "mcli:test:connection"
+            await self.redis_client.set(test_key, "test_value", ex=10)
+            value = await self.redis_client.get(test_key)
+            await self.redis_client.delete(test_key)
+
+            latency = (time.perf_counter() - start_time) * 1000  # ms
+
+            return {
+                "status": "success",
+                "latency_ms": round(latency, 2),
+                "connection_url": await self.get_connection_url(),
+                "test_result": value == "test_value",
+            }
+
+        except Exception as e:
+            return {
+                "status": "failed",
+                "error": str(e),
+                "connection_url": await self.get_connection_url(),
+            }
+
+    def _find_redis_server(self) -> Optional[Path]:
+        """Find Redis server executable"""
+        possible_paths = [
+            "/opt/homebrew/bin/redis-server",  # Homebrew on Apple Silicon
+            "/usr/local/bin/redis-server",  # Homebrew on Intel
+            "/usr/bin/redis-server",  # System install
+            Path.home() / ".local/bin/redis-server",  # Local install
+        ]
+
+        # Check PATH first
+        try:
+            result = subprocess.run(
+                ["which", "redis-server"], capture_output=True, text=True, timeout=5
+            )
+            if result.returncode == 0:
+                path = Path(result.stdout.strip())
+                if path.exists():
+                    return path
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+
+        # Check known locations
+        for path in possible_paths:
+            if isinstance(path, str):
+                path = Path(path)
+            if path.exists():
+                return path
+
+        return None
+
+    async def _generate_config(self) -> Path:
+        """Generate Redis configuration file"""
+        config_content = f"""
+# MCLI Redis Configuration
+port {self.port}
+bind {self.host}
+dir {self.data_dir}
+
+# Performance settings
+save 60 1000
+stop-writes-on-bgsave-error no
+rdbcompression yes
+rdbchecksum yes
+dbfilename mcli-redis.rdb
+
+# Memory settings  
+maxmemory-policy allkeys-lru
+maxmemory 256mb
+
+# Logging
+loglevel notice
+logfile {self.data_dir}/redis.log
+
+# Security (basic)
+protected-mode yes
+
+# Disable potentially dangerous commands in production
+rename-command FLUSHDB ""
+rename-command FLUSHALL ""
+rename-command DEBUG ""
+
+# Client settings
+timeout 300
+tcp-keepalive 300
+
+# Persistence
+appendonly yes
+appendfilename "mcli-redis.aof"
+appendfsync everysec
+no-appendfsync-on-rewrite no
+auto-aof-rewrite-percentage 100
+auto-aof-rewrite-min-size 64mb
+"""
+
+        config_file = self.data_dir / "redis.conf"
+        config_file.write_text(config_content.strip())
+        self.config_file = config_file
+
+        logger.info(f"Generated Redis config: {config_file}")
+        return config_file
+
+    async def _stop_redis_direct(self) -> bool:
+        """Stop Redis by finding process directly"""
+        try:
+            # Find Redis processes
+            redis_processes = []
+            for proc in psutil.process_iter(["pid", "name", "cmdline"]):
+                try:
+                    if proc.info["name"] == "redis-server":
+                        # Check if it's our instance by port
+                        cmdline = proc.info.get("cmdline", [])
+                        if any(str(self.port) in arg for arg in cmdline):
+                            redis_processes.append(proc)
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    continue
+
+            if not redis_processes:
+                logger.info("No Redis processes found to stop")
+                return True
+
+            # Stop processes gracefully
+            for proc in redis_processes:
+                try:
+                    logger.info(f"Stopping Redis process {proc.pid}")
+                    proc.send_signal(signal.SIGTERM)
+                except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
+                    logger.debug(f"Could not stop process {proc.pid}: {e}")
+
+            # Wait for graceful shutdown
+            await asyncio.sleep(2)
+
+            # Force kill if still running
+            for proc in redis_processes:
+                try:
+                    if proc.is_running():
+                        logger.warning(f"Force killing Redis process {proc.pid}")
+                        proc.kill()
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    pass
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to stop Redis directly: {e}")
+            return False
+
+    async def cleanup(self):
+        """Cleanup resources"""
+        if self.redis_client:
+            await self.redis_client.close()
+        await self.stop()
+
+
+# Global Redis service instance
+_redis_service = None
+
+
+async def get_redis_service() -> RedisService:
+    """Get or create global Redis service instance"""
+    global _redis_service
+    if _redis_service is None:
+        _redis_service = RedisService()
+    return _redis_service
+
+
+async def ensure_redis_running() -> bool:
+    """Ensure Redis is running, start if needed"""
+    service = await get_redis_service()
+
+    if await service.is_running():
+        logger.info("Redis already running")
+        return True
+
+    logger.info("Starting Redis service...")
+    return await service.start()
+
+
+async def get_redis_connection() -> Optional[redis.Redis]:
+    """Get Redis connection, starting service if needed"""
+    service = await get_redis_service()
+
+    if not await service.is_running():
+        success = await service.start()
+        if not success:
+            return None
+
+    return redis.Redis(host=service.host, port=service.port, decode_responses=True)

mcli/lib/shell/shell.py

@@ -0,0 +1,137 @@
+import json
+import logging
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from mcli.lib.logger.logger import get_logger, register_subprocess
+
+logger = get_logger(__name__)
+
+
+def shell_exec(script_path: str, function_name: str, *args) -> Dict[str, Any]:
+    """Execute a shell script function with security checks and better error handling"""
+    # Validate script path
+    script_path = Path(script_path).resolve()
+    if not script_path.exists():
+        raise FileNotFoundError(f"Script not found: {script_path}")
+
+    # Prepare the full command with the shell script, function name, and arguments
+    command = [str(script_path), function_name]
+    result = {"success": False, "stdout": "", "stderr": ""}
+    logger.info(f"Running command: {command}")
+    try:
+        # Run the shell script with the function name and arguments
+        proc = subprocess.Popen(
+            command + list(args), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+        )
+
+        # Register the process for system monitoring
+        register_subprocess(proc)
+
+        # Wait for the process to complete and get output
+        stdout, stderr = proc.communicate()
+
+        # Check return code
+        if proc.returncode != 0:
+            raise subprocess.CalledProcessError(proc.returncode, command, stdout, stderr)
+
+        # Store the result for later reference
+        result = subprocess.CompletedProcess(command, proc.returncode, stdout, stderr)
+
+        # Output from the shell script
+        if result.stdout:
+            logger.info(f"Script output stdout:\n{result.stdout}")
+
+        if result.stderr:
+            logger.info(f"Script output stderr:\n{result.stderr}")
+        # return output  # Should contain the "result" key with the list of files
+    except subprocess.CalledProcessError as e:
+        logger.info(f"Command failed with error: {e}")
+        logger.info(f"Standard Output: {e.stdout}")
+        logger.info(f"Error Output: {e.stderr}")
+    except json.JSONDecodeError as e:
+        logger.info(f"Failed to decode JSON: {e}")
+        logger.info(f"Raw Output: {result.stdout.strip() if result else 'No output'}")
+    return None
+
+
+def get_shell_script_path(command: str, command_path: str):
+    # Get the path to the shell script
+    base_dir = os.path.dirname(os.path.realpath(command_path))
+    scripts_path = f"{base_dir}/scripts/{command}.sh"
+    return scripts_path
+
+
+def shell_recurse(root_path):
+    """
+    Recursively applies a given function to all files in the directory tree starting from root_path.
+
+    :param func: function, a function that takes a file path as its argument and executes on the file
+    :param root_path: str, the root directory from which to start applying the function
+    """
+    # Check if the current root_path is a directory
+    if os.path.isdir(root_path):
+        # List all entries in the directory
+        for entry in os.listdir(root_path):
+            # Construct the full path
+            full_path = os.path.join(root_path, entry)
+            # Recursively apply the function if it's a directory
+            shell_recurse(full_path, shell_exec)
+    else:
+        # If it's a file, apply the function
+        shell_exec(root_path)
+
+
+def is_executable_available(executable):
+    return shutil.which(executable) is not None
+
+
+def fatal_error(msg):
+    logger.critical(msg + " Unable to recover from the error, exiting.")
+    if not logger.isEnabledFor(logging.DEBUG):
+        logger.error(
+            "Debug output may help you to fix this issue or will be useful for maintainers of this tool."
+            " Please try to rerun tool with `-d` flag to enable debug output"
+        )
+    sys.exit(1)
+
+
+def execute_os_command(command, fail_on_error=True, stdin=None):
+    logger.debug("Executing command '%s'", command)
+    process = subprocess.Popen(
+        command,
+        shell=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        stdin=subprocess.PIPE,
+    )
+
+    # Register the process for system monitoring
+    register_subprocess(process)
+
+    if stdin is not None:
+        stdin = stdin.encode()
+    stdout, stderr = [stream.decode().strip() for stream in process.communicate(input=stdin)]
+
+    logger.debug("rc    > %s", process.returncode)
+    if stdout:
+        logger.debug("stdout> %s", stdout)
+    if stderr:
+        logger.debug("stderr> %s", stderr)
+
+    if process.returncode:
+        msg = f'Failed to execute command "{command}", error:\n{stdout}{stderr}'
+        if fail_on_error:
+            fatal_error(msg)
+        else:
+            raise RuntimeError(msg)
+
+    return stdout
+
+
+def cli_exec():
+    pass

mcli/lib/toml/toml.py

@@ -0,0 +1,33 @@
+def read_from_toml(file_path: str, key: str):
+    """
+    Reads a TOML file and returns the value associated with the provided key.
+
+    Args:
+        file_path (str): The path to the TOML file.
+        key (str): The key whose value will be retrieved.
+
+    Returns:
+        The value corresponding to the key if it exists in the TOML file, or None otherwise.
+
+    Raises:
+        FileNotFoundError: If the specified file does not exist.
+        tomllib.TOMLDecodeError or toml.TomlDecodeError: If the file contains invalid TOML.
+    """
+    try:
+        # Attempt to use the built-in tomllib (available in Python 3.11+)
+        import tomllib
+
+        with open(file_path, "rb") as file:
+            config_data = tomllib.load(file)
+    except ModuleNotFoundError:
+        # Fall back to the third-party 'toml' package for earlier Python versions.
+        import toml
+
+        with open(file_path, "r", encoding="utf-8") as file:
+            config_data = toml.load(file)
+
+    # Return the value for the provided key, or None if the key is not found.
+    return config_data.get(key)
+
+
+__all__ = ["read_from_toml"]

mcli/lib/ui/styling.py

@@ -0,0 +1,47 @@
+from rich.box import HEAVY, ROUNDED
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+
+def info(message: str) -> None:
+    """Display an informational message with enhanced styling.
+
+    Args:
+        message: The text to display
+    """
+    panel = Panel(f"ℹ️  {message}", box=ROUNDED, border_style="bright_cyan", padding=(0, 1))
+    console.print(panel)
+
+
+def warning(message: str) -> None:
+    """Display a warning message with enhanced styling."""
+    panel = Panel(f"⚠️  {message}", box=ROUNDED, border_style="bright_yellow", padding=(0, 1))
+    console.print(panel)
+
+
+def success(message: str) -> None:
+    """Display a success message with enhanced styling."""
+    panel = Panel(f"✅ {message}", box=ROUNDED, border_style="bright_green", padding=(0, 1))
+    console.print(panel)
+
+
+def error(message: str) -> None:
+    """Display an error message with enhanced styling."""
+    panel = Panel(f"❌ {message}", box=HEAVY, border_style="bright_red", padding=(0, 1))
+    console.print(panel)
+
+
+def celebrate(message: str) -> None:
+    """Display a celebration message with extra flair."""
+    panel = Panel(
+        f"🎉 {message} 🎉",
+        title="🌟 SUCCESS 🌟",
+        title_align="center",
+        box=HEAVY,
+        border_style="bright_magenta",
+        padding=(1, 2),
+    )
+    console.print(panel)