service-forge 0.1.18__py3-none-any.whl → 0.1.39__py3-none-any.whl

service_forge/api/http_api.py

@@ -2,25 +2,39 @@ from fastapi import FastAPI
 import uvicorn
 from fastapi import APIRouter
 from loguru import logger
+from typing import Optional
 from urllib.parse import urlparse
-from fastapi import HTTPException, Request
+from fastapi import HTTPException, Request, WebSocket, WebSocketException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.openapi.utils import get_openapi
+
+from opentelemetry import context as otel_context_api
+from opentelemetry import trace
+from opentelemetry.propagate import extract
+from opentelemetry.trace import SpanKind
+
+from service_forge.api.routers.meta_api.meta_api_router import meta_api_router
+from service_forge.api.routers.trace.trace_router import trace_router
+from service_forge.api.service_studio import studio_static_files
 from service_forge.api.routers.websocket.websocket_router import websocket_router
 from service_forge.api.routers.service.service_router import service_router
 from service_forge.api.routers.feedback.feedback_router import router as feedback_router
 from service_forge.sft.config.sf_metadata import load_metadata
 from service_forge.sft.util.name_util import get_service_url_name
+from service_forge.execution_context import (
+    ExecutionContext,
+    reset_current_context,
+    set_current_context,
+)
 
 def is_trusted_origin(origin_host: str, host: str, trusted_root: str = "ring.shiweinan.com") -> bool:
     """
     Check if the origin host is trusted based on domain matching.
-    
+
     Args:
         origin_host: The hostname from the origin header
         host: The hostname from the host header
         trusted_root: The trusted root domain (can be customized)
-        
+
     Returns:
         bool: True if the origin is trusted, False otherwise
     """
