mcp-proxy-adapter 6.9.43__py3-none-any.whl

mcp_proxy_adapter/core/errors.py

@@ -0,0 +1,276 @@
+"""
+Module for defining errors and exceptions for the microservice.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+
+class MicroserviceError(Exception):
+    """
+    Base class for all microservice exceptions.
+
+    Attributes:
+        message: Error message.
+        code: Error code.
+        data: Additional error data.
+    """
+
+    def __init__(
+        self, message: str, code: int = -32000, data: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Initialize the error.
+
+        Args:
+            message: Error message.
+            code: Error code according to JSON-RPC standard.
+            data: Additional error data.
+        """
+        self.message = message
+        self.code = code
+        self.data = data or {}
+        super().__init__(message)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert error to dictionary format."""
+        result = {
+            "code": self.code,
+            "message": self.message
+        }
+        if self.data:
+            result["data"] = self.data
+        return result
+
+
+
+class ParseError(MicroserviceError):
+    """
+    Error while parsing JSON request.
+    JSON-RPC Error code: -32700
+    """
+
+    def __init__(
+        self, message: str = "Parse error", data: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, code=-32700, data=data)
+
+
+class InvalidRequestError(MicroserviceError):
+    """
+    Invalid JSON-RPC request format.
+    JSON-RPC Error code: -32600
+    """
+
+    def __init__(
+        self, message: str = "Invalid Request", data: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, code=-32600, data=data)
+
+
+class MethodNotFoundError(MicroserviceError):
+    """
+    Method not found error.
+    JSON-RPC Error code: -32601
+    """
+
+    def __init__(
+        self, message: str = "Method not found", data: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, code=-32601, data=data)
+
+
+class InvalidParamsError(MicroserviceError):
+    """
+    Invalid method parameters.
+    JSON-RPC Error code: -32602
+    """
+
+    def __init__(
+        self, message: str = "Invalid params", data: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, code=-32602, data=data)
+
+
+class InternalError(MicroserviceError):
+    """
+    Internal server error.
+    JSON-RPC Error code: -32603
+    """
+
+    def __init__(
+        self, message: str = "Internal error", data: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, code=-32603, data=data)
+
+
+class ValidationError(MicroserviceError):
+    """
+    Input data validation error.
+    JSON-RPC Error code: -32602 (using Invalid params code)
+    """
+
+    def __init__(
+        self, message: str = "Validation error", data: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, code=-32602, data=data)
+
+
+class CommandError(MicroserviceError):
+    """
+    Command execution error.
+    JSON-RPC Error code: -32000 (server error)
+    """
+
+    def __init__(
+        self,
+        message: str = "Command execution error",
+        data: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message, code=-32000, data=data)
+
+
+class NotFoundError(MicroserviceError):
+    """
+    "Not found" error.
+    JSON-RPC Error code: -32601 (using Method not found code)
+    """
+
+    def __init__(
+        self, message: str = "Resource not found", data: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, code=-32601, data=data)
+
+
+class ConfigurationError(MicroserviceError):
+    """
+    Configuration error.
+    JSON-RPC Error code: -32603 (using Internal error code)
+    """
+
+    def __init__(
+        self,
+        message: str = "Configuration error",
+        data: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message, code=-32603, data=data)
+
+
+class AuthenticationError(MicroserviceError):
+    """
+    Authentication error.
+    JSON-RPC Error code: -32001 (server error)
+    """
+
+    def __init__(
+        self,
+        message: str = "Authentication error",
+        data: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message, code=-32001, data=data)
+
+
+class AuthorizationError(MicroserviceError):
+    """
+    Authorization error.
+    JSON-RPC Error code: -32002 (server error)
+    """
+
+    def __init__(
+        self,
+        message: str = "Authorization error",
+        data: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message, code=-32002, data=data)
+
+
+class TimeoutError(MicroserviceError):
+    """
+    Timeout error.
+    JSON-RPC Error code: -32003 (server error)
+    """
+
+    def __init__(
+        self, message: str = "Timeout error", data: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, code=-32003, data=data)
+
+
+
+
+@dataclass
+class ValidationResult:
+    """Result of configuration validation."""
+    level: str  # "error", "warning", "info"
+    message: str
+    section: Optional[str] = None
+    key: Optional[str] = None
+    suggestion: Optional[str] = None
+
+
+class ConfigError(MicroserviceError):
+    """Configuration validation error."""
+    
+    def __init__(self, message: str, validation_results: Optional[List[ValidationResult]] = None):
+        """
+        Initialize configuration error.
+        
+        Args:
+            message: Error message
+            validation_results: List of validation results that caused the error
+        """
+        super().__init__(message, code=-32001, data={"type": "configuration_error"})
+        self.validation_results = validation_results or []
+    
+
+
+class MissingConfigKeyError(ConfigError):
+    """Missing required configuration key."""
+    
+    def __init__(self, key: str, section: str = None):
+        location = f"{section}.{key}" if section else key
+        message = f"Required configuration key '{location}' is missing"
+        super().__init__(message)
+        self.key = key
+        self.section = section
+
+
+class InvalidConfigValueError(ConfigError):
+    """Invalid configuration value."""
+    
+    def __init__(self, key: str, value: Any, expected_type: str, section: str = None):
+        location = f"{section}.{key}" if section else key
+        message = f"Invalid value for '{location}': got {type(value).__name__}, expected {expected_type}"
+        super().__init__(message)
+        self.key = key
+        self.section = section
+        self.value = value
+        self.expected_type = expected_type
+
+
+class MissingConfigSectionError(ConfigError):
+    """Missing required configuration section."""
+    
+    def __init__(self, section: str):
+        message = f"Required configuration section '{section}' is missing"
+        super().__init__(message)
+        self.section = section
+
+
+class MissingConfigFileError(ConfigError):
+    """Missing configuration file."""
+    
+    def __init__(self, file_path: str):
+        message = f"Configuration file '{file_path}' does not exist"
+        super().__init__(message)
+        self.file_path = file_path
+
+
+class InvalidConfigFileError(ConfigError):
+    """Invalid configuration file format."""
+    
+    def __init__(self, file_path: str, reason: str):
+        message = f"Invalid configuration file '{file_path}': {reason}"
+        super().__init__(message)
+        self.file_path = file_path
+        self.reason = reason

mcp_proxy_adapter/core/job_manager.py

@@ -0,0 +1,54 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Simple in-memory job manager for long-running demo commands.
+Not for production use.
+"""
+
+import asyncio
+import uuid
+from typing import Any, Dict, Optional, Awaitable
+
+
+class JobRecord:
+    def __init__(self, task: asyncio.Task):
+        self.task = task
+        self.status = "running"
+        self.result: Optional[Any] = None
+        self.error: Optional[str] = None
+
+
+_jobs: Dict[str, JobRecord] = {}
+
+
+def enqueue_coroutine(coro: Awaitable[Any]) -> str:
+    job_id = str(uuid.uuid4())
+    task = asyncio.create_task(_run_job(job_id, coro))
+    _jobs[job_id] = JobRecord(task)
+    return job_id
+
+
+async def _run_job(job_id: str, coro):
+    rec = _jobs[job_id]
+    try:
+        rec.result = await coro
+        rec.status = "completed"
+    except Exception as exc:  # noqa: BLE001
+        rec.error = str(exc)
+        rec.status = "failed"
+
+
+def get_job_status(job_id: str) -> Dict[str, Any]:
+    rec = _jobs.get(job_id)
+    if not rec:
+        return {"exists": False}
+    return {
+        "exists": True,
+        "status": rec.status,
+        "done": rec.task.done(),
+        "result": rec.result,
+        "error": rec.error,
+    }
+
+

