mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.30__py3-none-any.whl

mcp_proxy_adapter/core/server_engine.py

@@ -14,6 +14,8 @@ from abc import ABC, abstractmethod
 from typing import Dict, Any, Optional
 from pathlib import Path
 
+from .logging import get_global_logger
+
 logger = logging.getLogger(__name__)
 
 
@@ -41,38 +43,10 @@ class ServerEngine(ABC):
         pass
 
     @abstractmethod
-    def get_config_schema(self) -> Dict[str, Any]:
-        """
-        Get configuration schema for this server engine.
-
-        Returns:
-            Dictionary describing the configuration options
-        """
-        pass
 
     @abstractmethod
-    def validate_config(self, config: Dict[str, Any]) -> bool:
-        """
-        Validate configuration for this server engine.
-
-        Args:
-            config: Configuration dictionary
-
-        Returns:
-            True if configuration is valid, False otherwise
-        """
-        pass
 
     @abstractmethod
-    def run_server(self, app: Any, config: Dict[str, Any]) -> None:
-        """
-        Run the server with the given configuration.
-
-        Args:
-            app: ASGI application
-            config: Server configuration
-        """
-        pass
 
 
 class HypercornEngine(ServerEngine):
@@ -96,120 +70,8 @@ class HypercornEngine(ServerEngine):
             "reload": True,
         }
 
-    def get_config_schema(self) -> Dict[str, Any]:
-        return {
-            "host": {"type": "string", "default": "127.0.0.1"},
-            "port": {"type": "integer", "default": 8000},
-            "log_level": {"type": "string", "default": "INFO"},
-            "certfile": {"type": "string", "optional": True},
-            "keyfile": {"type": "string", "optional": True},
-            "ca_certs": {"type": "string", "optional": True},
-            "verify_mode": {"type": "string", "optional": True},
-            "reload": {"type": "boolean", "default": False},
-            "workers": {"type": "integer", "optional": True},
-        }
-
-    def validate_config(self, config: Dict[str, Any]) -> bool:
-        """Validate hypercorn configuration."""
-        required_fields = ["host", "port"]
-
-        for field in required_fields:
-            if field not in config:
-                get_global_logger().error(f"Missing required field: {field}")
-                return False
 
-        # Validate SSL files exist if specified
-        ssl_files = ["certfile", "keyfile", "ca_certs"]
-        for ssl_file in ssl_files:
-            if ssl_file in config and config[ssl_file]:
-                if not Path(config[ssl_file]).exists():
-                    get_global_logger().error(f"SSL file not found: {config[ssl_file]}")
-                    return False
 
-        return True
-
-    def run_server(self, app: Any, config: Dict[str, Any]) -> None:
-        """Run hypercorn server."""
-        try:
-            import hypercorn.asyncio
-            import asyncio
-
-            # Prepare hypercorn config
-            hypercorn_config = {
-                "bind": f"{config.get('host', '127.0.0.1')}:{config.get('port', 8000)}",
-                "log_level": config.get("log_level", "INFO"),
-                "reload": config.get("reload", False),
-            }
-
-            # Add SSL configuration if provided
-            get_global_logger().info(f"🔍 DEBUG: Input config keys: {list(config.keys())}")
-            get_global_logger().info(
-                f"🔍 DEBUG: Input config certfile: {config.get('certfile', 'NOT_FOUND')}"
-            )
-            get_global_logger().info(
-                f"🔍 DEBUG: Input config keyfile: {config.get('keyfile', 'NOT_FOUND')}"
-            )
-            get_global_logger().info(
-                f"🔍 DEBUG: Input config ca_certs: {config.get('ca_certs', 'NOT_FOUND')}"
-            )
-            get_global_logger().info(
-                f"🔍 DEBUG: Input config verify_mode: {config.get('verify_mode', 'NOT_FOUND')}"
-            )
-
-            if "certfile" in config and config["certfile"]:
-                hypercorn_config["certfile"] = config["certfile"]
-            if "keyfile" in config and config["keyfile"]:
-                hypercorn_config["keyfile"] = config["keyfile"]
-            if "ca_certs" in config and config["ca_certs"]:
-                hypercorn_config["ca_certs"] = config["ca_certs"]
-            if "verify_mode" in config and config["verify_mode"]:
-                # Convert verify_mode string to SSL constant
-                verify_mode_str = config["verify_mode"]
-                if verify_mode_str == "CERT_NONE":
-                    import ssl
-
-                    hypercorn_config["verify_mode"] = ssl.CERT_NONE
-                elif verify_mode_str == "CERT_REQUIRED":
-                    import ssl
-
-                    hypercorn_config["verify_mode"] = ssl.CERT_REQUIRED
-                elif verify_mode_str == "CERT_OPTIONAL":
-                    import ssl
-
-                    hypercorn_config["verify_mode"] = ssl.CERT_OPTIONAL
-                else:
-                    hypercorn_config["verify_mode"] = verify_mode_str
-
-            # Add workers if specified
-            if "workers" in config and config["workers"]:
-                hypercorn_config["workers"] = config["workers"]
-
-            get_global_logger().info(f"Starting hypercorn server with config: {hypercorn_config}")
-            get_global_logger().info(f"SSL config from input: {config.get('ssl', 'NOT_FOUND')}")
-            get_global_logger().info(
-                f"Security SSL config: {config.get('security', {}).get('ssl', 'NOT_FOUND')}"
-            )
-            get_global_logger().info(
-                f"🔍 DEBUG: Hypercorn verify_mode: {hypercorn_config.get('verify_mode', 'NOT_SET')}"
-            )
-            get_global_logger().info(
-                f"🔍 DEBUG: Hypercorn ca_certs: {hypercorn_config.get('ca_certs', 'NOT_SET')}"
-            )
-
-            # Create config object
-            config_obj = hypercorn.Config()
-            for key, value in hypercorn_config.items():
-                setattr(config_obj, key, value)
-
-            # Run server
-            asyncio.run(hypercorn.asyncio.serve(app, config_obj))
-
-        except ImportError:
-            get_global_logger().error("hypercorn not installed. Install with: pip install hypercorn")
-            raise
-        except Exception as e:
-            get_global_logger().error(f"Failed to start hypercorn server: {e}")
-            raise
 
 
 class ServerEngineFactory:
