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

mcp_proxy_adapter/api/core/registration_context.py

@@ -0,0 +1,356 @@
+"""Registration helper context builders for proxy interactions.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+
+@dataclass
+class ProxyCredentials:
+    """Client certificate and verification settings for proxy communication."""
+
+    cert: Optional[Tuple[str, str]]
+    verify: Union[bool, str]
+
+
+@dataclass
+class RegistrationContext:
+    """Prepared data required to register the adapter with a proxy."""
+
+    server_name: str
+    advertised_url: str
+    proxy_url: str
+    register_endpoint: str
+    capabilities: List[str]
+    metadata: Dict[str, Any]
+    use_proxy_client: bool
+    proxy_client_config: Dict[str, Any]
+    proxy_registration_config: Dict[str, Any]
+    credentials: ProxyCredentials
+
+
+@dataclass
+class HeartbeatSettings:
+    """Configuration for heartbeat scheduling."""
+
+    interval: int
+    endpoint: str
+
+
+def prepare_registration_context(
+    config: Dict[str, Any], logger: Any
+) -> Optional[RegistrationContext]:
+    """Build registration context from configuration.
+
+    Returns ``None`` when registration should not be performed.
+    """
+
+    proxy_client_config = dict(config.get("proxy_client") or {})
+    proxy_registration_config = dict(config.get("proxy_registration") or {})
+    use_proxy_client = bool(proxy_client_config)
+
+    if use_proxy_client:
+        registration_config = proxy_client_config.get("registration") or {}
+        registration_enabled = registration_config.get("auto_on_startup", False)
+    else:
+        registration_config = proxy_registration_config
+        registration_enabled = proxy_registration_config.get("enabled", False)
+
+    if not registration_enabled:
+        logger.info(
+            "Proxy registration disabled (auto_on_startup=false or enabled=false)"
+        )
+        return None
+
+    if use_proxy_client:
+        proxy_host = proxy_client_config.get("host", "localhost")
+        proxy_port = proxy_client_config.get("port", 3005)
+        # Determine proxy scheme based on proxy protocol
+        # NOTE: proxy_client.protocol indicates the SERVER's protocol, not the proxy's protocol
+        # Determine proxy protocol:
+        # 1. Check explicit proxy_protocol field (if exists) - this is the proxy's actual protocol
+        # 2. Check if port is 3005 (test proxy) - always use HTTP for test proxy
+        # 3. Check if client certificates are provided AND exist on disk (indicates HTTPS/mTLS proxy)
+        # 4. Check server protocol as hint (if server uses HTTPS/mTLS, proxy might too)
+        # 5. Fallback to HTTP (for test proxy)
+        proxy_protocol = proxy_client_config.get("proxy_protocol")
+        if not proxy_protocol:
+            # Test proxy (port 3005) always uses HTTP
+            if proxy_port == 3005:
+                proxy_protocol = "http"
+            else:
+                # Check if client certificates are provided for proxy connection
+                cert_file = proxy_client_config.get("cert_file")
+                key_file = proxy_client_config.get("key_file")
+                ca_cert_file = proxy_client_config.get("ca_cert_file")
+                cert_tuple = _build_cert_tuple(cert_file, key_file)
+                
+                if cert_tuple:
+                    # Certificates exist and are valid - proxy uses HTTPS/mTLS
+                    # Certificates in proxy_client are for connecting TO the proxy
+                    # Check if CA cert is provided to determine if it's mTLS
+                    if ca_cert_file and Path(ca_cert_file).exists():
+                        # All certificates (cert, key, CA) provided - likely mTLS
+                        # Use server protocol as hint for mTLS vs HTTPS
+                        server_protocol = proxy_client_config.get("protocol", "http")
+                        proxy_protocol = (
+                            "mtls" if server_protocol == "mtls" else "https"
+                        )
+                    else:
+                        # Only cert and key, no CA - HTTPS
+                        proxy_protocol = "https"
+                else:
+                    # No valid certificates - check server protocol as hint
+                    server_protocol = proxy_client_config.get("protocol", "http")
+                    if server_protocol in ("https", "mtls"):
+                        # Server uses HTTPS/mTLS - proxy might too, but no certs provided
+                        # Default to HTTP for safety (test proxy scenario)
+                        proxy_protocol = "http"
+                    else:
+                        # Server uses HTTP - proxy likely uses HTTP too
+                        proxy_protocol = "http"
+        # If proxy uses HTTPS/mTLS, use https scheme
+        proxy_scheme = "https" if proxy_protocol in ("https", "mtls") else "http"
+        proxy_base_url = f"{proxy_scheme}://{proxy_host}:{proxy_port}"
+        register_endpoint = registration_config.get("register_endpoint", "/register")
+        if register_endpoint.startswith("/proxy/"):
+            proxy_url = f"{proxy_base_url}/proxy"
+        else:
+            proxy_url = proxy_base_url
+    else:
+        proxy_url_candidate = (
+            proxy_registration_config.get("proxy_url")
+            or proxy_registration_config.get("server_url")
+        )
+        if not proxy_url_candidate:
+            logger.warning("No proxy server URL configured")
+            return None
+        proxy_url = str(proxy_url_candidate)
+        register_endpoint = "/register"
+
+    server_config = dict(config.get("server") or {})
+    host = server_config.get("host", "127.0.0.1")
+    port = server_config.get("port", 8000)
+    protocol = server_config.get("protocol", "http")
+    advertised_host = server_config.get("advertised_host") or host
+    scheme = "https" if protocol in ("https", "mtls") else "http"
+    advertised_url = f"{scheme}://{advertised_host}:{port}"
+
+    if use_proxy_client:
+        server_name = proxy_client_config.get("server_id") or proxy_client_config.get(
+            "server_name"
+        )
+        server_name = server_name or f"mcp-adapter-{host}-{port}"
+        capabilities = proxy_client_config.get("capabilities", ["jsonrpc", "health"])
+        metadata = {
+            "uuid": config.get("uuid"),
+            "protocol": protocol,
+            "host": host,
+            "port": port,
+            **(proxy_client_config.get("metadata") or {}),
+        }
+    else:
+        server_name = proxy_registration_config.get(
+            "server_id"
+        ) or proxy_registration_config.get("server_name")
+        server_name = server_name or f"mcp-adapter-{host}-{port}"
+        capabilities = proxy_registration_config.get(
+            "capabilities", ["jsonrpc", "health"]
+        )
+        metadata = {
+            "uuid": config.get("uuid"),
+            "protocol": protocol,
+            "host": host,
+            "port": port,
+            **(proxy_registration_config.get("metadata") or {}),
+        }
+
+    credentials = _resolve_registration_credentials(
+        use_proxy_client, proxy_client_config, proxy_registration_config
+    )
+
+    return RegistrationContext(
+        server_name=server_name,
+        advertised_url=advertised_url,
+        proxy_url=proxy_url,
+        register_endpoint=register_endpoint,
+        capabilities=capabilities,
+        metadata=metadata,
+        use_proxy_client=use_proxy_client,
+        proxy_client_config=proxy_client_config,
+        proxy_registration_config=proxy_registration_config,
+        credentials=credentials,
+    )
+
+
+def resolve_runtime_credentials(
+    use_proxy_client: bool,
+    proxy_client_config: Dict[str, Any],
+    proxy_registration_config: Dict[str, Any],
+) -> ProxyCredentials:
+    """Return credentials for runtime interactions (heartbeat, unregister)."""
+
+    if use_proxy_client:
+        cert_tuple = _build_cert_tuple(
+            proxy_client_config.get("cert_file"),
+            proxy_client_config.get("key_file"),
+        )
+        proxy_protocol = proxy_client_config.get("protocol", "http")
+        ca_cert = proxy_client_config.get("ca_cert_file")
+
+        verify: Union[bool, str] = True
+        if proxy_protocol == "http":
+            verify = False
+        elif ca_cert:
+            verify = ca_cert
+
+        return ProxyCredentials(cert=cert_tuple, verify=verify)
+
+    return _resolve_registration_credentials(False, {}, proxy_registration_config)
+
+
+def resolve_heartbeat_settings(
+    use_proxy_client: bool,
+    proxy_client_config: Dict[str, Any],
+    proxy_registration_config: Dict[str, Any],
+) -> HeartbeatSettings:
+    """Compute heartbeat interval and endpoint."""
+
+    if use_proxy_client:
+        heartbeat_config = proxy_client_config.get("heartbeat") or {}
+        interval = int(heartbeat_config.get("interval", 30))
+        endpoint = heartbeat_config.get("endpoint", "/heartbeat")
+    else:
+        heartbeat_config = proxy_registration_config.get("heartbeat") or {}
+        interval = int(
+            heartbeat_config.get(
+                "interval", proxy_registration_config.get("heartbeat_interval", 30)
+            )
+        )
+        endpoint = "/heartbeat"
+
+    return HeartbeatSettings(interval=interval, endpoint=endpoint)
+
+
+def resolve_unregister_endpoint(
+    use_proxy_client: bool,
+    proxy_client_config: Dict[str, Any],
+) -> str:
+    """Get unregister endpoint path."""
+
+    if use_proxy_client:
+        registration_config = proxy_client_config.get("registration") or {}
+        endpoint = registration_config.get("unregister_endpoint")
+        if endpoint:
+            return str(endpoint)
+        return "/unregister"
+    return "/unregister"
+
+
+def _resolve_registration_credentials(
+    use_proxy_client: bool,
+    proxy_client_config: Dict[str, Any],
+    proxy_registration_config: Dict[str, Any],
+) -> ProxyCredentials:
+    if use_proxy_client:
+        # Use same logic as resolve_runtime_credentials for consistency
+        # Check if proxy itself uses HTTPS/mTLS and requires certificates
+        cert_tuple = _build_cert_tuple(
+            proxy_client_config.get("cert_file"),
+            proxy_client_config.get("key_file"),
+        )
+        # Determine proxy protocol (same logic as in prepare_registration_context)
+        proxy_protocol = proxy_client_config.get("proxy_protocol")
+        if not proxy_protocol:
+            # Get proxy port for test proxy detection
+            proxy_port = proxy_client_config.get("port", 3005)
+            # Test proxy (port 3005) always uses HTTP
+            if proxy_port == 3005:
+                proxy_protocol = "http"
+            else:
+                # Check if client certificates are provided for proxy connection
+                cert_file = proxy_client_config.get("cert_file")
+                key_file = proxy_client_config.get("key_file")
+                ca_cert_file = proxy_client_config.get("ca_cert_file")
+                cert_tuple = _build_cert_tuple(cert_file, key_file)
+                
+                if cert_tuple:
+                    # Certificates exist and are valid - proxy uses HTTPS/mTLS
+                    # Check if CA cert is provided to determine if it's mTLS
+                    if ca_cert_file and Path(ca_cert_file).exists():
+                        # All certificates (cert, key, CA) provided - likely mTLS
+                        # Use server protocol as hint for mTLS vs HTTPS
+                        server_protocol = proxy_client_config.get("protocol", "http")
+                        proxy_protocol = (
+                            "mtls" if server_protocol == "mtls" else "https"
+                        )
+                    else:
+                        # Only cert and key, no CA - HTTPS
+                        proxy_protocol = "https"
+                else:
+                    # No valid certificates - check server protocol as hint
+                    server_protocol = proxy_client_config.get("protocol", "http")
+                    if server_protocol in ("https", "mtls"):
+                        # Server uses HTTPS/mTLS - proxy might too, but no certs provided
+                        # Default to HTTP for safety (test proxy scenario)
+                        proxy_protocol = "http"
+                    else:
+                        # Server uses HTTP - proxy likely uses HTTP too
+                        proxy_protocol = "http"
+        ca_cert = proxy_client_config.get("ca_cert_file")
+
+        verify: Union[bool, str] = True
+        if proxy_protocol == "http":
+            # HTTP proxy doesn't need certificates
+            verify = False
+        elif proxy_protocol in ("https", "mtls"):
+            # HTTPS/mTLS proxy requires certificates
+            if ca_cert:
+                verify = ca_cert
+            elif proxy_protocol == "mtls":
+                # mTLS requires CA cert
+                verify = True  # Will fail if no CA, but that's expected
+            else:
+                # HTTPS can use system CA store
+                verify = True
+
+        return ProxyCredentials(cert=cert_tuple, verify=verify)
+
+    cert_config = proxy_registration_config.get("certificate") or {}
+    ssl_config = proxy_registration_config.get("ssl") or {}
+
+    cert_tuple = _build_cert_tuple(
+        cert_config.get("cert_file"),
+        cert_config.get("key_file"),
+    )
+
+    verify: Union[bool, str] = True
+    ca_cert = ssl_config.get("ca_cert")
+    verify_mode = ssl_config.get("verify_mode", "CERT_REQUIRED")
+    if verify_mode == "CERT_NONE":
+        verify = False
+    elif ca_cert:
+        verify = ca_cert
+
+    return ProxyCredentials(cert=cert_tuple, verify=verify)
+
+
+def _build_cert_tuple(
+    cert_file: Optional[str],
+    key_file: Optional[str],
+) -> Optional[Tuple[str, str]]:
+    if not cert_file or not key_file:
+        return None
+
+    cert_path = Path(cert_file)
+    key_path = Path(key_file)
+    if not cert_path.exists() or not key_path.exists():
+        return None
+
+    return (str(cert_path.absolute()), str(key_path.absolute()))

mcp_proxy_adapter/api/core/registration_manager.py

@@ -0,0 +1,307 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Registration management utilities for MCP Proxy Adapter API.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, List, Optional
+
+from mcp_proxy_adapter.client.jsonrpc_client import JsonRpcClient
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+from mcp_proxy_adapter.api.core.registration_context import (
+    HeartbeatSettings,
+    ProxyCredentials,
+    RegistrationContext,
+    prepare_registration_context,
+    resolve_heartbeat_settings,
+    resolve_runtime_credentials,
+    resolve_unregister_endpoint,
+)
+from mcp_proxy_adapter.api.core.registration_tasks import (
+    create_heartbeat_task,
+    unregister_from_proxy as unregister_task,
+)
+
+
+class RegistrationManager:
+    """Manager for proxy registration functionality using JsonRpcClient."""
+
+    def __init__(self) -> None:
+        """Initialize registration manager."""
+        self.logger = get_global_logger()
+        self.registered = False
+        self.registration_task: Optional[asyncio.Task] = None
+        self.server_name: Optional[str] = None
+        self.server_url: Optional[str] = None
+        self.proxy_url: Optional[str] = None
+        self.capabilities: List[str] = []
+        self.metadata: Dict[str, Any] = {}
+        self.config: Optional[Dict[str, Any]] = None
+        self._use_proxy_client = False
+        self._proxy_client_config: Dict[str, Any] = {}
+        self._proxy_registration_config: Dict[str, Any] = {}
+        self._registration_credentials: Optional[ProxyCredentials] = None
+        self._runtime_credentials: Optional[ProxyCredentials] = None
+        self._register_endpoint: str = "/register"
+        self._heartbeat_settings: Optional[HeartbeatSettings] = None
+
+    async def register_with_proxy(self, config: Dict[str, Any]) -> bool:
+        """
+        Register this server with the proxy using JsonRpcClient.
+
+        Supports both ``proxy_client`` (SimpleConfig format) and ``proxy_registration`` (legacy format).
+        Registration is controlled by ``registration.auto_on_startup`` rather than ``proxy_client.enabled``.
+        """
+
+        context = prepare_registration_context(config, self.logger)
+        if context is None:
+            return True
+
+        self._apply_context(context, config)
+
+        proxy_url = self.proxy_url
+        assert proxy_url is not None
+        assert self.server_name is not None
+        assert self.server_url is not None
+
+        # Parse proxy URL to extract protocol, host, and port
+        from urllib.parse import urlparse
+
+        parsed = urlparse(proxy_url)
+        proxy_protocol = parsed.scheme or "http"
+        proxy_host = parsed.hostname or "localhost"
+        proxy_port = parsed.port or (443 if proxy_protocol == "https" else 80)
+
+        # Extract client certificate paths from credentials if available
+        client_cert = None
+        client_key = None
+        client_ca = None
+        if context.credentials.cert:
+            client_cert, client_key = context.credentials.cert
+        if isinstance(context.credentials.verify, str):
+            client_ca = context.credentials.verify
+
+        self.logger.debug(
+            "Creating JsonRpcClient: protocol=%s, host=%s, port=%s, cert=%s, ca=%s",
+            proxy_protocol,
+            proxy_host,
+            proxy_port,
+            client_cert is not None,
+            client_ca is not None,
+        )
+        if client_cert:
+            self.logger.debug("   Client cert: %s, key: %s", client_cert, client_key)
+        if client_ca:
+            self.logger.debug("   CA cert: %s", client_ca)
+
+        client = JsonRpcClient(
+            protocol=proxy_protocol,
+            host=proxy_host,
+            port=proxy_port,
+            cert=client_cert,
+            key=client_key,
+            ca=client_ca,
+        )
+
+        async def _register() -> Dict[str, Any]:
+            self._log_credentials("🔐 Registration SSL config", context.credentials)
+            self.logger.info(f"📡 Connecting to proxy: {proxy_url}")
+            self.logger.debug(
+                "   Endpoint: %s, Server: %s -> %s",
+                self._register_endpoint,
+                self.server_name,
+                self.server_url,
+            )
+            # Note: cert and verify are already set in JsonRpcClient constructor
+            # but we pass them again for explicit override if needed
+            return await client.register_with_proxy(
+                proxy_url=proxy_url,
+                server_name=context.server_name,
+                server_url=context.advertised_url,
+                capabilities=self.capabilities,
+                metadata=self.metadata,
+                cert=context.credentials.cert,
+                verify=context.credentials.verify,
+            )
+
+        max_retries = 5
+        retry_delay = 2
+
+        try:
+            for attempt in range(max_retries):
+                try:
+                    registration_response = await _register()
+                    if registration_response is not None:
+                        self.logger.debug(
+                            "Proxy registration response payload: %s",
+                            registration_response,
+                        )
+                        self.logger.info(
+                            "✅ Successfully registered with proxy as %s -> %s",
+                            self.server_name,
+                            self.server_url,
+                        )
+                        self.registered = True
+                        return True
+                except Exception as exc:  # noqa: BLE001
+                    full_error = self._format_httpx_error(exc)
+                    if attempt < max_retries - 1:
+                        self.logger.warning(
+                            "⚠️  Registration attempt %s/%s failed: %s. Retrying in %ss...",
+                            attempt + 1,
+                            max_retries,
+                            full_error,
+                            retry_delay,
+                        )
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 2
+                    else:
+                        self.logger.error(
+                            "❌ Failed to register with proxy after %s attempts: %s",
+                            max_retries,
+                            full_error,
+                        )
+                        return False
+            # If we get here, all retries failed
+            return False
+        except Exception as exc:  # noqa: BLE001
+            self.logger.error(f"❌ Registration error: {exc}")
+            return False
+        finally:
+            await client.close()
+
+    async def start_heartbeat(self, _config: Dict[str, Any]) -> None:
+        """Start heartbeat task using JsonRpcClient."""
+
+        if not self._can_start_tasks() or not self.registered:
+            return
+
+        credentials = resolve_runtime_credentials(
+            self._use_proxy_client,
+            self._proxy_client_config,
+            self._proxy_registration_config,
+        )
+        settings = resolve_heartbeat_settings(
+            self._use_proxy_client,
+            self._proxy_client_config,
+            self._proxy_registration_config,
+        )
+        self._runtime_credentials = credentials
+        self._heartbeat_settings = settings
+
+        heartbeat_url = f"{self.proxy_url}{settings.endpoint}"
+        self.logger.info(
+            "💓 Starting heartbeat task (interval: %ss)", settings.interval
+        )
+
+        assert self.server_name is not None
+        assert self.server_url is not None
+
+        self.registration_task = create_heartbeat_task(
+            proxy_url=heartbeat_url,
+            server_name=self.server_name,
+            server_url=self.server_url,
+            capabilities=self.capabilities,
+            metadata=self.metadata,
+            settings=settings,
+            credentials=credentials,
+            logger=self.logger,
+        )
+
+    async def stop(self) -> None:
+        """Stop registration manager and unregister from proxy."""
+
+        if self.registration_task:
+            self.registration_task.cancel()
+            try:
+                await self.registration_task
+            except asyncio.CancelledError:
+                pass
+            self.registration_task = None
+
+        if not (self.registered and self._can_start_tasks() and self.config):
+            self.registered = False
+            return
+
+        credentials = self._runtime_credentials or resolve_runtime_credentials(
+            self._use_proxy_client,
+            self._proxy_client_config,
+            self._proxy_registration_config,
+        )
+        endpoint = resolve_unregister_endpoint(
+            self._use_proxy_client,
+            self._proxy_client_config,
+        )
+
+        assert self.proxy_url is not None
+        assert self.server_name is not None
+
+        try:
+            await unregister_task(
+                proxy_url=self.proxy_url,
+                server_name=self.server_name,
+                endpoint=endpoint,
+                credentials=credentials,
+                logger=self.logger,
+            )
+        except Exception as exc:  # noqa: BLE001
+            self.logger.error(f"Error unregistering from proxy: {exc}")
+        finally:
+            self.registered = False
+
+    def _apply_context(
+        self, context: RegistrationContext, config: Dict[str, Any]
+    ) -> None:
+        self.server_name = context.server_name
+        self.server_url = context.advertised_url
+        self.proxy_url = context.proxy_url
+        self.capabilities = list(context.capabilities)
+        self.metadata = dict(context.metadata)
+        self.config = config
+        self._use_proxy_client = context.use_proxy_client
+        self._proxy_client_config = context.proxy_client_config
+        self._proxy_registration_config = context.proxy_registration_config
+        self._registration_credentials = context.credentials
+        self._runtime_credentials = None
+        self._register_endpoint = context.register_endpoint
+
+    def _log_credentials(self, prefix: str, credentials: ProxyCredentials) -> None:
+        self.logger.info(
+            "%s: cert=%s, verify=%s",
+            prefix,
+            credentials.cert is not None,
+            credentials.verify,
+        )
+        if credentials.cert:
+            self.logger.debug("   Client cert: %s, key: %s", *credentials.cert)
+        if isinstance(credentials.verify, str):
+            self.logger.debug("   CA cert: %s", credentials.verify)
+
+    def _format_httpx_error(self, exc: Exception) -> str:
+        import httpx
+
+        error_msg = str(exc) or type(exc).__name__
+        details: List[str] = [f"type={type(exc).__name__}"]
+
+        if isinstance(exc, httpx.HTTPStatusError):
+            details.append(f"status={exc.response.status_code}")
+            try:
+                details.append(f"response={exc.response.text[:200]}")
+            except Exception:  # noqa: BLE001
+                pass
+        elif isinstance(exc, httpx.ConnectError):
+            details.append("connection_failed")
+            if hasattr(exc, "request"):
+                details.append(f"url={exc.request.url}")
+        elif isinstance(exc, httpx.TimeoutException):
+            details.append("timeout")
+
+        return f"{error_msg} ({', '.join(details)})" if details else error_msg
+
+    def _can_start_tasks(self) -> bool:
+        return bool(self.proxy_url and self.server_name and self.server_url)