mcp_proxy_adapter/core/logging.py

@@ -0,0 +1,250 @@
+"""
+Module for configuring logging in the microservice.
+"""
+
+import logging
+import os
+import sys
+import uuid
+from logging.handlers import RotatingFileHandler
+from typing import Optional
+
+
+class CustomFormatter(logging.Formatter):
+    """
+    Custom formatter for logs with colored output in console.
+    """
+
+    grey = "\x1b[38;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format_str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    FORMATS = {
+        logging.DEBUG: grey + format_str + reset,
+        logging.INFO: grey + format_str + reset,
+        logging.WARNING: yellow + format_str + reset,
+        logging.ERROR: red + format_str + reset,
+        logging.CRITICAL: bold_red + format_str + reset,
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+class RequestContextFilter(logging.Filter):
+    """
+    Filter for adding request context to logs.
+    """
+
+    def __init__(self, request_id: Optional[str] = None):
+        super().__init__()
+        self.request_id = request_id
+
+
+class RequestLogger:
+    """
+    Logger class for logging requests with context.
+    """
+
+    def __init__(self, logger_name: str, request_id: Optional[str] = None):
+        """
+        Initialize request get_global_logger().
+
+        Args:
+            logger_name: Logger name.
+            request_id: Request identifier.
+        """
+        self.logger = logging.getLogger(logger_name)
+        self.request_id = request_id or str(uuid.uuid4())
+        self.filter = RequestContextFilter(self.request_id)
+        get_global_logger().addFilter(self.filter)
+
+    def debug(self, msg: str, *args, **kwargs):
+        """Log message with DEBUG level."""
+        get_global_logger().debug(f"[{self.request_id}] {msg}", *args, **kwargs)
+
+    def info(self, msg: str, *args, **kwargs):
+        """Log message with INFO level."""
+        get_global_logger().info(f"[{self.request_id}] {msg}", *args, **kwargs)
+
+    def warning(self, msg: str, *args, **kwargs):
+        """Log message with WARNING level."""
+        get_global_logger().warning(f"[{self.request_id}] {msg}", *args, **kwargs)
+
+    def error(self, msg: str, *args, **kwargs):
+        """Log message with ERROR level."""
+        get_global_logger().error(f"[{self.request_id}] {msg}", *args, **kwargs)
+
+    def exception(self, msg: str, *args, **kwargs):
+        """Log exception with traceback."""
+        get_global_logger().exception(f"[{self.request_id}] {msg}", *args, **kwargs)
+
+    def critical(self, msg: str, *args, **kwargs):
+        """Log message with CRITICAL level."""
+        get_global_logger().critical(f"[{self.request_id}] {msg}", *args, **kwargs)
+
+
+def setup_logging(
+    level: Optional[str] = None,
+    log_file: Optional[str] = None,
+    max_bytes: Optional[int] = None,
+    backup_count: Optional[int] = None,
+    rotation_type: Optional[str] = None,
+    rotation_when: Optional[str] = None,
+    rotation_interval: Optional[int] = None,
+) -> logging.Logger:
+    """
+    Configure logging for the microservice.
+
+    Args:
+        level: Logging level. By default, taken from configuration.
+        log_file: Path to log file. By default, taken from configuration.
+        max_bytes: Maximum log file size in bytes. By default, taken from configuration.
+        backup_count: Number of rotation files. By default, taken from configuration.
+        rotation_type: Type of log rotation ('size' or 'time'). By default, taken from configuration.
+        rotation_when: Time unit for rotation (D, H, M, S). By default, taken from configuration.
+        rotation_interval: Interval for rotation. By default, taken from configuration.
+
+    Returns:
+        Configured get_global_logger().
+    """
+    # Use provided parameters or defaults
+    level = level or "INFO"
+    log_file = log_file
+    rotation_type = rotation_type or "size"
+    log_dir = "./logs"
+    log_file_name = "mcp_proxy_adapter.log"
+    error_log_file = "mcp_proxy_adapter_error.log"
+    access_log_file = "mcp_proxy_adapter_access.log"
+
+    # Get rotation settings
+    max_file_size_str = "10MB"
+    backup_count = backup_count or 5
+
+    # Parse max file size (e.g., "10MB" -> 10 * 1024 * 1024)
+    max_bytes = max_bytes or _parse_file_size(max_file_size_str)
+
+    # Get format settings
+    log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    date_format = "%Y-%m-%d %H:%M:%S"
+
+    # Get output settings
+    console_output = True
+    file_output = True
+
+    # Convert string logging level to constant
+    numeric_level = getattr(logging, level.upper(), None)
+    if not isinstance(numeric_level, int):
+        numeric_level = logging.INFO
+
+    # Create root logger
+    logger = logging.getLogger("mcp_proxy_adapter")
+    logger.setLevel(numeric_level)
+    logger.handlers = []  # Clear handlers in case of repeated call
+
+    # Create formatter
+    formatter = logging.Formatter(log_format, date_format)
+
+    # Create console handler if enabled
+    if console_output:
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(numeric_level)
+        console_handler.setFormatter(CustomFormatter())
+        logger.addHandler(console_handler)
+
+    # Create file handlers if file output is enabled
+    if file_output and log_dir:
+        # Create directory for log files if it doesn't exist
+        if not os.path.exists(log_dir):
+            os.makedirs(log_dir, exist_ok=True)
+
+        # Main log file
+        if log_file_name:
+            main_log_path = os.path.join(log_dir, log_file_name)
+            main_handler = RotatingFileHandler(
+                main_log_path,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding="utf-8",
+            )
+            main_handler.setLevel(numeric_level)
+            main_handler.setFormatter(formatter)
+            logger.addHandler(main_handler)
+
+        # Error log file
+        if error_log_file:
+            error_log_path = os.path.join(log_dir, error_log_file)
+            error_handler = RotatingFileHandler(
+                error_log_path,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding="utf-8",
+            )
+            error_handler.setLevel(logging.ERROR)
+            error_handler.setFormatter(formatter)
+            logger.addHandler(error_handler)
+
+        # Access log file (for HTTP requests)
+        if access_log_file:
+            access_log_path = os.path.join(log_dir, access_log_file)
+            access_handler = RotatingFileHandler(
+                access_log_path,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding="utf-8",
+            )
+            access_handler.setLevel(logging.INFO)
+            access_handler.setFormatter(formatter)
+            logger.addHandler(access_handler)
+
+    # Configure loggers for external libraries
+    log_levels = {}
+    for logger_name, logger_level in log_levels.items():
+        lib_logger = logging.getLogger(logger_name)
+        lib_logger.setLevel(getattr(logging, logger_level.upper(), logging.INFO))
+
+    return logger
+
+
+def _parse_file_size(size_str) -> int:
+    """
+    Parse file size string to bytes.
+
+    Args:
+        size_str: Size string (e.g., "10MB", "1GB", "100KB") or int
+
+    Returns:
+        Size in bytes
+    """
+    # If it's already an int, return it
+    if isinstance(size_str, int):
+        return size_str
+
+    # Convert to string and parse
+    size_str = str(size_str).upper()
+    if size_str.endswith("KB"):
+        return int(size_str[:-2]) * 1024
+    elif size_str.endswith("MB"):
+        return int(size_str[:-2]) * 1024 * 1024
+    elif size_str.endswith("GB"):
+        return int(size_str[:-2]) * 1024 * 1024 * 1024
+    else:
+        # Assume bytes if no unit specified
+        return int(size_str)
+
+
+# Global get_global_logger() for use throughout the application
+# Initialize lazily to avoid import-time errors
+logger = None
+
+def get_global_logger():
+    """Get the global logger, initializing it if necessary."""
+    global logger
+    if logger is None:
+        logger = setup_logging()
+    return logger