@@ -233,43 +95,10 @@ class ServerEngineFactory:
         get_global_logger().info(f"Registered server engine: {engine.get_name()}")
 
     @classmethod
-    def get_engine(cls, name: str) -> Optional[ServerEngine]:
-        """
-        Get a server engine by name.
-
-        Args:
-            name: Name of the server engine
-
-        Returns:
-            Server engine instance or None if not found
-        """
-        return cls._engines.get(name)
 
     @classmethod
-    def get_available_engines(cls) -> Dict[str, ServerEngine]:
-        """
-        Get all available server engines.
-
-        Returns:
-            Dictionary mapping engine names to engine instances
-        """
-        return cls._engines.copy()
 
     @classmethod
-    def get_engine_with_feature(cls, feature: str) -> Optional[ServerEngine]:
-        """
-        Get the first available engine that supports a specific feature.
-
-        Args:
-            feature: Name of the feature to check
-
-        Returns:
-            Server engine that supports the feature or None
-        """
-        for engine in cls._engines.values():
-            if engine.get_supported_features().get(feature, False):
-                return engine
-        return None
 
     @classmethod
     def initialize_default_engines(cls) -> None:

mcp_proxy_adapter/core/settings.py

@@ -3,7 +3,6 @@ Settings management for the MCP Proxy Adapter framework.
 Provides utilities for reading and managing framework settings from configuration.
 """
 
-from typing import Any, Dict, Optional, Union
 from mcp_proxy_adapter.config import config
 
 
@@ -69,65 +68,10 @@ class Settings:
         cls._custom_settings.clear()
 
     @staticmethod
-    def get_server_settings() -> Dict[str, Any]:
-        """
-        Get server configuration settings.
-
-        Returns:
-            Dictionary with server settings
-        """
-        return {
-            "host": config.get("server.host", "0.0.0.0"),
-            "port": config.get("server.port", 8000),
-            "debug": config.get("server.debug", False),
-            "log_level": config.get("server.log_level", "INFO"),
-        }
 
     @staticmethod
-    def get_logging_settings() -> Dict[str, Any]:
-        """
-        Get logging configuration settings.
-
-        Returns:
-            Dictionary with logging settings
-        """
-        return {
-            "level": config.get("logging.level", "INFO"),
-            "file": config.get("logging.file"),
-            "log_dir": config.get("logging.log_dir", "./logs"),
-            "log_file": config.get("logging.log_file", "mcp_proxy_adapter.log"),
-            "error_log_file": config.get(
-                "logging.error_log_file", "mcp_proxy_adapter_error.log"
-            ),
-            "access_log_file": config.get(
-                "logging.access_log_file", "mcp_proxy_adapter_access.log"
-            ),
-            "max_file_size": config.get("logging.max_file_size", "10MB"),
-            "backup_count": config.get("logging.backup_count", 5),
-            "format": config.get(
-                "logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-            ),
-            "date_format": config.get("logging.date_format", "%Y-%m-%d %H:%M:%S"),
-            "console_output": config.get("logging.console_output", True),
-            "file_output": config.get("logging.file_output", True),
-        }
 
     @staticmethod
-    def get_commands_settings() -> Dict[str, Any]:
-        """
-        Get commands configuration settings.
-
-        Returns:
-            Dictionary with commands settings
-        """
-        return {
-            "auto_discovery": config.get("commands.auto_discovery", True),
-            "discovery_path": config.get(
-                "commands.discovery_path", "mcp_proxy_adapter.commands"
-            ),
-            "auto_commands_path": config.get("commands.auto_commands_path"),
-            "custom_commands_path": config.get("commands.custom_commands_path"),
-        }
 
     @staticmethod
     def get_custom_setting(key: str, default: Any = None) -> Any:
@@ -144,16 +88,6 @@ class Settings:
         return config.get(key, default)
 
     @staticmethod
-    def get_all_settings() -> Dict[str, Any]:
-        """
-        Get all configuration settings including custom settings.
-
-        Returns:
-            Dictionary with all configuration settings
-        """
-        all_settings = config.get_all()
-        all_settings["custom_settings"] = Settings._custom_settings
-        return all_settings
 
     @staticmethod
     def set_custom_setting(key: str, value: Any) -> None:
@@ -194,11 +128,6 @@ class ServerSettings:
         """Get debug mode."""
         return config.get("server.debug", False)
 
-    @staticmethod
-    def get_log_level() -> str:
-        """Get log level."""
-        return config.get("server.log_level", "INFO")
-
 
 class LoggingSettings:
     """
