service-forge 0.1.28__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, 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,9 +44,9 @@ 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)
     )
 
 
@@ -45,21 +59,21 @@ def validate_auth_from_headers(
 ) -> 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)
@@ -71,10 +85,10 @@ def validate_auth_from_headers(
             )
         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:
@@ -91,18 +105,21 @@ async def authenticate_websocket(
 ) -> 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,
@@ -110,10 +127,10 @@ async def authenticate_websocket(
         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
 
@@ -128,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
     """
@@ -145,7 +162,7 @@ def create_app(
     # Configure CORS middleware
     if cors_origins is None:
         cors_origins = ["*"]
-        
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=cors_origins,
@@ -154,6 +171,49 @@ 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:
@@ -169,42 +229,53 @@ def create_app(
     # 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", "")
-                
-                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)
-    
+    # 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(
@@ -222,7 +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=metadata.enable_auth_middleware, 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:
     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()

service_forge/api/routers/service/service_router.py

@@ -1,10 +1,12 @@
+import json
 import os
 import uuid
 import tempfile
 from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from fastapi.params import Body, Path
 from fastapi.responses import JSONResponse
 from loguru import logger
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Dict, Any
 from pydantic import BaseModel
 from omegaconf import OmegaConf
 from service_forge.current_service import get_service
@@ -18,18 +20,32 @@ class WorkflowStatusResponse(BaseModel):
     workflows: list[dict]
 
 class WorkflowActionResponse(BaseModel):
-    workflow_id: str
+    workflow_id: Optional[str] = None
     success: bool
     message: str
+    task_id: Optional[str] = None
 
 @service_router.get("/status", response_model=WorkflowStatusResponse)
 async def get_service_status():
     service = get_service()
     if service is None:
         raise HTTPException(status_code=503, detail="Service not initialized")
-    
+    # 排除调试版本
+    try:
+        status = service.get_service_status(exclude_debug=True)
+        return status
+    except Exception as e:
+        logger.error(f"Error getting service status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@service_router.get("/workflow/{workflow_id}/status", response_model=dict)
+def get_workflow_data(workflow_id: str):
+    service = get_service()
+    if service is None:
+        raise HTTPException(status_code=503, detail="Service not initialized")
+
     try:
-        status = service.get_service_status()
+        status = service.get_workflow_status(workflow_id)
         return status
     except Exception as e:
         logger.error(f"Error getting service status: {e}")
@@ -42,7 +58,7 @@ async def start_workflow(workflow_id: str):
         raise HTTPException(status_code=503, detail="Service not initialized")
     
     try:
-        success = service.start_workflow_by_id(uuid.UUID(workflow_id))
+        success = service.start_workflow_by_id(workflow_id)
         if success:
             return WorkflowActionResponse(success=True, message=f"Workflow {workflow_id} started successfully")
         else:
@@ -58,7 +74,7 @@ async def stop_workflow(workflow_id: str):
         raise HTTPException(status_code=503, detail="Service not initialized")
     
     try:
-        success = await service.stop_workflow_by_id(uuid.UUID(workflow_id))
+        success = await service.stop_workflow_by_id(workflow_id)
         if success:
             return WorkflowActionResponse(success=True, message=f"Workflow {workflow_id} stopped successfully")
         else:
@@ -67,6 +83,26 @@ async def stop_workflow(workflow_id: str):
         logger.error(f"Error stopping workflow {workflow_id}: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
+class TriggerWorkflowRequest(BaseModel):
+    kwargs: Optional[Dict[str, Any]] = {}
+
+@service_router.post("/workflow/{workflow_id}/trigger", response_model=WorkflowActionResponse)
+async def trigger_workflow(workflow_id: str = Path(...), request_body: TriggerWorkflowRequest = Body(...)):
+    service = get_service()
+    if service is None:
+        raise HTTPException(status_code=503, detail="Service not initialized")
+
+    try:
+        task_id = service.trigger_workflow_by_id(workflow_id, "", None, **request_body.kwargs)   # Trigger Name实际上没有使用
+        if task_id is not None:
+            return WorkflowActionResponse(workflow_id=workflow_id, task_id=str(task_id), success=True, message=f"Workflow {workflow_id} triggered successfully with task_id {task_id}")
+        else:
+            return WorkflowActionResponse(workflow_id=workflow_id, success=False, message=f"Failed to trigger workflow {workflow_id}")
+    except Exception as e:
+        logger.error(f"Error triggering workflow {workflow_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @service_router.post("/workflow/upload", response_model=WorkflowActionResponse)
 async def upload_workflow_config(
     file: Optional[UploadFile] = File(None),