mcp-proxy-adapter 6.6.8__py3-none-any.whl → 6.7.0__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -41,6 +41,81 @@ from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.custom_openapi import custom_openapi_with_fallback
 
 
+def _determine_registration_url(config: Dict[str, Any]) -> str:
+    """
+    Determine the registration URL for proxy registration.
+    
+    Logic:
+    1. Protocol: registration.protocol > server.protocol > fallback to http
+    2. Host: public_host > hostname (if server.host is 0.0.0.0/127.0.0.1) > server.host
+    3. Port: public_port > server.port
+    
+    Args:
+        config: Application configuration
+        
+    Returns:
+        Complete registration URL
+    """
+    import os
+    import socket
+    
+    # Get server configuration
+    server_config = config.get("server", {})
+    server_host = server_config.get("host", "0.0.0.0")
+    server_port = server_config.get("port", 8000)
+    server_protocol = server_config.get("protocol", "http")
+    
+    # Get registration configuration
+    reg_cfg = config.get("registration", config.get("proxy_registration", {}))
+    public_host = reg_cfg.get("public_host")
+    public_port = reg_cfg.get("public_port")
+    registration_protocol = reg_cfg.get("protocol")
+    
+    # Determine protocol
+    if registration_protocol:
+        # Use protocol from registration configuration
+        # Convert mtls to https for URL construction (mTLS is still HTTPS)
+        protocol = "https" if registration_protocol == "mtls" else registration_protocol
+        logger.info(f"🔍 Using registration.protocol: {registration_protocol} -> {protocol}")
+    else:
+        # Fallback to server protocol
+        verify_client = config.get("transport", {}).get("verify_client", False)
+        ssl_enabled = server_protocol in ["https", "mtls"] or verify_client
+        protocol = "https" if ssl_enabled else "http"
+        logger.info(f"⚠️  Fallback to server.protocol: {server_protocol} -> {protocol} (verify_client={verify_client})")
+    
+    # Determine host
+    if not public_host:
+        if server_host in ("0.0.0.0", "127.0.0.1"):
+            # Try to get hostname, fallback to docker host addr
+            try:
+                hostname = socket.gethostname()
+                # Use hostname if it's not localhost
+                if hostname and hostname not in ("localhost", "127.0.0.1"):
+                    resolved_host = hostname
+                else:
+                    resolved_host = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
+            except Exception:
+                resolved_host = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
+        else:
+            resolved_host = server_host
+    else:
+        resolved_host = public_host
+        
+    # Determine port
+    resolved_port = public_port or server_port
+    
+    # Build URL
+    server_url = f"{protocol}://{resolved_host}:{resolved_port}"
+    
+    logger.info(
+        "🔍 Registration URL selection: server_host=%s, server_port=%s, public_host=%s, public_port=%s, protocol=%s, resolved_host=%s, resolved_port=%s, server_url=%s",
+        server_host, server_port, public_host, public_port, protocol, resolved_host, resolved_port, server_url
+    )
+    
+    return server_url
+
+
 def create_lifespan(config_path: Optional[str] = None):
     """
     Create lifespan manager for the FastAPI application.
@@ -81,46 +156,27 @@ def create_lifespan(config_path: Optional[str] = None):
         if not server_port:
             raise ValueError("server.port is required")
 
-        reg_cfg = config.get("registration", {})
-        public_host = reg_cfg.get("public_host")
-        public_port = reg_cfg.get("public_port")
-
-        # Check SSL configuration from new structure
-        # Priority: registration.protocol > server.protocol > fallback to http
-        reg_cfg = config.get("registration", {})
-        registration_protocol = reg_cfg.get("protocol")
-        server_protocol = config.get("server.protocol", "http")
-        
-        if registration_protocol:
-            # Use protocol from registration configuration
-            # Convert mtls to https for URL construction (mTLS is still HTTPS)
-            protocol = "https" if registration_protocol == "mtls" else registration_protocol
-            logger.info(f"🔍 Using registration.protocol: {registration_protocol} -> {protocol}")
-        else:
-            # Fallback to server protocol
-            verify_client = config.get("transport.verify_client", False)
-            ssl_enabled = server_protocol in ["https", "mtls"] or verify_client
-            protocol = "https" if ssl_enabled else "http"
-            logger.info(f"⚠️  Fallback to server.protocol: {server_protocol} -> {protocol} (verify_client={verify_client})")
-
-        import os
-        docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
-        target_host = public_host or (docker_host_addr if server_host == "0.0.0.0" else server_host)
-        target_port = public_port or server_port
-        early_server_url = f"{protocol}://{target_host}:{target_port}"
+        # Determine registration URL using unified logic
+        early_server_url = _determine_registration_url(config)
         try:
-            from mcp_proxy_adapter.core.proxy_registration import (
-                proxy_registration_manager,
+            from mcp_proxy_adapter.core.async_proxy_registration import (
+                initialize_async_registration,
+                start_async_registration,
             )
 
-            if proxy_registration_manager is not None:
-                proxy_registration_manager.set_server_url(early_server_url)
-                logger.info(
-                    "🔍 Early injection of server_url for registration: %s",
-                    early_server_url,
-                )
+            # Initialize async registration manager
+            async_manager = initialize_async_registration(config)
+            logger.info(
+                "🔍 Initialized async registration manager with server_url: %s",
+                early_server_url,
+            )
+            
+            # Start async registration in background thread
+            start_async_registration(early_server_url)
+            logger.info("🚀 Started async proxy registration and heartbeat thread")
+            
         except Exception as e:
-            logger.error(f"Failed to inject early server_url: {e}")
+            logger.error(f"Failed to initialize async registration: {e}")
 
         # Initialize system using unified logic (may perform registration)
         if config_path:
@@ -142,57 +198,29 @@ def create_lifespan(config_path: Optional[str] = None):
             server_host = server_config.get("host", "0.0.0.0")
             server_port = server_config.get("port", 8000)
 
-            reg_cfg = final_config.get("registration", final_config.get("proxy_registration", {}))
-            public_host = reg_cfg.get("public_host")
-            public_port = reg_cfg.get("public_port")
-
-            # Determine protocol using the new configuration structure
-            # Priority: registration.protocol > server.protocol > fallback to http
-            reg_cfg = final_config.get("registration", final_config.get("proxy_registration", {}))
-            registration_protocol = reg_cfg.get("protocol")
-            server_protocol = final_config.get("server", {}).get("protocol", "http")
+            # Determine registration URL using unified logic
+            server_url = _determine_registration_url(final_config)
             
-            if registration_protocol:
-                # Use protocol from registration configuration
-                # Convert mtls to https for URL construction (mTLS is still HTTPS)
-                protocol = "https" if registration_protocol == "mtls" else registration_protocol
-                logger.info(f"🔍 Using registration.protocol: {registration_protocol} -> {protocol}")
-            else:
-                # Fallback to server protocol
-                verify_client_cfg = final_config.get("transport", {}).get("verify_client", False)
-                ssl_enabled_final = server_protocol in ["https", "mtls"] or verify_client_cfg
-                protocol = "https" if ssl_enabled_final else "http"
-                logger.info(f"⚠️  Fallback to server.protocol: {server_protocol} -> {protocol} (verify_client={verify_client_cfg})")
-
-            import os
-            docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
-            resolved_host = public_host or (docker_host_addr if server_host == "0.0.0.0" else server_host)
-            resolved_port = public_port or server_port
-            server_url = f"{protocol}://{resolved_host}:{resolved_port}"
-
-            logger.info(
-                "🔍 Registration URL selection: server_host=%s, server_port=%s, public_host=%s, public_port=%s, protocol=%s",
-                server_host,
-                server_port,
-                public_host,
-                public_port,
-                protocol,
-            )
+            # Update async registration manager with final server URL
             try:
-                print(
-                    "🔍 Registration URL selection (print):",
-                    {
-                        "server_host": server_host,
-                        "server_port": server_port,
-                        "public_host": public_host,
-                        "public_port": public_port,
-                        "protocol": protocol,
-                    },
+                from mcp_proxy_adapter.core.async_proxy_registration import (
+                    get_async_registration_manager,
                 )
-            except Exception:
-                pass
-
-            logger.debug("Registration server_url resolved to: %s", server_url)
+                
+                async_manager = get_async_registration_manager()
+                if async_manager:
+                    async_manager.set_server_url(server_url)
+                    logger.info(f"🔍 Updated async registration manager with final server_url: {server_url}")
+                    
+                    # Get current status
+                    status = async_manager.get_status()
+                    logger.info(f"📊 Registration status: {status}")
+                else:
+                    logger.warning("Async registration manager not available")
+                    
+            except Exception as e:
+                logger.error(f"Failed to update async registration manager: {e}")
+            
             try:
                 print("🔍 Registration server_url resolved to (print):", server_url)
             except Exception:
@@ -227,12 +255,30 @@ def create_lifespan(config_path: Optional[str] = None):
         # Shutdown events
         logger.info("Application shutting down")
 
-        # Unregister from proxy if enabled
-        unregistration_success = await unregister_from_proxy()
-        if unregistration_success:
-            logger.info("✅ Proxy unregistration completed successfully")
-        else:
-            logger.warning("⚠️ Proxy unregistration failed or was disabled")
+        # Stop async registration manager (this will also unregister)
+        try:
+            from mcp_proxy_adapter.core.async_proxy_registration import (
+                stop_async_registration,
+                get_registration_status,
+            )
+            
+            # Get final status before stopping
+            final_status = get_registration_status()
+            logger.info(f"📊 Final registration status: {final_status}")
+            
+            # Stop async registration (this will also unregister)
+            stop_async_registration()
+            logger.info("✅ Async registration manager stopped successfully")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to stop async registration: {e}")
+            
+            # Fallback to old unregistration method
+            unregistration_success = await unregister_from_proxy()
+            if unregistration_success:
+                logger.info("✅ Fallback proxy unregistration completed successfully")
+            else:
+                logger.warning("⚠️ Fallback proxy unregistration failed or was disabled")
 
     return lifespan
 

mcp_proxy_adapter/commands/__init__.py

@@ -24,6 +24,9 @@ from mcp_proxy_adapter.commands.echo_command import EchoCommand
 from mcp_proxy_adapter.commands.proxy_registration_command import (
     ProxyRegistrationCommand,
 )
+from mcp_proxy_adapter.commands.registration_status_command import (
+    RegistrationStatusCommand,
+)
 
 __all__ = [
     "Command",
@@ -43,4 +46,5 @@ __all__ = [
     "RoleTestCommand",
     "EchoCommand",
     "ProxyRegistrationCommand",
+    "RegistrationStatusCommand",
 ]

mcp_proxy_adapter/commands/registration_status_command.py

@@ -0,0 +1,119 @@
+"""
+Registration Status Command
+
+This command provides information about the current proxy registration status,
+including async registration state, heartbeat status, and statistics.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from typing import Dict, Any
+from dataclasses import dataclass
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+from mcp_proxy_adapter.core.logging import logger
+
+
+@dataclass
+class RegistrationStatusCommandResult(SuccessResult):
+    """Result of registration status command."""
+
+    status: Dict[str, Any]
+    message: str = "Registration status retrieved successfully"
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary."""
+        return {
+            "success": True,
+            "status": self.status,
+            "message": self.message,
+        }
+
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for result."""
+        return {
+            "type": "object",
+            "properties": {
+                "success": {
+                    "type": "boolean",
+                    "description": "Whether the command was successful",
+                },
+                "status": {
+                    "type": "object",
+                    "description": "Registration status information",
+                    "properties": {
+                        "state": {"type": "string", "description": "Current registration state"},
+                        "server_key": {"type": "string", "description": "Server key if registered"},
+                        "last_attempt": {"type": "number", "description": "Timestamp of last registration attempt"},
+                        "last_success": {"type": "number", "description": "Timestamp of last successful registration"},
+                        "last_error": {"type": "string", "description": "Last error message"},
+                        "attempt_count": {"type": "integer", "description": "Total registration attempts"},
+                        "success_count": {"type": "integer", "description": "Total successful registrations"},
+                        "heartbeat_enabled": {"type": "boolean", "description": "Whether heartbeat is enabled"},
+                        "heartbeat_interval": {"type": "integer", "description": "Heartbeat interval in seconds"},
+                        "thread_alive": {"type": "boolean", "description": "Whether registration thread is alive"},
+                    },
+                },
+                "message": {"type": "string", "description": "Result message"},
+            },
+            "required": ["success", "status", "message"],
+        }
+
+
+class RegistrationStatusCommand(Command):
+    """Command to get proxy registration status."""
+
+    name = "registration_status"
+    descr = "Get current proxy registration status and statistics"
+    category = "proxy"
+    author = "Vasiliy Zdanovskiy"
+    email = "vasilyvz@gmail.com"
+
+    async def execute(self, **kwargs) -> RegistrationStatusCommandResult:
+        """
+        Execute registration status command.
+
+        Returns:
+            RegistrationStatusCommandResult with current status
+        """
+        logger.info("Executing registration status command")
+
+        try:
+            from mcp_proxy_adapter.core.async_proxy_registration import (
+                get_registration_status,
+            )
+
+            status = get_registration_status()
+            
+            logger.info(f"Registration status retrieved: {status}")
+
+            return RegistrationStatusCommandResult(
+                status=status,
+                message="Registration status retrieved successfully"
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to get registration status: {e}")
+            
+            error_status = {
+                "state": "error",
+                "error": str(e),
+                "thread_alive": False
+            }
+            
+            return RegistrationStatusCommandResult(
+                status=error_status,
+                message=f"Failed to get registration status: {e}"
+            )
+
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for command parameters."""
+        return {
+            "type": "object",
+            "properties": {},
+            "additionalProperties": False,
+        }

mcp_proxy_adapter/core/app_runner.py

@@ -16,6 +16,7 @@ from typing import Dict, Any, List, Optional
 from fastapi import FastAPI
 
 from mcp_proxy_adapter.core.logging import get_logger
+from mcp_proxy_adapter.core.signal_handler import setup_signal_handling, is_shutdown_requested
 
 logger = get_logger("app_runner")
 
@@ -250,6 +251,30 @@ class ApplicationRunner:
                 print(f"  - {error}", file=sys.stderr)
             sys.exit(1)
 
+        # Setup signal handling for graceful shutdown
+        def shutdown_callback():
+            """Callback for graceful shutdown with proxy unregistration."""
+            print("\n🛑 Graceful shutdown initiated...")
+            try:
+                from mcp_proxy_adapter.core.async_proxy_registration import (
+                    stop_async_registration,
+                    get_registration_status,
+                )
+                
+                # Get final status
+                final_status = get_registration_status()
+                print(f"📊 Final registration status: {final_status}")
+                
+                # Stop async registration (this will unregister from proxy)
+                stop_async_registration()
+                print("✅ Proxy unregistration completed")
+                
+            except Exception as e:
+                print(f"❌ Error during shutdown: {e}")
+        
+        setup_signal_handling(shutdown_callback)
+        print("🔧 Signal handling configured for graceful shutdown")
+
         # Setup hooks
         self.setup_hooks()
 
@@ -276,14 +301,16 @@ class ApplicationRunner:
             import asyncio
 
             print(f"🚀 Starting server on {host}:{port}")
-            print("   Use Ctrl+C to stop the server")
+            print("🛑 Use Ctrl+C or send SIGTERM for graceful shutdown")
             print("=" * 60)
 
             # Run with hypercorn
             asyncio.run(hypercorn.asyncio.serve(self.app, **server_kwargs))
 
         except KeyboardInterrupt:
-            print("\n🛑 Server stopped by user")
+            print("\n🛑 Server stopped by user (Ctrl+C)")
+            if is_shutdown_requested():
+                print("✅ Graceful shutdown completed")
         except Exception as e:
             print(f"\n❌ Failed to start server: {e}", file=sys.stderr)
             sys.exit(1)