@@ -216,51 +145,22 @@ class LoggingSettings:
         return config.get("logging.log_dir", "./logs")
 
     @staticmethod
-    def get_log_file() -> Optional[str]:
-        """Get main log file name."""
-        return config.get("logging.log_file", "mcp_proxy_adapter.log")
 
     @staticmethod
-    def get_error_log_file() -> Optional[str]:
-        """Get error log file name."""
-        return config.get("logging.error_log_file", "mcp_proxy_adapter_error.log")
 
     @staticmethod
-    def get_access_log_file() -> Optional[str]:
-        """Get access log file name."""
-        return config.get("logging.access_log_file", "mcp_proxy_adapter_access.log")
 
     @staticmethod
-    def get_max_file_size() -> str:
-        """Get max file size."""
-        return config.get("logging.max_file_size", "10MB")
 
     @staticmethod
-    def get_backup_count() -> int:
-        """Get backup count."""
-        return config.get("logging.backup_count", 5)
 
     @staticmethod
-    def get_format() -> str:
-        """Get log format."""
-        return config.get(
-            "logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        )
 
     @staticmethod
-    def get_date_format() -> str:
-        """Get date format."""
-        return config.get("logging.date_format", "%Y-%m-%d %H:%M:%S")
 
     @staticmethod
-    def get_console_output() -> bool:
-        """Get console output setting."""
-        return config.get("logging.console_output", True)
 
     @staticmethod
-    def get_file_output() -> bool:
-        """Get file output setting."""
-        return config.get("logging.file_output", True)
 
 
 class CommandsSettings:
@@ -279,35 +179,17 @@ class CommandsSettings:
         return config.get("commands.discovery_path", "mcp_proxy_adapter.commands")
 
     @staticmethod
-    def get_custom_commands_path() -> Optional[str]:
-        """Get custom commands path."""
-        return config.get("commands.custom_commands_path")
 
 
 # Convenience functions for easy access
-def get_server_host() -> str:
-    """Get server host."""
-    return ServerSettings.get_host()
 
 
-def get_server_port() -> int:
-    """Get server port."""
-    return ServerSettings.get_port()
 
 
-def get_server_debug() -> bool:
-    """Get server debug mode."""
-    return ServerSettings.get_debug()
 
 
-def get_logging_level() -> str:
-    """Get logging level."""
-    return LoggingSettings.get_level()
 
 
-def get_logging_dir() -> str:
-    """Get logging directory."""
-    return LoggingSettings.get_log_dir()
 
 
 def get_auto_discovery() -> bool:
@@ -320,19 +202,10 @@ def get_discovery_path() -> str:
     return CommandsSettings.get_discovery_path()
 
 
-def get_setting(key: str, default: Any = None) -> Any:
-    """Get any setting by key."""
-    return Settings.get_custom_setting(key, default)
 
 
-def set_setting(key: str, value: Any) -> None:
-    """Set any setting by key."""
-    Settings.set_custom_setting(key, value)
 
 
-def reload_settings() -> None:
-    """Reload all settings from configuration."""
-    Settings.reload_config()
 
 
 def add_custom_settings(settings: Dict[str, Any]) -> None:

mcp_proxy_adapter/core/signal_handler.py

@@ -9,7 +9,6 @@ email: vasilyvz@gmail.com
 """
 
 import signal
-import asyncio
 import threading
 from typing import Optional, Callable, Any
 from mcp_proxy_adapter.core.logging import get_global_logger
@@ -56,42 +55,7 @@ class SignalHandler:
         
         get_global_logger().info("Signal handlers installed for SIGTERM, SIGINT, SIGHUP")
     
-    def _handle_shutdown_signal(self, signum: int, frame: Any):
-        """
-        Handle shutdown signals.
-        
-        Args:
-            signum: Signal number
-            frame: Current stack frame
-        """
-        signal_name = signal.Signals(signum).name
-        get_global_logger().info(f"🛑 Received {signal_name} signal, initiating graceful shutdown...")
-        
-        # Set shutdown event
-        self._shutdown_event.set()
-        
-        # Call shutdown callback if set
-        if self._shutdown_callback:
-            try:
-                get_global_logger().info("🔄 Executing shutdown callback...")
-                self._shutdown_callback()
-                get_global_logger().info("✅ Shutdown callback completed successfully")
-            except Exception as e:
-                get_global_logger().error(f"❌ Shutdown callback failed: {e}")
-        
-        # Force exit immediately to avoid server hang
-        get_global_logger().info("🔄 Force exiting to avoid server hang...")
-        import os
-        # Use os._exit for immediate termination
-        get_global_logger().warning("⚠️ Using os._exit for immediate termination...")
-        os._exit(0)
     
-    def _force_exit(self):
-        """Force exit if graceful shutdown takes too long."""
-        if self._shutdown_event.is_set():
-            get_global_logger().warning("⚠️ Forcing exit after timeout")
-            import os
-            os._exit(1)
     
     def wait_for_shutdown(self, timeout: Optional[float] = None) -> bool:
         """
@@ -114,12 +78,6 @@ class SignalHandler:
         """
         return self._shutdown_event.is_set()
     
-    def restore_handlers(self):
-        """Restore original signal handlers."""
-        for sig, handler in self._original_handlers.items():
-            if handler is not None:
-                signal.signal(sig, handler)
-        get_global_logger().info("Original signal handlers restored")
 
 
 # Global signal handler instance
@@ -134,31 +92,8 @@ def get_signal_handler() -> SignalHandler:
     return _signal_handler
 
 
-def setup_signal_handling(shutdown_callback: Optional[Callable] = None):
-    """
-    Setup signal handling for graceful shutdown.
-    
-    Args:
-        shutdown_callback: Optional callback to execute during shutdown
-    """
-    handler = get_signal_handler()
-    if shutdown_callback:
-        handler.set_shutdown_callback(shutdown_callback)
-    get_global_logger().info("Signal handling setup completed")
 
 
-def wait_for_shutdown_signal(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
-    """
-    handler = get_signal_handler()
-    return handler.wait_for_shutdown(timeout)
 
 
 def is_shutdown_requested() -> bool:

mcp_proxy_adapter/core/ssl_utils.py

@@ -45,91 +45,6 @@ class SSLUtils:
     }
 
     @staticmethod
