mcp-proxy-adapter 2.0.1__py3-none-any.whl → 6.9.50__py3-none-any.whl

mcp_proxy_adapter/core/server_engine.py

@@ -0,0 +1,217 @@
+"""
+Server Engine Abstraction
+
+This module provides an abstraction layer for the hypercorn ASGI server engine,
+providing full mTLS support and SSL capabilities.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, Any
+
+from .logging import get_global_logger
+
+logger = logging.getLogger(__name__)
+
+
+class ServerEngine(ABC):
+    """
+    Abstract base class for server engines.
+
+    This class defines the interface that all server engines must implement,
+    allowing the framework to work with different ASGI servers transparently.
+    """
+
+    @abstractmethod
+    def get_name(self) -> str:
+        """Get the name of the server engine."""
+        pass
+
+    @abstractmethod
+    def get_supported_features(self) -> Dict[str, bool]:
+        """
+        Get supported features of this server engine.
+
+        Returns:
+            Dictionary mapping feature names to boolean support status
+        """
+        pass
+
+    def validate_config(self, config: Dict[str, Any]) -> bool:
+        """
+        Validate configuration for this engine.
+
+        Args:
+            config: Configuration dictionary to validate
+
+        Returns:
+            True if configuration is valid, False otherwise
+        """
+        # Default implementation: always valid
+        return True
+
+    def get_config_schema(self) -> Dict[str, Any]:
+        """
+        Get configuration schema for this engine.
+
+        Returns:
+            Dictionary describing the configuration schema
+        """
+        # Default implementation: empty schema
+        return {}
+
+    def run_server(self, app: Any, config: Dict[str, Any]) -> None:
+        """
+        Run the server with the given application and configuration.
+
+        Args:
+            app: ASGI application
+            config: Server configuration
+
+        Raises:
+            NotImplementedError: This method must be implemented by subclasses
+        """
+        raise NotImplementedError("run_server must be implemented by subclasses")
+
+
+class HypercornEngine(ServerEngine):
+    """
+    Hypercorn server engine implementation.
+
+    Provides full mTLS support and better SSL capabilities.
+    """
+
+    def get_name(self) -> str:
+        return "hypercorn"
+
+    def get_supported_features(self) -> Dict[str, bool]:
+        return {
+            "ssl_tls": True,
+            "mtls_client_certs": True,  # Full support
+            "ssl_scope_info": True,  # SSL info in request scope
+            "client_cert_verification": True,
+            "websockets": True,
+            "http2": True,
+            "reload": True,
+        }
+
+    def run_server(self, app: Any, config: Dict[str, Any]) -> None:
+        """
+        Run the server with the given application and configuration.
+
+        Args:
+            app: ASGI application
+            config: Server configuration dictionary containing:
+                - host: Server host (default: "127.0.0.1")
+                - port: Server port (default: 8000)
+                - certfile: SSL certificate file (optional)
+                - keyfile: SSL key file (optional)
+                - ca_certs: CA certificate file (optional)
+                - verify_mode: SSL verification mode (optional)
+                - check_hostname: Enable hostname checking (optional)
+                - log_level: Logging level (optional)
+                - reload: Enable auto-reload (optional)
+        """
+        import asyncio
+        import hypercorn.asyncio
+        from hypercorn.config import Config as HypercornConfig
+
+        # Create hypercorn configuration
+        hypercorn_config = HypercornConfig()
+        hypercorn_config.bind = [f"{config.get('host', '127.0.0.1')}:{config.get('port', 8000)}"]
+
+        # Apply SSL configuration if present
+        if "certfile" in config:
+            hypercorn_config.certfile = config["certfile"]
+        if "keyfile" in config:
+            hypercorn_config.keyfile = config["keyfile"]
+        if "ca_certs" in config:
+            hypercorn_config.ca_certs = config["ca_certs"]
+        if "verify_mode" in config:
+            hypercorn_config.verify_mode = config["verify_mode"]
+        if "check_hostname" in config:
+            hypercorn_config.check_hostname = config["check_hostname"]
+
+        # Apply other settings
+        if "log_level" in config:
+            hypercorn_config.loglevel = config["log_level"].upper()
+        if "reload" in config:
+            hypercorn_config.reload = config["reload"]
+
+        # Try to set ALPN protocols for HTTP/2 support
+        try:
+            hypercorn_config.alpn_protocols = ["h2", "http/1.1"]
+        except Exception:
+            pass
+
+        # Run the server (blocking call)
+        # Note: This uses asyncio.run internally, so it will block until server stops
+        asyncio.run(hypercorn.asyncio.serve(app, hypercorn_config))
+
+
+class ServerEngineFactory:
+    """
+    Factory for creating server engines.
+
+    This class manages the creation and configuration of different server engines.
+    """
+
+    _engines: Dict[str, ServerEngine] = {}
+
+    @classmethod
+    def register_engine(cls, engine: ServerEngine) -> None:
+        """
+        Register a server engine.
+
+        Args:
+            engine: Server engine instance to register
+        """
+        cls._engines[engine.get_name()] = engine
+        get_global_logger().info(f"Registered server engine: {engine.get_name()}")
+
+    @classmethod
+    def get_engine(cls, engine_name: str) -> Optional[ServerEngine]:
+        """
+        Get a registered server engine by name.
+
+        Args:
+            engine_name: Name of the engine to retrieve
+
+        Returns:
+            ServerEngine instance if found, None otherwise
+        """
+        return cls._engines.get(engine_name)
+
+    @classmethod
+    def get_available_engines(cls) -> Dict[str, ServerEngine]:
+        """
+        Get all registered server engines.
+
+        Returns:
+            Dictionary mapping engine names to ServerEngine instances
+        """
+        return cls._engines.copy()
+
+    @classmethod
+    def initialize_default_engines(cls) -> None:
+        """Initialize default server engines."""
+        # Register hypercorn engine (only supported engine)
+        try:
+            import hypercorn  # noqa: F401
+
+            cls.register_engine(HypercornEngine())
+            get_global_logger().info(
+                "Hypercorn engine registered (full mTLS support available)"
+            )
+        except ImportError:
+            get_global_logger().error(
+                "Hypercorn not available - this is required for the framework"
+            )
+            raise
+
+
+# Initialize default engines
+ServerEngineFactory.initialize_default_engines()

mcp_proxy_adapter/core/settings.py

@@ -0,0 +1,260 @@
+"""
+Settings management for the MCP Proxy Adapter framework.
+Provides utilities for reading and managing framework settings from configuration.
+"""
+
+from mcp_proxy_adapter.config import config
+
+
+class Settings:
+    """
+    Settings management class for the framework.
+    Provides easy access to configuration values with type conversion and validation.
+    """
+
+    # Store custom settings as a class variable
+    _custom_settings: Dict[str, Any] = {}
+
+    @classmethod
+    def add_custom_settings(cls, settings: Dict[str, Any]) -> None:
+        """
+        Add custom settings to the settings manager.
+
+        Args:
+            settings: Dictionary with custom settings
+        """
+        cls._custom_settings.update(settings)
+
+    @classmethod
+    def get_custom_settings(cls) -> Dict[str, Any]:
+        """
+        Get all custom settings.
+
+        Returns:
+            Dictionary with all custom settings
+        """
+        return cls._custom_settings.copy()
+
+    @classmethod
+    def get_custom_setting_value(cls, key: str, default: Any = None) -> Any:
+        """
+        Get custom setting value.
+
+        Args:
+            key: Setting key
+            default: Default value if key not found
+
+        Returns:
+            Setting value
+        """
+        return cls._custom_settings.get(key, default)
+
+    @classmethod
+    def set_custom_setting_value(cls, key: str, value: Any) -> None:
+        """
+        Set custom setting value.
+
+        Args:
+            key: Setting key
+            value: Value to set
+        """
+        cls._custom_settings[key] = value
+
+    @classmethod
+    def clear_custom_settings(cls) -> None:
+        """
+        Clear all custom settings.
+        """
+        cls._custom_settings.clear()
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+    def get_custom_setting(key: str, default: Any = None) -> Any:
+        """
+        Get custom setting from configuration.
+
+        Args:
+            key: Configuration key in dot notation (e.g., "custom.feature_enabled")
+            default: Default value if key not found
+
+        Returns:
+            Configuration value
+        """
+        return config.get(key, default)
+
+    @staticmethod
+
+    @staticmethod
+    def set_custom_setting(key: str, value: Any) -> None:
+        """
+        Set custom setting in configuration.
+
+        Args:
+            key: Configuration key in dot notation
+            value: Value to set
+        """
+        config.set(key, value)
+
+    @staticmethod
+    def reload_config() -> None:
+        """
+        Reload configuration from file and environment variables.
+        """
+        config.load_config()
+
+
+class ServerSettings:
+    """
+    Server-specific settings helper.
+    """
+
+    @staticmethod
+    def get_host() -> str:
+        """Get server host."""
+        return config.get("server.host", "0.0.0.0")
+
+    @staticmethod
+    def get_port() -> int:
+        """Get server port."""
+        return config.get("server.port", 8000)
+
+    @staticmethod
+    def get_debug() -> bool:
+        """Get debug mode."""
+        return config.get("server.debug", False)
+
+
+class LoggingSettings:
+    """
+    Logging-specific settings helper.
+    """
+
+    @staticmethod
+    def get_level() -> str:
+        """Get logging level."""
+        return config.get("logging.level", "INFO")
+
+    @staticmethod
+    def get_log_dir() -> str:
+        """Get log directory."""
+        return config.get("logging.log_dir", "./logs")
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+
+    @staticmethod
+
+
+class CommandsSettings:
+    """
+    Commands-specific settings helper.
+    """
+
+    @staticmethod
+    def get_auto_discovery() -> bool:
+        """Get auto discovery setting."""
+        return config.get("commands.auto_discovery", True)
+
+    @staticmethod
+    def get_discovery_path() -> str:
+        """Get discovery path."""
+        return config.get("commands.discovery_path", "mcp_proxy_adapter.commands")
+
+    @staticmethod
+
+
+# Convenience functions for easy access
+
+
+
+
+
+
+
+
+
+
+def get_auto_discovery() -> bool:
+    """Get auto discovery setting."""
+    return CommandsSettings.get_auto_discovery()
+
+
+def get_discovery_path() -> str:
+    """Get discovery path."""
+    return CommandsSettings.get_discovery_path()
+
+
+
+
+
+
+
+
+def add_custom_settings(settings: Dict[str, Any]) -> None:
+    """
+    Add custom settings to the settings manager.
+
+    Args:
+        settings: Dictionary with custom settings
+    """
+    Settings.add_custom_settings(settings)
+
+
+def get_custom_settings() -> Dict[str, Any]:
+    """
+    Get all custom settings.
+
+    Returns:
+        Dictionary with all custom settings
+    """
+    return Settings.get_custom_settings()
+
+
+def get_custom_setting_value(key: str, default: Any = None) -> Any:
+    """
+    Get custom setting value.
+
+    Args:
+        key: Setting key
+        default: Default value if key not found
+
+    Returns:
+        Setting value
+    """
+    return Settings.get_custom_setting_value(key, default)
+
+
+def set_custom_setting_value(key: str, value: Any) -> None:
+    """
+    Set custom setting value.
+
+    Args:
+        key: Setting key
+        value: Value to set
+    """
+    Settings.set_custom_setting_value(key, value)
+
+
+def clear_custom_settings() -> None:
+    """
+    Clear all custom settings.
+    """
+    Settings.clear_custom_settings()

mcp_proxy_adapter/core/signal_handler.py

@@ -0,0 +1,107 @@
+"""
+Signal handler for graceful shutdown with proxy unregistration.
+
+This module provides signal handling for SIGTERM, SIGINT, and SIGHUP
+to ensure proper proxy unregistration before server shutdown.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import signal
+import threading
+from typing import Optional, Callable, Any
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class SignalHandler:
+    """
+    Signal handler for graceful shutdown with proxy unregistration.
+    """
+    
+    def __init__(self):
+        """Initialize signal handler."""
+        self._shutdown_callback: Optional[Callable] = None
+        self._shutdown_event = threading.Event()
+        self._original_handlers = {}
+        self._setup_signal_handlers()
+    
+    def set_shutdown_callback(self, callback: Callable):
+        """
+        Set callback function to be called during shutdown.
+        
+        Args:
+            callback: Function to call during shutdown
+        """
+        self._shutdown_callback = callback
+        get_global_logger().info("Shutdown callback set for signal handler")
+    
+    def _setup_signal_handlers(self):
+        """Setup signal handlers for graceful shutdown."""
+        # Handle SIGTERM (termination signal)
+        self._original_handlers[signal.SIGTERM] = signal.signal(
+            signal.SIGTERM, self._handle_shutdown_signal
+        )
+        
+        # Handle SIGINT (Ctrl+C)
+        self._original_handlers[signal.SIGINT] = signal.signal(
+            signal.SIGINT, self._handle_shutdown_signal
+        )
+        
+        # Handle SIGHUP (hangup signal)
+        self._original_handlers[signal.SIGHUP] = signal.signal(
+            signal.SIGHUP, self._handle_shutdown_signal
+        )
+        
+        get_global_logger().info("Signal handlers installed for SIGTERM, SIGINT, SIGHUP")
+    
+    
+    
+    def wait_for_shutdown(self, timeout: Optional[float] = None) -> bool:
+        """
+        Wait for shutdown signal.
+        
+        Args:
+            timeout: Maximum time to wait in seconds
+            
+        Returns:
+            True if shutdown signal received, False if timeout
+        """
+        return self._shutdown_event.wait(timeout)
+    
+    def is_shutdown_requested(self) -> bool:
+        """
+        Check if shutdown has been requested.
+        
+        Returns:
+            True if shutdown signal received
+        """
+        return self._shutdown_event.is_set()
+    
+
+
+# Global signal handler instance
+_signal_handler: Optional[SignalHandler] = None
+
+
+def get_signal_handler() -> SignalHandler:
+    """Get the global signal handler instance."""
+    global _signal_handler
+    if _signal_handler is None:
+        _signal_handler = SignalHandler()
+    return _signal_handler
+
+
+
+
+
+
+def is_shutdown_requested() -> bool:
+    """
+    Check if shutdown has been requested.
+    
+    Returns:
+        True if shutdown signal received
+    """
+    handler = get_signal_handler()
+    return handler.is_shutdown_requested()