mcp-proxy-adapter 6.1.0__py3-none-any.whl → 6.2.0__py3-none-any.whl

mcp_proxy_adapter/core/client_manager.py

@@ -0,0 +1,284 @@
+"""
+Client Manager for MCP Proxy Adapter Framework
+
+This module provides client management functionality for the MCP Proxy Adapter framework.
+It handles client creation, connection management, and proxy registration.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import json
+import logging
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+
+from .client import UniversalClient, create_client_from_config
+
+
+class ClientManager:
+    """
+    Manages client connections and proxy registrations.
+    
+    This class provides functionality for:
+    - Creating and managing client connections
+    - Proxy registration
+    - Connection pooling
+    - Authentication management
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize client manager.
+        
+        Args:
+            config: Client manager configuration
+        """
+        self.config = config
+        self.logger = logging.getLogger(__name__)
+        self.clients: Dict[str, UniversalClient] = {}
+        self.connection_pool: Dict[str, UniversalClient] = {}
+        
+        # Client manager settings
+        self.max_connections = config.get("max_connections", 10)
+        self.connection_timeout = config.get("connection_timeout", 30)
+        self.retry_attempts = config.get("retry_attempts", 3)
+        self.retry_delay = config.get("retry_delay", 1)
+        
+        self.logger.info("Client manager initialized")
+    
+    async def create_client(self, client_id: str, config_file: str) -> UniversalClient:
+        """
+        Create a new client instance.
+        
+        Args:
+            client_id: Unique identifier for the client
+            config_file: Path to client configuration file
+            
+        Returns:
+            UniversalClient instance
+        """
+        try:
+            if client_id in self.clients:
+                self.logger.warning(f"Client {client_id} already exists, reusing existing connection")
+                return self.clients[client_id]
+            
+            client = create_client_from_config(config_file)
+            self.clients[client_id] = client
+            
+            self.logger.info(f"Client {client_id} created successfully")
+            return client
+            
+        except Exception as e:
+            self.logger.error(f"Failed to create client {client_id}: {e}")
+            raise
+    
+    async def get_client(self, client_id: str) -> Optional[UniversalClient]:
+        """
+        Get an existing client instance.
+        
+        Args:
+            client_id: Client identifier
+            
+        Returns:
+            UniversalClient instance or None if not found
+        """
+        return self.clients.get(client_id)
+    
+    async def remove_client(self, client_id: str) -> bool:
+        """
+        Remove a client instance.
+        
+        Args:
+            client_id: Client identifier
+            
+        Returns:
+            True if client was removed, False otherwise
+        """
+        if client_id in self.clients:
+            client = self.clients[client_id]
+            await client.disconnect()
+            del self.clients[client_id]
+            self.logger.info(f"Client {client_id} removed")
+            return True
+        return False
+    
+    async def test_client_connection(self, client_id: str) -> bool:
+        """
+        Test connection for a specific client.
+        
+        Args:
+            client_id: Client identifier
+            
+        Returns:
+            True if connection is successful, False otherwise
+        """
+        client = await self.get_client(client_id)
+        if not client:
+            self.logger.error(f"Client {client_id} not found")
+            return False
+        
+        try:
+            return await client.test_connection()
+        except Exception as e:
+            self.logger.error(f"Connection test failed for client {client_id}: {e}")
+            return False
+    
+    async def register_proxy(self, client_id: str, proxy_config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Register with proxy server using a specific client.
+        
+        Args:
+            client_id: Client identifier
+            proxy_config: Proxy registration configuration
+            
+        Returns:
+            Registration result
+        """
+        client = await self.get_client(client_id)
+        if not client:
+            return {"error": f"Client {client_id} not found"}
+        
+        try:
+            result = await client.register_proxy(proxy_config)
+            self.logger.info(f"Proxy registration completed for client {client_id}")
+            return result
+        except Exception as e:
+            self.logger.error(f"Proxy registration failed for client {client_id}: {e}")
+            return {"error": str(e)}
+    
+    async def execute_command(self, client_id: str, command: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Execute a command using a specific client.
+        
+        Args:
+            client_id: Client identifier
+            command: Command name
+            params: Command parameters
+            
+        Returns:
+            Command result
+        """
+        client = await self.get_client(client_id)
+        if not client:
+            return {"error": f"Client {client_id} not found"}
+        
+        try:
+            result = await client.execute_command(command, params or {})
+            self.logger.info(f"Command {command} executed for client {client_id}")
+            return result
+        except Exception as e:
+            self.logger.error(f"Command execution failed for client {client_id}: {e}")
+            return {"error": str(e)}
+    
+    async def get_client_status(self, client_id: str) -> Dict[str, Any]:
+        """
+        Get status information for a specific client.
+        
+        Args:
+            client_id: Client identifier
+            
+        Returns:
+            Client status information
+        """
+        client = await self.get_client(client_id)
+        if not client:
+            return {"error": f"Client {client_id} not found"}
+        
+        try:
+            # Test connection
+            connection_ok = await client.test_connection()
+            
+            # Test security features
+            security_features = await client.test_security_features()
+            
+            status = {
+                "client_id": client_id,
+                "base_url": client.base_url,
+                "auth_method": client.auth_method,
+                "connection_ok": connection_ok,
+                "security_features": security_features,
+                "session_active": client.session is not None
+            }
+            
+            return status
+        except Exception as e:
+            self.logger.error(f"Failed to get status for client {client_id}: {e}")
+            return {"error": str(e)}
+    
+    async def list_clients(self) -> List[str]:
+        """
+        Get list of all client identifiers.
+        
+        Returns:
+            List of client identifiers
+        """
+        return list(self.clients.keys())
+    
+    async def cleanup(self):
+        """Clean up all client connections."""
+        for client_id in list(self.clients.keys()):
+            await self.remove_client(client_id)
+        self.logger.info("All client connections cleaned up")
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.cleanup()
+
+
+def create_client_manager(config: Dict[str, Any]) -> ClientManager:
+    """
+    Create a ClientManager instance.
+    
+    Args:
+        config: Client manager configuration
+        
+    Returns:
+        ClientManager instance
+    """
+    return ClientManager(config)
+
+
+# Example usage and testing functions
+async def test_client_manager():
+    """Test client manager functionality."""
+    # Example configuration
+    config = {
+        "max_connections": 5,
+        "connection_timeout": 30,
+        "retry_attempts": 3,
+        "retry_delay": 1
+    }
+    
+    async with ClientManager(config) as manager:
+        # Create a client
+        client_id = "test_client"
+        config_file = "configs/http_simple.json"
+        
+        try:
+            client = await manager.create_client(client_id, config_file)
+            print(f"✅ Client {client_id} created successfully")
+            
+            # Test connection
+            connection_ok = await manager.test_client_connection(client_id)
+            print(f"✅ Connection test: {connection_ok}")
+            
+            # Get status
+            status = await manager.get_client_status(client_id)
+            print(f"✅ Client status: {json.dumps(status, indent=2)}")
+            
+            # Execute command
+            result = await manager.execute_command(client_id, "help")
+            print(f"✅ Command result: {json.dumps(result, indent=2)}")
+            
+        except Exception as e:
+            print(f"❌ Test failed: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_client_manager())

mcp_proxy_adapter/core/protocol_manager.py

@@ -21,19 +21,84 @@ class ProtocolManager:
     ensuring that only configured protocols are accessible.
     """
     
-    def __init__(self):
-        """Initialize the protocol manager."""
+    def __init__(self, app_config: Optional[Dict] = None):
+        """
+        Initialize the protocol manager.
+        
+        Args:
+            app_config: Application configuration dictionary (optional)
+        """
+        self.app_config = app_config
         self._load_config()
     
     def _load_config(self):
         """Load protocol configuration from config."""
-        self.protocols_config = config.get("protocols", {})
+        # Use provided config or fallback to global config
+        current_config = self.app_config if self.app_config is not None else config.get_all()
+        
+        # Get protocols configuration
+        self.protocols_config = current_config.get("protocols", {})
         self.enabled = self.protocols_config.get("enabled", True)
-        self.allowed_protocols = self.protocols_config.get("allowed_protocols", ["http"])
-        logger.debug(f"Protocol manager loaded config: enabled={self.enabled}, allowed_protocols={self.allowed_protocols}")
+        
+        # Get SSL configuration to determine allowed protocols
+        ssl_enabled = self._is_ssl_enabled(current_config)
+        
+        # Set allowed protocols based on SSL configuration
+        if ssl_enabled:
+            # If SSL is enabled, allow both HTTP and HTTPS
+            self.allowed_protocols = self.protocols_config.get("allowed_protocols", ["http", "https"])
+            # Ensure HTTPS is in allowed protocols if SSL is enabled
+            if "https" not in self.allowed_protocols:
+                self.allowed_protocols.append("https")
+        else:
+            # If SSL is disabled, only allow HTTP
+            self.allowed_protocols = self.protocols_config.get("allowed_protocols", ["http"])
+            # Remove HTTPS from allowed protocols if SSL is disabled
+            if "https" in self.allowed_protocols:
+                self.allowed_protocols.remove("https")
+        
+        logger.debug(f"Protocol manager loaded config: enabled={self.enabled}, allowed_protocols={self.allowed_protocols}, ssl_enabled={ssl_enabled}")
+    
+    def _is_ssl_enabled(self, current_config: Dict) -> bool:
+        """
+        Check if SSL is enabled in configuration.
+        
+        Args:
+            current_config: Current configuration dictionary
+            
+        Returns:
+            True if SSL is enabled, False otherwise
+        """
+        # Try security framework SSL config first
+        security_config = current_config.get("security", {})
+        ssl_config = security_config.get("ssl", {})
+        
+        if ssl_config.get("enabled", False):
+            logger.debug("SSL enabled via security.ssl configuration")
+            return True
+        
+        # Fallback to legacy SSL config
+        legacy_ssl_config = current_config.get("ssl", {})
+        if legacy_ssl_config.get("enabled", False):
+            logger.debug("SSL enabled via legacy ssl configuration")
+            return True
+        
+        logger.debug("SSL is disabled in configuration")
+        return False
+    
+    def update_config(self, new_config: Dict):
+        """
+        Update configuration and reload protocol settings.
+        
+        Args:
+            new_config: New configuration dictionary
+        """
+        self.app_config = new_config
+        self._load_config()
+        logger.info(f"Protocol manager configuration updated: allowed_protocols={self.allowed_protocols}")
     
     def reload_config(self):
-        """Reload protocol configuration."""
+        """Reload protocol configuration from global config."""
         self._load_config()
         
     def is_protocol_allowed(self, protocol: str) -> bool:
@@ -137,7 +202,11 @@ class ProtocolManager:
         if protocol.lower() not in ["https", "mtls"]:
             return None
             
-        ssl_config = config.get("ssl", {})
+        # Use provided config or fallback to global config
+        current_config = self.app_config if self.app_config is not None else config.get_all()
+        
+        # Get SSL configuration
+        ssl_config = self._get_ssl_config(current_config)
         
         if not ssl_config.get("enabled", False):
             logger.warning(f"SSL required for protocol '{protocol}' but SSL is disabled")
@@ -170,6 +239,33 @@ class ProtocolManager:
             logger.error(f"Failed to create SSL context for protocol '{protocol}': {e}")
             return None
     
+    def _get_ssl_config(self, current_config: Dict) -> Dict:
+        """
+        Get SSL configuration from config.
+        
+        Args:
+            current_config: Current configuration dictionary
+            
+        Returns:
+            SSL configuration dictionary
+        """
+        # Try security framework SSL config first
+        security_config = current_config.get("security", {})
+        ssl_config = security_config.get("ssl", {})
+        
+        if ssl_config.get("enabled", False):
+            logger.debug("Using security.ssl configuration")
+            return ssl_config
+        
+        # Fallback to legacy SSL config
+        legacy_ssl_config = current_config.get("ssl", {})
+        if legacy_ssl_config.get("enabled", False):
+            logger.debug("Using legacy ssl configuration")
+            return legacy_ssl_config
+        
+        # Return empty config if SSL is disabled
+        return {"enabled": False}
+    
     def get_protocol_info(self) -> Dict[str, Dict]:
         """
         Get information about all configured protocols.
@@ -222,7 +318,10 @@ class ProtocolManager:
                 
             # Check SSL requirements
             if protocol in ["https", "mtls"]:
-                ssl_config = config.get("ssl", {})
+                # Use provided config or fallback to global config
+                current_config = self.app_config if self.app_config is not None else config.get_all()
+                ssl_config = self._get_ssl_config(current_config)
+                
                 if not ssl_config.get("enabled", False):
                     errors.append(f"Protocol '{protocol}' requires SSL but SSL is disabled")
                 elif not ssl_config.get("cert_file") or not ssl_config.get("key_file"):
@@ -231,5 +330,28 @@ class ProtocolManager:
         return errors
 
 
-# Global protocol manager instance
-protocol_manager = ProtocolManager() 
+# Global protocol manager instance - will be updated with config when needed
+protocol_manager = None
+
+def get_protocol_manager(app_config: Optional[Dict] = None) -> ProtocolManager:
+    """
+    Get protocol manager instance with current configuration.
+    
+    Args:
+        app_config: Application configuration dictionary (optional)
+        
+    Returns:
+        ProtocolManager instance
+    """
+    global protocol_manager
+    
+    # If no app_config provided, use global config
+    if app_config is None:
+        app_config = config.get_all()
+    
+    # Create new instance if none exists or config changed
+    if protocol_manager is None or protocol_manager.app_config != app_config:
+        protocol_manager = ProtocolManager(app_config)
+        logger.info("Protocol manager created with new configuration")
+    
+    return protocol_manager 

mcp_proxy_adapter/core/security_integration.py

@@ -102,18 +102,26 @@ class SecurityIntegration:
             public_paths=security_section.get("auth", {}).get("public_paths", [])
         )
         
-        # Create permission config
+        # Create permission config - handle null values properly
+        permissions_section = security_section.get("permissions", {})
+        roles_file = permissions_section.get("roles_file")
+        
+        # If roles_file is None or empty string, don't pass it to avoid framework errors
+        if roles_file is None or roles_file == "":
+            logger.warning("roles_file is None or empty, permissions will use default configuration")
+            roles_file = None
+        
         permission_config = PermissionConfig(
-            enabled=security_section.get("permissions", {}).get("enabled", True),
-            roles_file=security_section.get("permissions", {}).get("roles_file"),
-            default_role=security_section.get("permissions", {}).get("default_role", "guest"),
-            admin_role=security_section.get("permissions", {}).get("admin_role", "admin"),
-            role_hierarchy=security_section.get("permissions", {}).get("role_hierarchy", {}),
-            permission_cache_enabled=security_section.get("permissions", {}).get("permission_cache_enabled", True),
-            permission_cache_ttl=security_section.get("permissions", {}).get("permission_cache_ttl", 300),
-            wildcard_permissions=security_section.get("permissions", {}).get("wildcard_permissions", False),
-            strict_mode=security_section.get("permissions", {}).get("strict_mode", True),
-            roles=security_section.get("permissions", {}).get("roles")
+            enabled=permissions_section.get("enabled", True),
+            roles_file=roles_file,
+            default_role=permissions_section.get("default_role", "guest"),
+            admin_role=permissions_section.get("admin_role", "admin"),
+            role_hierarchy=permissions_section.get("role_hierarchy", {}),
+            permission_cache_enabled=permissions_section.get("permission_cache_enabled", True),
+            permission_cache_ttl=permissions_section.get("permission_cache_ttl", 300),
+            wildcard_permissions=permissions_section.get("wildcard_permissions", False),
+            strict_mode=permissions_section.get("strict_mode", True),
+            roles=permissions_section.get("roles")
         )
         
         # Create rate limit config

mcp_proxy_adapter/core/server_adapter.py

@@ -35,7 +35,7 @@ class ServerConfigAdapter:
         
         Args:
             ssl_config: Source SSL configuration
-            target_engine: Target engine name (uvicorn, hypercorn, etc.)
+            target_engine: Target engine name (hypercorn)
             
         Returns:
             Converted SSL configuration for the target engine
@@ -45,35 +45,12 @@ class ServerConfigAdapter:
             logger.error(f"Unknown server engine: {target_engine}")
             return {}
         
-        if target_engine == "uvicorn":
-            return ServerConfigAdapter._convert_to_uvicorn_ssl(ssl_config)
-        elif target_engine == "hypercorn":
+        if target_engine == "hypercorn":
             return ServerConfigAdapter._convert_to_hypercorn_ssl(ssl_config)
         else:
             logger.warning(f"No SSL conversion available for engine: {target_engine}")
             return {}
     
-    @staticmethod
-    def _convert_to_uvicorn_ssl(ssl_config: Dict[str, Any]) -> Dict[str, Any]:
-        """Convert SSL configuration to uvicorn format."""
-        uvicorn_ssl = {}
-        
-        # Map SSL parameters
-        if ssl_config.get("cert_file"):
-            uvicorn_ssl["ssl_certfile"] = ssl_config["cert_file"]
-        if ssl_config.get("key_file"):
-            uvicorn_ssl["ssl_keyfile"] = ssl_config["key_file"]
-        if ssl_config.get("ca_cert"):
-            uvicorn_ssl["ssl_ca_certs"] = ssl_config["ca_cert"]
-        
-        # Map verification mode
-        if ssl_config.get("verify_client", False):
-            import ssl
-            uvicorn_ssl["ssl_cert_reqs"] = ssl.CERT_REQUIRED
-        
-        logger.debug(f"Converted SSL config to uvicorn: {uvicorn_ssl}")
-        return uvicorn_ssl
-    
     @staticmethod
     def _convert_to_hypercorn_ssl(ssl_config: Dict[str, Any]) -> Dict[str, Any]:
         """Convert SSL configuration to hypercorn format."""
@@ -99,49 +76,16 @@ class ServerConfigAdapter:
         """
         Determine the optimal server engine for a given configuration.
         
+        Currently only hypercorn is supported.
+        
         Args:
             config: Server configuration
             
         Returns:
-            Name of the optimal engine or None if no suitable engine found
+            Optimal engine name (currently always "hypercorn")
         """
-        # Check if mTLS is required
-        ssl_config = config.get("ssl", {})
-        if not ssl_config:
-            # Try to get SSL config from security section
-            ssl_config = config.get("security", {}).get("ssl", {})
-        
-        # Prefer hypercorn for all SSL/TLS scenarios due to better mTLS support
-        if ssl_config.get("enabled", False):
-            engine = ServerEngineFactory.get_engine("hypercorn")
-            if engine:
-                logger.info("Selected hypercorn for SSL/TLS support (better mTLS capabilities)")
-                return engine.get_name()
-            else:
-                logger.warning("SSL enabled but hypercorn not available")
-        
-        # For mTLS client verification, hypercorn is required
-        if ssl_config.get("verify_client", False) or ssl_config.get("client_cert_required", False):
-            engine = ServerEngineFactory.get_engine_with_feature("mtls_client_certs")
-            if engine:
-                logger.info(f"Selected {engine.get_name()} for mTLS support")
-                return engine.get_name()
-            else:
-                logger.warning("mTLS required but no suitable engine available")
-                return None
-        
-        # Default to hypercorn for better async support, fallback to uvicorn
-        engine = ServerEngineFactory.get_engine("hypercorn")
-        if engine:
-            logger.info("Selected hypercorn as default engine (better async support)")
-            return engine.get_name()
-        
-        engine = ServerEngineFactory.get_engine("uvicorn")
-        if engine:
-            logger.info("Selected uvicorn as fallback engine")
-            return "uvicorn"
-        
-        return None
+        # Currently only hypercorn is supported
+        return "hypercorn"
     
     @staticmethod
     def validate_engine_compatibility(
@@ -201,19 +145,18 @@ class ServerConfigAdapter:
 
 class UnifiedServerRunner:
     """
-    Unified server runner that abstracts the choice of server engine.
+    Unified server runner that uses hypercorn as the default engine.
     
-    This class provides a unified interface for running servers regardless
-    of the underlying engine, automatically selecting the best engine
-    for the given configuration.
+    This class provides a unified interface for running servers using hypercorn
+    as the underlying engine.
     """
     
-    def __init__(self, default_engine: str = "uvicorn"):
+    def __init__(self, default_engine: str = "hypercorn"):
         """
         Initialize the unified server runner.
         
         Args:
-            default_engine: Default engine to use if no specific requirements
+            default_engine: Default engine to use (currently only hypercorn is supported)
         """
         self.default_engine = default_engine
         self.available_engines = ServerEngineFactory.get_available_engines()
@@ -228,22 +171,16 @@ class UnifiedServerRunner:
         engine_name: Optional[str] = None
     ) -> None:
         """
-        Run server with the specified or optimal engine.
+        Run server with hypercorn engine.
         
         Args:
             app: ASGI application
             config: Server configuration
-            engine_name: Specific engine to use (optional)
+            engine_name: Engine to use (currently only hypercorn is supported)
         """
-        # Determine which engine to use
-        if engine_name:
-            selected_engine = engine_name
-            logger.info(f"Using specified engine: {selected_engine}")
-        else:
-            selected_engine = ServerConfigAdapter.get_optimal_engine_for_config(config)
-            if not selected_engine:
-                selected_engine = self.default_engine
-                logger.info(f"Using default engine: {selected_engine}")
+        # Use hypercorn as the only supported engine
+        selected_engine = "hypercorn"
+        logger.info(f"Using hypercorn engine")
         
         # Validate compatibility
         if not ServerConfigAdapter.validate_engine_compatibility(config, selected_engine):