-    def create_ssl_context(
-        cert_file: str,
-        key_file: str,
-        ca_cert: Optional[str] = None,
-        verify_client: bool = False,
-        cipher_suites: Optional[List[str]] = None,
-        min_tls_version: str = "1.2",
-        max_tls_version: str = "1.3",
-        crl_config: Optional[Dict[str, Any]] = None,
-    ) -> ssl.SSLContext:
-        """
-        Create SSL context with specified configuration.
-
-        Args:
-            cert_file: Path to certificate file
-            key_file: Path to private key file
-            ca_cert: Path to CA certificate file (optional)
-            verify_client: Whether to verify client certificates
-            cipher_suites: List of cipher suites to use
-            min_tls_version: Minimum TLS version
-            max_tls_version: Maximum TLS version
-            crl_config: CRL configuration dictionary (optional)
-
-        Returns:
-            Configured SSL context
-
-        Raises:
-            ValueError: If certificate validation fails
-            FileNotFoundError: If certificate or key files not found
-        """
-        # Validate certificate using AuthValidator
-        validator = AuthValidator()
-        result = validator.validate_certificate(cert_file)
-        if not result.is_valid:
-            raise ValueError(f"Invalid certificate: {result.error_message}")
-
-        # Check CRL if configured
-        if crl_config:
-            try:
-                crl_manager = CRLManager(crl_config)
-                if crl_manager.is_certificate_revoked(cert_file):
-                    raise ValueError(
-                        f"Certificate is revoked according to CRL: {cert_file}"
-                    )
-            except Exception as e:
-                get_global_logger().error(f"CRL check failed: {e}")
-                # For security, fail if CRL check fails
-                raise ValueError(f"CRL validation failed: {e}")
-
-        # Check if files exist
-        if not Path(cert_file).exists():
-            raise FileNotFoundError(f"Certificate file not found: {cert_file}")
-        if not Path(key_file).exists():
-            raise FileNotFoundError(f"Key file not found: {key_file}")
-        if ca_cert and not Path(ca_cert).exists():
-            raise FileNotFoundError(f"CA certificate file not found: {ca_cert}")
-
-        # Create SSL context
-        if verify_client:
-            context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-        else:
-            context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
-
-        # Load certificate and key
-        context.load_cert_chain(cert_file, key_file)
-
-        # Load CA certificate if provided
-        if ca_cert:
-            context.load_verify_locations(ca_cert)
-
-        # Configure client verification
-        if verify_client:
-            context.verify_mode = ssl.CERT_REQUIRED
-            context.check_hostname = False
-        else:
-            context.verify_mode = ssl.CERT_NONE
-
-        # Setup cipher suites
-        SSLUtils.setup_cipher_suites(context, cipher_suites or [])
-
-        # Setup TLS versions
-        SSLUtils.setup_tls_versions(context, min_tls_version, max_tls_version)
-
-        get_global_logger().info(f"SSL context created successfully with cert: {cert_file}")
-        return context
 
     @staticmethod
     def validate_certificate(
@@ -225,55 +140,22 @@ class SSLUtils:
             get_global_logger().error(f"Failed to set TLS versions: {e}")
 
     @staticmethod
-    def check_tls_version(min_version: str, max_version: str) -> bool:
-        """
-        Check if TLS version range is valid.
-
-        Args:
-            min_version: Minimum TLS version
-            max_version: Maximum TLS version
-
-        Returns:
-            True if version range is valid, False otherwise
-        """
-        min_tls = SSLUtils.TLS_VERSIONS.get(min_version)
-        max_tls = SSLUtils.TLS_VERSIONS.get(max_version)
-
-        if not min_tls or not max_tls:
-            return False
-
-        # Check if min version is less than or equal to max version
-        return min_tls <= max_tls
-
-    @staticmethod
-    def get_ssl_config_for_hypercorn(ssl_config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Get SSL configuration for hypercorn from transport configuration.
-
-        Args:
-            ssl_config: SSL configuration from transport manager
-
-        Returns:
-            Configuration for hypercorn
-        """
-        hypercorn_ssl = {}
-
-        if not ssl_config:
-            return hypercorn_ssl
-
-        # Basic SSL parameters
-        if ssl_config.get("cert_file"):
-            hypercorn_ssl["certfile"] = ssl_config["cert_file"]
-
-        if ssl_config.get("key_file"):
-            hypercorn_ssl["keyfile"] = ssl_config["key_file"]
-
-        if ssl_config.get("ca_cert"):
-            hypercorn_ssl["ca_certs"] = ssl_config["ca_cert"]
-
-        # Client verification mode
-        if ssl_config.get("verify_client", False):
-            hypercorn_ssl["verify_mode"] = "CERT_REQUIRED"
-
-        get_global_logger().info(f"Generated hypercorn SSL config: {hypercorn_ssl}")
-        return hypercorn_ssl
+    def create_ssl_context(
+        cert_file: Optional[str] = None,
+        key_file: Optional[str] = None,
+        ca_file: Optional[str] = None,
+        verify_mode: int = ssl.CERT_REQUIRED,
+        check_hostname: bool = True,
+    ) -> ssl.SSLContext:
+        """Create SSL context with proper configuration."""
+        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        context.check_hostname = check_hostname
+        context.verify_mode = verify_mode
+        
+        if cert_file and key_file:
+            context.load_cert_chain(cert_file, key_file)
+        
+        if ca_file:
+            context.load_verify_locations(ca_file)
+            
+        return context