778 lines
39 KiB
Python
778 lines
39 KiB
Python
"""
|
|
MCP Controller - Handle MCP Streamable HTTP protocol SSE connections and messages
|
|
Supports both service_id (UUID) and slug_name service identifiers
|
|
"""
|
|
|
|
from typing import Optional
|
|
from datetime import datetime, timezone
|
|
from sqlalchemy import false
|
|
from starlette.requests import Request
|
|
from starlette.responses import Response
|
|
import asyncio
|
|
import time
|
|
import hashlib
|
|
import re
|
|
from mcp.server.sse import SseServerTransport
|
|
from mcp.server.streamable_http import StreamableHTTPServerTransport
|
|
from mcp.server.lowlevel import Server
|
|
from services.api_service.services.mcp_server_factory import McpServerFactory
|
|
from services.common.logging_config import get_logger
|
|
from services.api_service.repositories.user_apikey_repository import UserApiKeyRepository
|
|
from services.api_service.repositories.user_repository import UserRepository
|
|
from services.api_service.repositories.resource_group_repository import ResourceGroupMapRepository
|
|
|
|
from services.api_service.utils.connection_manager import connection_manager
|
|
from services.common.database import get_db
|
|
from services.common.config import Config
|
|
from services.api_service.utils.mcp_event_store import RedisEventStore
|
|
|
|
logger = get_logger(__name__)
|
|
|
|
|
|
class McpController:
|
|
"""MCP Streamable HTTP controller class - Handle SSE connections and message routing"""
|
|
|
|
def __init__(self):
|
|
self.sse = SseServerTransport("/messages/")
|
|
# StreamableHTTP session persistence: store transport and server task keyed by (service_id, user_id)
|
|
self._http_transports: dict[str, StreamableHTTPServerTransport] = {}
|
|
self._http_server_tasks: dict[str, asyncio.Task] = {}
|
|
self._http_servers: dict[str, Server] = {}
|
|
self.server_factory = McpServerFactory()
|
|
# Session recycling: track idle time and run a background cleanup task
|
|
self._session_last_activity: dict[str, float] = {}
|
|
self._session_gc_task: Optional[asyncio.Task] = None
|
|
self._session_gc_stop_event = asyncio.Event()
|
|
self._session_idle_ttl = getattr(Config, "MCP_SESSION_IDLE_TTL_SECONDS", 900)
|
|
self._session_cleanup_interval = getattr(Config, "MCP_SESSION_CLEANUP_INTERVAL_SECONDS", 60)
|
|
|
|
async def handle_sse_connection(self, request: Request):
|
|
"""Handle MCP Streamable HTTP SSE connection with resume capability."""
|
|
# Get connection identification info
|
|
x_real_ip = request.headers.get("x-real-ip") or request.headers.get("x-forwarded-for")
|
|
client_ip = (x_real_ip.split(",")[0].strip() if x_real_ip else (request.client.host if request.client else "unknown"))
|
|
user_agent = request.headers.get("user-agent", "unknown")
|
|
service_id = None
|
|
|
|
try:
|
|
# Extract service_id from URL path (supports both ID and slug_name)
|
|
service_id = self._extract_service_id(request)
|
|
if not service_id:
|
|
logger.error("Missing service_id parameter or service not found")
|
|
# For SSE connection errors, we need to send response directly via ASGI interface
|
|
await self._send_error_response(request, 400, "Missing service_id parameter or service not found")
|
|
return
|
|
|
|
logger.info(f"Received SSE connection request - Service ID: {service_id}, Client: {client_ip}, UA: {user_agent[:50]}...")
|
|
|
|
# Extract user ID (for billing) - must provide valid apikey
|
|
user_info = self._extract_user_info(request)
|
|
if not user_info:
|
|
logger.error("Missing or invalid apikey, connection rejected")
|
|
await self._send_error_response(request, 401, "Missing or invalid apikey parameter")
|
|
return
|
|
|
|
user_id, apikey_id = user_info
|
|
|
|
# Get apikey for logging (extract first 10 characters for audit)
|
|
apikey = request.query_params.get("apikey", "")
|
|
if not apikey:
|
|
apikey = request.query_params.get("authkey","")
|
|
apikey_for_log = apikey[:10] if apikey else None
|
|
|
|
# Create MCP server instance (pass user_id and apikey_id for billing and logging)
|
|
mcp_server = await self.server_factory.create_server(service_id, user_id, apikey_id)
|
|
|
|
# Register connection to manager
|
|
connection_key = connection_manager.register_connection(service_id, user_id, client_ip)
|
|
|
|
# Establish SSE connection and run MCP server
|
|
async with self.sse.connect_sse(request.scope, request.receive, request._send) as streams:
|
|
logger.info(f"SSE connection established - Service ID: {service_id}, User ID: {user_id}, Client: {client_ip}")
|
|
|
|
# Configure server initialization options
|
|
init_options = mcp_server.create_initialization_options()
|
|
init_options.server_name = f"mcp-service-{service_id}"
|
|
|
|
# Add connection recovery hint info
|
|
logger.info(f"Server name set to: {init_options.server_name}")
|
|
logger.info(f"MCP server startup complete, waiting for client messages... (Connection ID: {connection_key})")
|
|
|
|
try:
|
|
# Run MCP server
|
|
await mcp_server.run(streams[0], streams[1], init_options)
|
|
logger.info(f"MCP server run completed - Service ID: {service_id}, User ID: {user_id}")
|
|
except Exception as e:
|
|
logger.error(f"Error occurred during MCP server operation: {str(e)}", exc_info=True)
|
|
finally:
|
|
# Unregister connection
|
|
connection_manager.unregister_connection(connection_key)
|
|
|
|
# SSE connection ended normally via context manager, no additional handling needed
|
|
|
|
except ConnectionError as e:
|
|
logger.warning(f"Connection error - Service ID: {service_id or 'unknown'}, Client: {client_ip}: {str(e)}")
|
|
await self._send_error_response(request, 503, "Connection error")
|
|
except Exception as e:
|
|
logger.error(f"SSE connection handling failed - Service ID: {service_id or 'unknown'}, Client: {client_ip}: {str(e)}", exc_info=True)
|
|
await self._send_error_response(request, 500, f"Internal server error: {str(e)}")
|
|
|
|
async def _send_error_response(self, request: Request, status_code: int, message: str):
|
|
"""Send error response directly through ASGI interface"""
|
|
response_body = message.encode('utf-8')
|
|
await request._send({
|
|
'type': 'http.response.start',
|
|
'status': status_code,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await request._send({
|
|
'type': 'http.response.body',
|
|
'body': response_body,
|
|
})
|
|
|
|
async def handle_sse_connection_asgi(self, request: Request):
|
|
"""Return an ASGI app that handles MCP SSE connections.
|
|
|
|
Starlette Route passes a Request and treats the returned callable as an ASGI app.
|
|
The returned ASGI callable performs the SSE handshake and runs the MCP server.
|
|
"""
|
|
|
|
async def asgi(scope, receive, send):
|
|
req = Request(scope)
|
|
x_real_ip = req.headers.get("x-real-ip") or req.headers.get("x-forwarded-for")
|
|
client_ip = (x_real_ip.split(",")[0].strip() if x_real_ip else (req.client.host if req.client else "unknown"))
|
|
user_agent = req.headers.get("user-agent", "unknown")
|
|
service_id = None
|
|
|
|
try:
|
|
# Extract service_id from URL path (supports both ID and slug_name)
|
|
service_id = self._extract_service_id(req)
|
|
if not service_id:
|
|
response_body = b"Missing service_id parameter or service not found"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 400,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
|
|
logger.info(f"Received SSE connection request - Service ID: {service_id}, Client: {client_ip}, UA: {user_agent[:50]}...")
|
|
|
|
# Extract user ID (for billing) - must provide valid apikey
|
|
user_info = self._extract_user_info(req)
|
|
if not user_info:
|
|
response_body = b"Missing or invalid apikey parameter"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 401,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
|
|
user_id, apikey_id = user_info
|
|
|
|
# Check invoke permission
|
|
if not self._check_invoke_permission(user_id, service_id):
|
|
response_body = b"Invoke permission denied"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 403,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
|
|
# Create MCP server instance (pass user_id and apikey_id for billing and logging)
|
|
mcp_server = await self.server_factory.create_server(service_id, user_id, apikey_id)
|
|
|
|
# Register connection to manager
|
|
connection_key = connection_manager.register_connection(service_id, user_id, client_ip)
|
|
|
|
try:
|
|
# Establish SSE connection and run MCP server
|
|
async with self.sse.connect_sse(scope, receive, send) as streams:
|
|
logger.info(f"SSE connection established - Service ID: {service_id}, User ID: {user_id}, Client: {client_ip}")
|
|
|
|
# Configure server initialization options
|
|
init_options = mcp_server.create_initialization_options()
|
|
init_options.server_name = f"mcp-service-{service_id}"
|
|
|
|
logger.info(f"Server name set to: {init_options.server_name}")
|
|
logger.info("MCP server startup complete, waiting for client messages... (ASGI endpoint)")
|
|
|
|
try:
|
|
# Run MCP server
|
|
await mcp_server.run(streams[0], streams[1], init_options)
|
|
logger.info(f"MCP server run completed - Service ID: {service_id}, User ID: {user_id}")
|
|
except asyncio.CancelledError:
|
|
# Client disconnected; treat as normal shutdown
|
|
logger.info(f"SSE client disconnected - Service ID: {service_id}, User ID: {user_id}")
|
|
except Exception as e:
|
|
logger.error(f"Error occurred during MCP server operation: {str(e)}", exc_info=True)
|
|
finally:
|
|
# Unregister connection
|
|
connection_manager.unregister_connection(connection_key)
|
|
|
|
except ConnectionError as e:
|
|
logger.warning(f"Connection error - Service ID: {service_id or 'unknown'}, Client: {client_ip}: {str(e)}")
|
|
response_body = b"Connection error"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 503,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
except Exception as e:
|
|
logger.error(f"SSE connection handling failed - Service ID: {service_id or 'unknown'}, Client: {client_ip}: {str(e)}", exc_info=True)
|
|
response_body = f"Internal server error: {str(e)}".encode('utf-8')
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 500,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
|
|
return asgi
|
|
|
|
async def handle_streamable_http_asgi(self, request: Request):
|
|
"""Return an ASGI app that handles MCP Streamable HTTP (GET/POST/DELETE).
|
|
|
|
Delegate requests to StreamableHTTP's handle_request; use persistent transport and server
|
|
so GET/POST/DELETE interact within the same session, ensuring tools/resources queries
|
|
return to the same SSE stream.
|
|
"""
|
|
|
|
async def asgi(scope, receive, send):
|
|
req = Request(scope)
|
|
x_real_ip = req.headers.get("x-real-ip") or req.headers.get("x-forwarded-for")
|
|
client_ip = (x_real_ip.split(",")[0].strip() if x_real_ip else (req.client.host if req.client else "unknown"))
|
|
user_agent = req.headers.get("user-agent", "unknown")
|
|
service_id = None
|
|
session_key = None
|
|
|
|
try:
|
|
# Extract service_id from URL path (supports both ID and slug_name)
|
|
service_id = self._extract_service_id(req)
|
|
if not service_id:
|
|
response_body = b"Missing service_id parameter or service not found"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 400,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
|
|
logger.info(f"Received StreamableHTTP request - Service ID: {service_id}, Client: {client_ip}, UA: {user_agent[:50]}...")
|
|
|
|
# Security: validate Origin to prevent DNS rebinding (MCP spec requirement)
|
|
origin = req.headers.get('origin')
|
|
if origin and not self._is_origin_allowed(origin, req):
|
|
logger.warning(f"Rejected by Origin validation - Origin: {origin}, Host: {req.url.scheme}://{req.url.netloc}")
|
|
response_body = b"Forbidden: invalid Origin"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 403,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
|
|
# Validate Accept & Content-Type headers according to MCP Streamable HTTP rules
|
|
accept = (req.headers.get('accept') or '').lower()
|
|
content_type = (req.headers.get('content-type') or '').lower()
|
|
if req.method == 'GET':
|
|
if 'text/event-stream' not in accept:
|
|
logger.warning("Missing Accept: text/event-stream for GET SSE")
|
|
response_body = b"Not Acceptable: require text/event-stream"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 406,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
elif req.method == 'POST':
|
|
# Client should list both application/json and text/event-stream
|
|
if not ('application/json' in accept and 'text/event-stream' in accept):
|
|
logger.warning("POST Accept must include application/json and text/event-stream")
|
|
response_body = b"Not Acceptable: require application/json and text/event-stream"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 406,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
# Body must be JSON-RPC payload
|
|
if 'application/json' not in content_type:
|
|
logger.warning("Unsupported Media Type for POST; require application/json")
|
|
response_body = b"Unsupported Media Type: require application/json"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 415,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
|
|
# Extract user ID (for billing) - must provide valid apikey
|
|
user_info = self._extract_user_info(req)
|
|
if not user_info:
|
|
response_body = b"Missing or invalid apikey parameter"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 401,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
user_id, apikey_id = user_info
|
|
if not self._check_invoke_permission(user_id, service_id):
|
|
response_body = b"Invoke permission denied"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 403,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
raw_client_id = req.headers.get('x-client-instance-id') or req.headers.get('x-client-id')
|
|
client_instance_id = (re.sub(r'[^a-zA-Z0-9._-]', '', raw_client_id)[:32]) if raw_client_id else None
|
|
ua = user_agent or ""
|
|
ua_hash = hashlib.sha1(ua.encode('utf-8')).hexdigest()[:8]
|
|
client_fingerprint = client_instance_id or f"{client_ip}:{ua_hash}"
|
|
session_key = f"{service_id}:{user_id}:{client_fingerprint}"
|
|
|
|
# Build connection key for lifecycle management
|
|
connection_key = f"{service_id}:{user_id}:{client_ip}"
|
|
|
|
try:
|
|
# Get or create a persistent StreamableHTTP transport and MCP server
|
|
transport = await self._ensure_http_session(session_key, service_id, user_id, apikey_id)
|
|
logger.debug(f"method: {req.method}, content_type: {content_type}")
|
|
# Note session activity
|
|
self._note_session_activity(session_key)
|
|
|
|
# Ensure transport is connected before delegating (avoid race on first request)
|
|
try:
|
|
await self._wait_transport_ready(transport, timeout_seconds=2.0)
|
|
except TimeoutError:
|
|
logger.error("Transport not ready within timeout; refusing request")
|
|
response_body = b"Service Unavailable: transport not ready"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 503,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
return
|
|
|
|
# Register only on GET (SSE handshake); POST just updates activity
|
|
if req.method == "GET":
|
|
connection_manager.register_connection(service_id, user_id, client_ip)
|
|
logger.debug(f'register connection successful.connection_key is {connection_key}')
|
|
elif req.method == "POST":
|
|
connection_manager.update_activity(connection_key)
|
|
|
|
# Delegate request to transport; GET establishes SSE; POST sends JSON-RPC; DELETE terminates the session
|
|
await transport.handle_request(scope, receive, send)
|
|
|
|
# Update activity after handling (avoid cleaning long-running processing)
|
|
self._note_session_activity(session_key)
|
|
|
|
# If the session has terminated, clean up and unregister
|
|
if transport.is_terminated:
|
|
await self._cleanup_http_session(session_key)
|
|
connection_manager.unregister_connection(connection_key)
|
|
# For explicit DELETE, ensure termination cleanup
|
|
if req.method == "DELETE" and not transport.is_terminated:
|
|
try:
|
|
await transport.terminate()
|
|
except Exception:
|
|
logger.exception("Error terminating transport on DELETE")
|
|
await self._cleanup_http_session(session_key)
|
|
connection_manager.unregister_connection(connection_key)
|
|
finally:
|
|
# Unregister when SSE GET disconnects
|
|
if req.method == "GET":
|
|
connection_manager.unregister_connection(connection_key)
|
|
|
|
except ConnectionError as e:
|
|
logger.warning(f"Connection error - Service ID: {service_id or 'unknown'}, Client: {client_ip}: {str(e)}")
|
|
response_body = b"Connection error"
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 503,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
except Exception as e:
|
|
logger.error(f"StreamableHTTP handling failed - Service ID: {service_id or 'unknown'}, Client: {client_ip}: {str(e)}", exc_info=True)
|
|
response_body = f"Internal server error: {str(e)}".encode('utf-8')
|
|
await send({
|
|
'type': 'http.response.start',
|
|
'status': 500,
|
|
'headers': [
|
|
[b'content-type', b'text/plain'],
|
|
[b'content-length', str(len(response_body)).encode()],
|
|
],
|
|
})
|
|
await send({'type': 'http.response.body', 'body': response_body})
|
|
|
|
return asgi
|
|
|
|
async def _wait_transport_ready(self, transport: StreamableHTTPServerTransport, timeout_seconds: float = 2.0) -> None:
|
|
"""Wait until StreamableHTTP transport is connected and streams are initialized.
|
|
|
|
The underlying transport sets internal streams in connect(); POST/GET handling
|
|
requires these to exist. We poll briefly to avoid race on first request.
|
|
"""
|
|
deadline = time.time() + timeout_seconds
|
|
# Access internal attributes defensively; break once read writer is present
|
|
while True:
|
|
# If terminated, break early
|
|
if transport.is_terminated:
|
|
raise TimeoutError("Transport terminated during wait")
|
|
# Heuristic: writer/reader set once connect() started
|
|
has_read_writer = getattr(transport, "_read_stream_writer", None) is not None
|
|
has_write_reader = getattr(transport, "_write_stream_reader", None) is not None
|
|
if has_read_writer and has_write_reader:
|
|
return
|
|
if time.time() > deadline:
|
|
raise TimeoutError("Transport not ready")
|
|
await asyncio.sleep(0.01)
|
|
|
|
def _is_origin_allowed(self, origin: str, req: Request) -> bool:
|
|
"""Validate Origin header against request host to prevent DNS rebinding.
|
|
|
|
Policy:
|
|
- If Origin is present, it must match the scheme+host of the request URL.
|
|
- Allow common localhost variants (127.0.0.1, localhost) across http/https.
|
|
- If Origin is missing, treat as allowed (native clients may omit it).
|
|
"""
|
|
try:
|
|
if not origin:
|
|
return True
|
|
origin = origin.strip()
|
|
request_host = f"{req.url.scheme}://{req.url.netloc}"
|
|
if origin == request_host:
|
|
return True
|
|
allowed_local_origins = {
|
|
"http://127.0.0.1",
|
|
f"http://127.0.0.1:{req.url.port}" if req.url.port else "http://127.0.0.1",
|
|
"http://localhost",
|
|
f"http://localhost:{req.url.port}" if req.url.port else "http://localhost",
|
|
"https://127.0.0.1",
|
|
f"https://127.0.0.1:{req.url.port}" if req.url.port else "https://127.0.0.1",
|
|
"https://localhost",
|
|
f"https://localhost:{req.url.port}" if req.url.port else "https://localhost",
|
|
}
|
|
return origin in allowed_local_origins
|
|
except Exception:
|
|
logger.exception("Origin validation error")
|
|
return False
|
|
|
|
async def _ensure_http_session(self, session_key: str, service_id: str, user_id: str, apikey_id: str) -> StreamableHTTPServerTransport:
|
|
"""Ensure a persistent StreamableHTTP transport and MCP server exist for the session.
|
|
|
|
- Create or reuse the transport
|
|
- If the server has not been started, start mcp_server.run() within transport.connect()
|
|
"""
|
|
if session_key in self._http_transports:
|
|
transport = self._http_transports[session_key]
|
|
# Start GC task if not started
|
|
self._ensure_session_gc_task()
|
|
# Note activity
|
|
self._note_session_activity(session_key)
|
|
# If the server task exists and is not finished, reuse it
|
|
task = self._http_server_tasks.get(session_key)
|
|
if task and not task.done():
|
|
return transport
|
|
# If no task or the task is finished, restart
|
|
mcp_server = self._http_servers.get(session_key)
|
|
if mcp_server is None:
|
|
mcp_server = await self.server_factory.create_server(service_id, user_id, apikey_id)
|
|
self._http_servers[session_key] = mcp_server
|
|
init_options = mcp_server.create_initialization_options()
|
|
init_options.server_name = f"mcp-service-{service_id}"
|
|
|
|
async def run_server():
|
|
async with transport.connect() as (read_stream, write_stream):
|
|
try:
|
|
await mcp_server.run(read_stream, write_stream, init_options)
|
|
except asyncio.CancelledError:
|
|
logger.info(f"MCP server task cancelled - Service: {service_id}, User: {user_id}")
|
|
except Exception as e:
|
|
logger.error(f"MCP server task error: {e}", exc_info=True)
|
|
|
|
task = asyncio.create_task(run_server())
|
|
self._http_server_tasks[session_key] = task
|
|
return transport
|
|
|
|
# Create transport and server
|
|
event_store = RedisEventStore(namespace=session_key, ttl_seconds=Config.MCP_SESSION_IDLE_TTL_SECONDS)
|
|
transport = StreamableHTTPServerTransport(
|
|
mcp_session_id=None,
|
|
is_json_response_enabled=False,
|
|
event_store=event_store,
|
|
)
|
|
mcp_server = await self.server_factory.create_server(service_id, user_id, apikey_id)
|
|
self._http_transports[session_key] = transport
|
|
self._http_servers[session_key] = mcp_server
|
|
|
|
init_options = mcp_server.create_initialization_options()
|
|
init_options.server_name = f"mcp-service-{service_id}"
|
|
logger.info(f"StreamableHTTP session created - Service: {service_id}, User: {user_id}")
|
|
|
|
# Start GC task if not started and note activity
|
|
self._ensure_session_gc_task()
|
|
self._note_session_activity(session_key)
|
|
|
|
async def run_server():
|
|
async with transport.connect() as (read_stream, write_stream):
|
|
try:
|
|
await mcp_server.run(read_stream, write_stream, init_options)
|
|
except asyncio.CancelledError:
|
|
logger.info(f"MCP server task cancelled - Service: {service_id}, User: {user_id}")
|
|
except Exception as e:
|
|
logger.error(f"MCP server task error: {e}", exc_info=True)
|
|
|
|
task = asyncio.create_task(run_server())
|
|
self._http_server_tasks[session_key] = task
|
|
return transport
|
|
|
|
async def _cleanup_http_session(self, session_key: str) -> None:
|
|
"""Cleanup transport and server task for a terminated session."""
|
|
task = self._http_server_tasks.pop(session_key, None)
|
|
transport = self._http_transports.pop(session_key, None)
|
|
self._http_servers.pop(session_key, None)
|
|
|
|
if task and not task.done():
|
|
try:
|
|
# Terminate transport to prompt server exit
|
|
if transport and not transport.is_terminated:
|
|
await transport.terminate()
|
|
await task
|
|
except Exception:
|
|
logger.exception("Error while waiting for server task to finish")
|
|
|
|
def _extract_service_id(self, request: Request) -> Optional[str]:
|
|
"""Extract service ID from request path, supporting both ID and slug_name."""
|
|
service_identifier = request.path_params.get("service_id")
|
|
if not service_identifier:
|
|
return None
|
|
|
|
# Try to find service by service_identifier, supports both ID and slug_name modes
|
|
db = None
|
|
try:
|
|
from services.api_service.repositories.mcp_service_repository import McpServiceRepository
|
|
from services.common.database import get_db
|
|
|
|
db = next(get_db())
|
|
service_repository = McpServiceRepository(db)
|
|
|
|
# Try to find by ID first
|
|
service = service_repository.get_by_id(service_identifier)
|
|
if service:
|
|
logger.debug(f"Service found (by ID): {service.name} ({service.id})")
|
|
return service.id
|
|
|
|
# If not found by ID, try by slug_name
|
|
service = service_repository.get_by_slug_name(service_identifier)
|
|
if service:
|
|
logger.debug(f"Service found (by slug_name): {service.name} ({service.id})")
|
|
return service.id
|
|
|
|
logger.warning(f"Service not found: {service_identifier}")
|
|
return None
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error occurred while querying service: {str(e)}", exc_info=True)
|
|
return None
|
|
finally:
|
|
if db is not None:
|
|
db.close()
|
|
def _check_invoke_permission(self, user_id: str, service_id: str) -> bool:
|
|
db = None
|
|
try:
|
|
# Create database session
|
|
db = next(get_db())
|
|
user_repo = UserRepository(db)
|
|
# Query user info by apikey
|
|
user = user_repo.get_by_id(user_id)
|
|
if not user:
|
|
logger.warning(f"User not found in database: {user_id[:10]}...")
|
|
return False
|
|
logger.debug(f"Found user record - User ID: {user.id}, group id is: {user.group_id}")
|
|
if user.group_id == "allow-all":
|
|
return True
|
|
elif user.group_id == "deny-all":
|
|
return False
|
|
|
|
resource_group_map_repo = ResourceGroupMapRepository(db)
|
|
resource_groups = resource_group_map_repo.get_by_id(user.group_id)
|
|
if not resource_groups:
|
|
logger.warning(f"Resource group not found for user: {user_id[:10]}...")
|
|
return False
|
|
|
|
# Check if service_id is in resource_groups
|
|
if service_id not in resource_groups:
|
|
logger.warning(f"Service {service_id} not found in user's resource groups: {user_id[:10]}...")
|
|
return False
|
|
|
|
return True
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error occurred while querying user apikey: {str(e)}", exc_info=True)
|
|
return False
|
|
finally:
|
|
if db is not None:
|
|
db.close()
|
|
|
|
|
|
def _extract_user_info(self, request: Request) -> Optional[tuple[str, str]]:
|
|
"""Extract user ID and apikey ID from request by validating apikey parameter."""
|
|
# Get apikey from URL query parameters
|
|
apikey = request.query_params.get("apikey")
|
|
if not apikey:
|
|
apikey = request.query_params.get("authkey")
|
|
if not apikey:
|
|
logger.warning("Apikey not found in URL parameters")
|
|
return None
|
|
|
|
logger.debug(f"Validating apikey: {apikey[:10]}...") # Only log first 10 characters for debugging
|
|
|
|
db = None
|
|
try:
|
|
# Create database session
|
|
db = next(get_db())
|
|
user_apikey_repo = UserApiKeyRepository(db)
|
|
|
|
# Query user info by apikey
|
|
user_apikey = user_apikey_repo.get_by_apikey(apikey)
|
|
if not user_apikey:
|
|
logger.warning(f"Apikey not found in database: {apikey[:10]}...")
|
|
return None
|
|
|
|
logger.debug(f"Found apikey record - User ID: {user_apikey.user_id}, API Key ID: {user_apikey.id}, expiry time: {user_apikey.expire_at}")
|
|
|
|
# Check if apikey is expired
|
|
if user_apikey.expire_at:
|
|
# Ensure timezone consistency
|
|
if user_apikey.expire_at.tzinfo is None:
|
|
expire_at_utc = user_apikey.expire_at.replace(tzinfo=timezone.utc)
|
|
else:
|
|
expire_at_utc = user_apikey.expire_at
|
|
|
|
if expire_at_utc < datetime.now(timezone.utc):
|
|
logger.warning(f"Apikey has expired: {apikey[:10]}..., expiry time: {user_apikey.expire_at}")
|
|
return None
|
|
|
|
|
|
logger.info(f"Apikey validation successful - User ID: {user_apikey.user_id}, API Key ID: {user_apikey.id}")
|
|
return (user_apikey.user_id, user_apikey.id)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error occurred while querying user apikey: {str(e)}", exc_info=True)
|
|
return None
|
|
finally:
|
|
if db is not None:
|
|
db.close()
|
|
|
|
def get_sse_mount_handler(self):
|
|
"""Get SSE message handler for processing requests."""
|
|
return self.sse.handle_post_message
|
|
|
|
def get_streamable_http_handler(self):
|
|
# We no longer return a handler for a persistent instance; if needed, call
|
|
# handle_streamable_http_asgi at the routing layer. This placeholder is
|
|
# retained to avoid external references breaking, but it is not used.
|
|
raise NotImplementedError("Use handle_streamable_http_asgi for StreamableHTTP routes")
|
|
|
|
|
|
def _ensure_session_gc_task(self) -> None:
|
|
"""Start background GC task if not already running."""
|
|
if self._session_gc_task is None or self._session_gc_task.done():
|
|
loop = asyncio.get_running_loop()
|
|
self._session_gc_task = loop.create_task(self._run_session_gc())
|
|
logger.info("Session GC task started")
|
|
|
|
def _note_session_activity(self, session_key: str) -> None:
|
|
"""Update last activity timestamp for a session."""
|
|
self._session_last_activity[session_key] = time.time()
|
|
|
|
async def _run_session_gc(self) -> None:
|
|
"""Background task to recycle idle or terminated sessions."""
|
|
try:
|
|
while not self._session_gc_stop_event.is_set():
|
|
await asyncio.sleep(self._session_cleanup_interval)
|
|
now = time.time()
|
|
stale_keys: list[str] = []
|
|
for key, transport in list(self._http_transports.items()):
|
|
last = self._session_last_activity.get(key, 0)
|
|
idle = (now - last) > self._session_idle_ttl
|
|
task = self._http_server_tasks.get(key)
|
|
active_task = task is not None and not task.done()
|
|
# Only TTL-clean when there is no active task, to avoid killing active SSE sessions
|
|
if transport.is_terminated or (idle and not active_task):
|
|
stale_keys.append(key)
|
|
for key in stale_keys:
|
|
logger.info(f"Recycling session {key} (terminated or idle > {self._session_idle_ttl}s)")
|
|
try:
|
|
await self._cleanup_http_session(key)
|
|
except Exception:
|
|
logger.exception("Error during session cleanup")
|
|
self._session_last_activity.pop(key, None)
|
|
except asyncio.CancelledError:
|
|
pass
|
|
finally:
|
|
logger.info("Session GC task stopped")
|