@@ -30,12 +44,97 @@ def is_trusted_origin(origin_host: str, host: str, trusted_root: str = "ring.shi
 
     # Allow same domain, or subdomains under the same trusted root
     return (
-        origin_host == host or
-        origin_host.endswith("." + trusted_root) or
-        host.endswith("." + trusted_root)
+        origin_host == host
+        or origin_host.endswith("." + trusted_root)
+        or host.endswith("." + trusted_root)
     )
 
 
+def validate_auth_from_headers(
+    headers: dict,
+    origin: str | None,
+    scheme: str,
+    host: str,
+    trusted_domain: str = "ring.shiweinan.com",
+) -> tuple[str | None, str | None]:
+    """
+    Validate authentication from headers and return user_id and token.
+
+    Args:
+        headers: Dictionary of headers (can be from Request or WebSocket)
+        origin: Origin header value
+        scheme: URL scheme (http/https/ws/wss)
+        host: Host header value
+        trusted_domain: Trusted domain for origin validation
+
+    Returns:
+        tuple: (user_id, auth_token) - user_id can be None if not authenticated and not same origin
+    """
+    is_same_origin = False
+
+    logger.debug(f"origin {origin}, host:{host}")
+
+    if origin and host:
+        try:
+            parsed_origin = urlparse(origin)
+            parsed_host = urlparse(f"{scheme}://{host}")
+            is_same_origin = (
+                parsed_origin.hostname == parsed_host.hostname
+                and parsed_origin.port == parsed_host.port
+                and is_trusted_origin(parsed_origin.hostname, parsed_host.hostname, trusted_domain)
+            )
+        except Exception:
+            pass
+
+    user_id = headers.get("X-User-ID")
+    token = headers.get("X-User-Token")
+
+    if not is_same_origin:
+        # For cross-origin requests, user_id is required
+        if not user_id:
+            return None, None
+        return user_id, token
+    else:
+        # For same-origin requests, user_id defaults to "0" if not provided
+        return user_id if user_id else "0", token
+
+
+async def authenticate_websocket(
+    websocket: WebSocket,
+    trusted_domain: str = "ring.shiweinan.com",
+) -> None:
+    """
+    Authenticate WebSocket connection and set user_id and auth_token in websocket.state.
+
+    Args:
+        websocket: WebSocket instance
+        trusted_domain: Trusted domain for origin validation
+
+    Raises:
+        WebSocketException: If authentication fails
+    """
+    if not websocket.url.path.startswith("/api"):
+        return
+
+    origin = websocket.headers.get("origin") or websocket.headers.get("referer")
+    scheme = websocket.url.scheme
+    host = websocket.headers.get("host", "")
+
+    user_id, token = validate_auth_from_headers(
+        websocket.headers,
+        origin,
+        scheme,
+        host,
+        trusted_domain,
+    )
+
+    if user_id is None:
+        raise WebSocketException(code=1008, reason="Unauthorized")
+
+    websocket.state.user_id = user_id
+    websocket.state.auth_token = token
+
+
 def create_app(
     app: FastAPI | None = None,
     routers: list[APIRouter] | None = None,
@@ -46,14 +145,14 @@ def create_app(
 ) -> FastAPI:
     """
     Create or configure a FastAPI app with common middleware and configuration.
-    
+
     Args:
         app: Optional existing FastAPI instance. If None, creates a new one.
         routers: List of APIRouter instances to include
         cors_origins: List of allowed CORS origins. Defaults to ["*"]
         enable_auth_middleware: Whether to enable authentication middleware
         trusted_domain: Trusted domain for origin validation
-        
+
     Returns:
         FastAPI: Configured FastAPI application instance
     """
@@ -63,7 +162,7 @@ def create_app(
     # Configure CORS middleware
     if cors_origins is None:
         cors_origins = ["*"]
-        
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=cors_origins,
@@ -72,64 +171,111 @@ def create_app(
         allow_headers=["*"],
     )
 
+    @app.middleware("http")
+    async def tracing_middleware(request: Request, call_next):
+        tracer = trace.get_tracer("service_forge.api.http")
+        try:
+            parent_context = extract(request.headers)
+        except Exception:
+            parent_context = otel_context_api.get_current()
+        if parent_context is None:
+            parent_context = otel_context_api.get_current()
+
+        span_name = f"HTTP {request.method} {request.url.path}"
+        with tracer.start_as_current_span(
+            span_name,
+            context=parent_context,
+            kind=SpanKind.SERVER,
+        ) as span:
+            span.set_attribute("http.method", request.method)
+            span.set_attribute("http.target", request.url.path)
+            span.set_attribute("http.scheme", request.url.scheme)
+            host_header = request.headers.get("host")
+            if host_header:
+                span.set_attribute("http.host", host_header)
+            if request.client:
+                span.set_attribute("net.peer.ip", request.client.host)
+                span.set_attribute("net.peer.port", request.client.port or 0)
+
+            execution_context = ExecutionContext(
+                trace_context=otel_context_api.get_current(),
+                span=span,
+                metadata={
+                    "entrypoint": "http",
+                    "path": request.url.path,
+                    "method": request.method,
+                },
+            )
+            token = set_current_context(execution_context)
+            request.state.execution_context = execution_context
+            try:
+                response = await call_next(request)
+            finally:
+                reset_current_context(token)
+        return response
+
     # Include routers if provided
     if routers:
         for router in routers:
             app.include_router(router)
     
+    # Store auth configuration in app.state for WebSocket endpoints to access
+    app.state.enable_auth_middleware = enable_auth_middleware
+    app.state.trusted_domain = trusted_domain
+
     # Always include WebSocket router
     app.include_router(websocket_router)
 
     # Include Feedback router
     app.include_router(feedback_router)
     
-    # Always include Service router
+    # Always include Service router, Meta API Router, Trace Router, and Static Files
     app.include_router(service_router)
-    
+    app.include_router(meta_api_router)
+    app.include_router(trace_router)
+    app.mount('/sdk/studio', studio_static_files)
+
+    @app.middleware("http")
+    async def auth_middleware(request: Request, call_next):
+        request.state.user_id = request.headers.get("X-User-ID") or "0"
+        request.state.auth_token = request.headers.get("X-User-Token") or ""
+        return await call_next(request)
+
+
     # Add authentication middleware if enabled
-    if enable_auth_middleware:
-        @app.middleware("http")
-        async def auth_middleware(request: Request, call_next):
-            """
-            Authentication middleware for API routes.
-            
-            Validates user authentication for /api routes with origin-based
-            trust verification and X-User-ID header validation.
-            """
-            if request.url.path.startswith("/api"):
-                origin = request.headers.get("origin") or request.headers.get("referer")
-                scheme = request.url.scheme
-                host = request.headers.get("host", "")
-                is_same_origin = False
-                
-                logger.debug(f"origin {origin}, host:{host}")
-                
-                if origin and host:
-                    try:
-                        parsed_origin = urlparse(origin)
-                        parsed_host = urlparse(f"{scheme}://{host}")
-                        is_same_origin = (
-                            parsed_origin.hostname == parsed_host.hostname
-                            and parsed_origin.port == parsed_host.port
-                            and is_trusted_origin(parsed_origin.hostname, parsed_host.hostname, trusted_domain)
-                        )
-                    except Exception:
-                        pass  # If parsing fails, continue with default behavior
-                if not is_same_origin:
-                    headers = request.headers
-                    user_id = headers.get("X-User-ID")
-                    if not user_id:
-                        raise HTTPException(status_code=401, detail="Unauthorized")
-                    
-                    request.state.user_id = user_id
-                else:
-                    # Same-origin requests can skip auth, but still set default user_id
-                    request.state.user_id = "0"  # Can be None or default value as needed
-
-            return await call_next(request)
-    
+    # if enable_auth_middleware:
+    #     @app.middleware("http")
+    #     async def auth_middleware(request: Request, call_next):
+    #         """
+    #         Authentication middleware for API routes.
+
+    #         Validates user authentication for /api routes with origin-based
+    #         trust verification and X-User-ID header validation.
+    #         """
+    #         if request.url.path.startswith("/api"):
+    #             origin = request.headers.get("origin") or request.headers.get("referer")
+    #             scheme = request.url.scheme
+    #             host = request.headers.get("host", "")
+
+    #             user_id, token = validate_auth_from_headers(
+    #                 request.headers,
+    #                 origin,
+    #                 scheme,
+    #                 host,
+    #                 trusted_domain,
+    #             )
+
+    #             if user_id is None:
+    #                 raise HTTPException(status_code=401, detail="Unauthorized")
+
+    #             request.state.user_id = user_id
+    #             request.state.auth_token = token
+
+    #         return await call_next(request)
+
     return app
 
+
 async def start_fastapi_server(host: str, port: int):
     try:
         config = uvicorn.Config(
@@ -147,6 +293,10 @@ async def start_fastapi_server(host: str, port: int):
 
 try:
     metadata = load_metadata("sf-meta.yaml")
-    fastapi_app = create_app(enable_auth_middleware=False, root_path=f"/api/v1/{get_service_url_name(metadata.name, metadata.version)}")
+    if metadata.mode == "debug":
+        fastapi_app = create_app(enable_auth_middleware=True, root_path=None)
+    else:
+        fastapi_app = create_app(enable_auth_middleware=metadata.enable_auth_middleware, root_path=f"/api/v1/{get_service_url_name(metadata.name, metadata.version)}")
 except Exception as e:
-    fastapi_app = create_app(enable_auth_middleware=False, root_path=None)
+    logger.warning(f"Failed to load metadata, using default configuration: {e}")
+    fastapi_app = create_app(enable_auth_middleware=True, root_path=None)

service_forge/api/kafka_api.py

@@ -1,11 +1,24 @@
 from __future__ import annotations
-from typing import Callable, Any
-from aiokafka import AIOKafkaConsumer, AIOKafkaProducer, ConsumerRecord
+
 import asyncio
-import json
 import inspect
-from pydantic import BaseModel
+import json
+from typing import Any, Callable
+
+from aiokafka import AIOKafkaConsumer, AIOKafkaProducer, ConsumerRecord
 from loguru import logger
+from opentelemetry import context as otel_context_api
+from opentelemetry import trace
+from opentelemetry.propagate import extract, inject
+from opentelemetry.trace import SpanKind
+
+from service_forge.execution_context import (
+    ExecutionContext,
+    set_current_context,
+    get_current_context,
+    reset_current_context,
+)
+
 
 class KafkaApp:
     def __init__(self, bootstrap_servers: str = None):
@@ -15,15 +28,21 @@ class KafkaApp:
         self._producer: AIOKafkaProducer = None
         self._lock = asyncio.Lock()
         self._running = False
+        self._tracer = trace.get_tracer("service_forge.api.kafka")
 
     def kafka_input(self, topic: str, data_type: type, group_id: str):
         def decorator(func: Callable):
             self._handlers[topic] = (func, data_type, group_id)
-            logger.info(f"Registered Kafka input handler for topic '{topic}', data_type: {data_type}")
+            logger.info(
+                f"Registered Kafka input handler for topic '{topic}', data_type: {data_type}"
+            )
 
             if self._running:
-                asyncio.create_task(self._start_consumer(topic, func, data_type, group_id))
+                asyncio.create_task(
+                    self._start_consumer(topic, func, data_type, group_id)
+                )
             return func
+
         return decorator
 
     def set_bootstrap_servers(self, bootstrap_servers: str) -> None:
@@ -40,13 +59,17 @@ class KafkaApp:
         async with self._lock:
             for topic, (handler, data_type, group_id) in self._handlers.items():
                 if topic not in self._consumer_tasks:
-                    self._consumer_tasks[topic] = asyncio.create_task(self._start_consumer(topic, handler, data_type, group_id))
+                    self._consumer_tasks[topic] = asyncio.create_task(
+                        self._start_consumer(topic, handler, data_type, group_id)
+                    )
 
         self._running = True
         while self._running:
             await asyncio.sleep(1)
 
-    async def _start_consumer(self, topic: str, handler: Callable, data_type: type, group_id: str):
+    async def _start_consumer(
+        self, topic: str, handler: Callable, data_type: type, group_id: str
+    ):
         consumer = AIOKafkaConsumer(
             topic,
             bootstrap_servers=self.bootstrap_servers,
@@ -65,16 +88,62 @@ class KafkaApp:
         finally:
             await consumer.stop()
 
-    async def _dispatch_message(self, handler: Callable, msg: ConsumerRecord, data_type: type):
+    async def _dispatch_message(
+        self, handler: Callable, msg: ConsumerRecord, data_type: type
+    ):
+        header_carrier: dict[str, str] = {}
+        for key, value in msg.headers or []:
+            try:
+                header_carrier[key] = (
+                    value.decode("utf-8")
+                    if isinstance(value, (bytes, bytearray))
+                    else str(value)
+                )
+            except Exception:
+                header_carrier[key] = ""
+
         try:
-            data = data_type()
-            data.ParseFromString(msg.value)
-        except Exception as e:
-            print("Error:", e)
-            data = data_type(**json.loads(msg.value.decode("utf-8")))
-        result = handler(data)
-        if inspect.iscoroutine(result):
-            await result
+            parent_context = extract(header_carrier)
+        except Exception:
+            parent_context = otel_context_api.get_current()
+        if parent_context is None:
+            parent_context = otel_context_api.get_current()
+
+        span_name = f"Kafka consume {msg.topic}"
+        with self._tracer.start_as_current_span(
+            span_name,
+            context=parent_context,
+            kind=SpanKind.CONSUMER,
+        ) as span:
+            span.set_attribute("messaging.system", "kafka")
+            span.set_attribute("messaging.destination", msg.topic)
+            span.set_attribute("messaging.kafka.partition", msg.partition)
+            span.set_attribute("messaging.kafka.offset", msg.offset)
+
+            execution_context = ExecutionContext(
+                trace_context=otel_context_api.get_current(),
+                span=span,
+                logger=logger.bind(topic=msg.topic),
+                metadata={
+                    "entrypoint": "kafka",
+                    "topic": msg.topic,
+                    "partition": msg.partition,
+                },
+            )
+            token = set_current_context(execution_context)
+
+            try:
+                try:
+                    data = data_type()
+                    data.ParseFromString(msg.value)
+                except Exception as e:
+                    print("Error:", e)
+                    data = data_type(**json.loads(msg.value.decode("utf-8")))
+                result = handler(data)
+                if inspect.iscoroutine(result):
+                    await result
+            finally:
+                reset_current_context(token)
 
     async def _start_producer(self):
         if self._producer is None:
@@ -94,14 +163,31 @@ class KafkaApp:
     async def send_message(self, topic: str, data_type: type, data: Any) -> None:
         if not self._running:
             raise RuntimeError("KafkaApp is not running. Call start() first.")
-        
+
         if self._producer is None:
             raise RuntimeError("Kafka producer is not initialized.")
-        
+
+        headers_carrier: dict[str, str] = {}
+        execution_context = get_current_context()
+        try:
+            if execution_context and execution_context.trace_context is not None:
+                inject(headers_carrier, context=execution_context.trace_context)
+            else:
+                inject(headers_carrier)
+        except Exception as e:
+            logger.warning(f"inject trace context failed: {e}")
+
         try:
-            await self._producer.send_and_wait(topic, data)
+            await self._producer.send_and_wait(
+                topic,
+                data,
+                headers=[
+                    (key, str(value).encode("utf-8"))
+                    for key, value in headers_carrier.items()
+                ],
+            )
             logger.info(f"✅ 已发送消息到 topic '{topic}', type: {data_type}")
-            
+
         except Exception as e:
             logger.error(f"❌ 发送消息到 topic '{topic}' 失败: {e}")
             raise
@@ -109,18 +195,20 @@ class KafkaApp:
     async def stop(self):
         logger.info("Stopping KafkaApp ...")
         self._running = False
-        
+
         for t in list(self._consumer_tasks.values()):
             t.cancel()
         await asyncio.sleep(0.1)
         self._consumer_tasks.clear()
-        
+
         await self._stop_producer()
-        
+
         logger.info("✅ KafkaApp stopped")
 
+
 kafka_app = KafkaApp()
 
+
 async def start_kafka_server(bootstrap_servers: str):
     kafka_app.set_bootstrap_servers(bootstrap_servers)
-    await kafka_app.start()
+    await kafka_app.start()

service_forge/api/routers/meta_api/meta_api_router.py

@@ -0,0 +1,57 @@
+from typing import Type
+
+from fastapi import APIRouter
+from omegaconf import OmegaConf
+
+from service_forge.model.meta_api.schema import NodeTypeSchema, NodeInputPortSchema, NodeOutputPortSchema
+from service_forge.sft.config.sf_metadata import load_metadata
+from service_forge.workflow.node import Node, node_register
+from service_forge.workflow.trigger import Trigger
+
+def _node_class_to_schema(node_class: Type[Node]) -> NodeTypeSchema:
+    """将Node子类转化为NodeTypeSchema"""
+    _input_ports = {}
+    for port in node_class.DEFAULT_INPUT_PORTS:
+        _input_ports[port.name] = NodeInputPortSchema(
+            name=port.name,
+            type=port.type.__name__,
+            default_value=port.default
+        )
+
+    _output_ports = {}
+    for port in node_class.DEFAULT_OUTPUT_PORTS:
+        _output_ports[port.name] = NodeOutputPortSchema(
+            name=port.name,
+            type=port.type.__name__
+        )
+
+    return NodeTypeSchema(
+        name = node_class.__name__,
+        inputs=_input_ports,
+        outputs=_output_ports,
+        is_trigger=issubclass(node_class, Trigger)
+    )
+
+
+def create_schema_router() -> APIRouter:
+    router = APIRouter(prefix='/schema')
+
+    @router.get('/nodes', response_model=list[NodeTypeSchema])
+    def get_node_schema():
+        schemas = []
+        for k, v in node_register.items.items():
+            if v is not Trigger:
+                schemas.append(_node_class_to_schema(v))
+        return schemas
+
+    return router
+
+def create_meta_api_router() -> APIRouter:
+    router = APIRouter(tags=['meta-api'], prefix='/sdk/meta-api')
+    router.include_router(create_schema_router())
+    return router
+
+metadata = load_metadata('sf-meta.yaml')
+service_config = OmegaConf.load(metadata.service_config)
+
+meta_api_router = create_meta_api_router()