hello-datap-component-base 0.2.0__py3-none-any.whl

hello_datap_component_base/mns_client.py

@@ -0,0 +1,286 @@
+"""
+阿里云 MNS 消息队列客户端
+"""
+import json
+import os
+import time
+from typing import Dict, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class MNSClient:
+    """阿里云 MNS 消息队列客户端"""
+    
+    def __init__(
+        self, 
+        queue_name: str = "aiinfra-data-process-component-result-queue",
+        max_retries: int = 3,
+        retry_delay: float = 1.0,
+        retry_backoff: float = 2.0
+    ):
+        """
+        初始化 MNS 客户端
+        
+        Args:
+            queue_name: 队列名称，默认为 aiinfra-data-process-component-result-queue
+            max_retries: 最大重试次数，默认 3 次（可通过环境变量 MNS_MAX_RETRIES 配置）
+            retry_delay: 初始重试延迟（秒），默认 1.0 秒（可通过环境变量 MNS_RETRY_DELAY 配置）
+            retry_backoff: 重试延迟的指数退避倍数，默认 2.0（可通过环境变量 MNS_RETRY_BACKOFF 配置）
+        """
+        self.queue_name = queue_name
+        
+        # 从环境变量读取重试配置，如果没有则使用默认值
+        self.max_retries = int(os.environ.get('MNS_MAX_RETRIES', max_retries))
+        self.retry_delay = float(os.environ.get('MNS_RETRY_DELAY', retry_delay))
+        self.retry_backoff = float(os.environ.get('MNS_RETRY_BACKOFF', retry_backoff))
+        
+        self._client = None
+        self._queue = None
+        self._initialized = False
+        self._Message = None  # Message 类，延迟加载
+        
+    def _init_client(self):
+        """初始化 MNS 客户端（延迟加载）"""
+        if self._initialized:
+            return
+            
+        try:
+            # 尝试导入阿里云 MNS SDK
+            from mns.account import Account
+            from mns.queue import Queue, Message
+            
+            # 保存 Message 类供后续使用
+            self._Message = Message
+            
+            # 从环境变量获取 MNS 配置
+            endpoint = os.environ.get('MNS_ENDPOINT')
+            access_key_id = os.environ.get('MNS_ACCESS_KEY_ID')
+            access_key_secret = os.environ.get('MNS_ACCESS_KEY_SECRET')
+            
+            if not all([endpoint, access_key_id, access_key_secret]):
+                # 如果 MNS_ENDPOINT 不存在，静默跳过（已在 get_mns_client 中检查）
+                # 如果 MNS_ENDPOINT 存在但其他配置不完整，记录警告
+                if endpoint:
+                    logger.warning(
+                        "MNS 配置不完整，无法发送消息到队列。"
+                        "需要设置环境变量: MNS_ACCESS_KEY_ID, MNS_ACCESS_KEY_SECRET"
+                    )
+                self._initialized = True  # 标记为已初始化，避免重复警告
+                return
+            
+            # 创建 MNS 账户
+            account = Account(endpoint, access_key_id, access_key_secret)
+            # 获取队列（使用 get_queue 方法）
+            self._queue = account.get_queue(self.queue_name)
+            self._client = account
+            self._initialized = True
+            logger.info(f"MNS 客户端初始化成功，队列: {self.queue_name}")
+            
+        except ImportError:
+            logger.warning(
+                "未安装阿里云 MNS SDK，无法发送消息到队列。"
+                "请安装: pip install aliyun-mns"
+            )
+            self._initialized = True  # 标记为已初始化，避免重复警告
+        except Exception as e:
+            logger.error(f"初始化 MNS 客户端失败: {e}")
+            self._initialized = True  # 标记为已初始化，避免重复警告
+    
+    def _is_retryable_exception(self, exception: Exception) -> bool:
+        """
+        判断异常是否可重试
+        
+        Args:
+            exception: 异常对象
+            
+        Returns:
+            是否可重试
+        """
+        exception_str = str(exception)
+        exception_type = type(exception).__name__
+        
+        # 网络相关异常，可重试
+        retryable_keywords = [
+            'NetworkException',
+            'NetWorkException',
+            'Connection reset',
+            'Connection refused',
+            'Connection timeout',
+            'timeout',
+            'ConnectionError',
+            'ConnectTimeout',
+            'ReadTimeout',
+            'Errno 104',  # Connection reset by peer
+            'Errno 111',  # Connection refused
+            'Errno 110',  # Connection timed out
+        ]
+        
+        # 检查异常类型和消息中是否包含可重试的关键词
+        for keyword in retryable_keywords:
+            if keyword in exception_type or keyword in exception_str:
+                return True
+        
+        return False
+    
+    def _send_message_once(self, message_body: str) -> bool:
+        """
+        发送消息的单次尝试
+        
+        Args:
+            message_body: JSON 格式的消息字符串
+            
+        Returns:
+            是否发送成功
+        """
+        # 创建 Message 对象（MNS SDK 要求使用 Message 对象）
+        if self._Message is None:
+            from mns.queue import Message
+            self._Message = Message
+        
+        msg = self._Message(message_body)
+        
+        # 发送消息
+        self._queue.send_message(msg)
+        return True
+    
+    def send_message(self, message: Dict[str, Any]) -> bool:
+        """
+        发送消息到队列（带重试逻辑）
+        
+        Args:
+            message: 要发送的消息字典
+            
+        Returns:
+            是否发送成功
+        """
+        self._init_client()
+        
+        if not self._queue:
+            logger.warning("MNS 队列未初始化，跳过消息发送")
+            return False
+        
+        # 将消息转换为 JSON 字符串
+        message_body = json.dumps(message, ensure_ascii=False)
+        
+        # 重试逻辑
+        last_exception = None
+        delay = self.retry_delay
+        
+        for attempt in range(self.max_retries + 1):  # 总共尝试 max_retries + 1 次
+            try:
+                success = self._send_message_once(message_body)
+                if success:
+                    if attempt > 0:
+                        logger.info(
+                            f"消息已成功发送到队列 {self.queue_name} "
+                            f"（第 {attempt + 1} 次尝试）"
+                        )
+                    else:
+                        logger.info(f"消息已发送到队列 {self.queue_name}")
+                    return True
+                    
+            except Exception as e:
+                last_exception = e
+                
+                # 判断是否可重试
+                if not self._is_retryable_exception(e):
+                    # 不可重试的异常，直接返回失败
+                    logger.error(
+                        f"发送消息到队列失败（不可重试的异常）: {e}",
+                        exc_info=True
+                    )
+                    return False
+                
+                # 可重试的异常
+                if attempt < self.max_retries:
+                    # 还有重试机会
+                    logger.warning(
+                        f"发送消息到队列失败（第 {attempt + 1} 次尝试）: {e}，"
+                        f"{delay:.2f} 秒后重试..."
+                    )
+                    time.sleep(delay)
+                    delay *= self.retry_backoff  # 指数退避
+                else:
+                    # 已用完所有重试机会
+                    logger.error(
+                        f"发送消息到队列失败（已重试 {self.max_retries} 次）: {e}",
+                        exc_info=True
+                    )
+        
+        # 所有重试都失败了
+        if last_exception:
+            logger.error(
+                f"发送消息到队列最终失败（共尝试 {self.max_retries + 1} 次）: {last_exception}",
+                exc_info=True
+            )
+        return False
+    
+    def send_result(
+        self,
+        code: int,
+        message: str,
+        work_flow_id: Optional[int],
+        work_flow_instance_id: Optional[int],
+        task_id: Optional[str],
+        output: Optional[Dict[str, Any]] = None,
+        processing_time: Optional[float] = None
+    ) -> bool:
+        """
+        发送处理结果到队列
+        
+        Args:
+            code: 返回码，0 表示成功，非 0 表示失败
+            message: 返回消息
+            work_flow_id: 工作流ID
+            work_flow_instance_id: 工作流实例ID
+            task_id: 任务ID
+            output: 用户程序的输出结果（正常时为结果，异常时为 None）
+            processing_time: 处理时间（秒）
+            
+        Returns:
+            是否发送成功
+        """
+        result_message = {
+            "code": code,
+            "message": message,
+            "data": {
+                "work_flow_id": work_flow_id,
+                "work_flow_instance_id": work_flow_instance_id,
+                "task_id": task_id,
+                "out_put": output
+            }
+        }
+        if processing_time is not None:
+            result_message["processing_time"] = processing_time
+        
+        return self.send_message(result_message)
+
+
+def get_mns_client(queue_name: Optional[str] = None) -> Optional[MNSClient]:
+    """
+    获取 MNS 客户端实例
+    
+    Args:
+        queue_name: 队列名称，如果为 None 则使用默认队列名
+        
+    Returns:
+        MNSClient 实例，如果配置不完整则返回 None
+    """
+    # 如果环境变量中没有 MNS_ENDPOINT 配置，则不发送 MNS，直接返回 None
+    if not os.environ.get('MNS_ENDPOINT'):
+        return None
+    
+    if queue_name is None:
+        queue_name = os.environ.get('MNS_QUEUE_NAME', 'aiinfra-data-process-component-result-queue')
+    
+    client = MNSClient(queue_name)
+    client._init_client()
+    
+    # 如果客户端未正确初始化，返回 None
+    if not client._queue:
+        return None
+    
+    return client
+

hello_datap_component_base/runner.py

@@ -0,0 +1,247 @@
+import asyncio
+import signal
+import sys
+import subprocess
+from typing import Optional, Dict, Any, Type
+from .base import BaseService, ServiceConfig
+from .config import ServerConfig
+from .discover import get_single_service_class
+from .logger import setup_logging
+
+
+class ServiceRunner:
+    """服务运行器"""
+
+    def __init__(self, config_path: str, class_name: Optional[str] = None):
+        """
+        初始化运行器
+
+        Args:
+            config_path: 配置文件路径
+            class_name: 指定的服务类名
+        """
+        self.config_path = config_path
+        self.class_name = class_name
+        self.config: Optional[ServerConfig] = None
+        self.service_class: Optional[Type[BaseService]] = None
+        self.service_instance: Optional[BaseService] = None
+
+    def load_config(self):
+        """加载配置"""
+        self.config = ServerConfig.from_file(self.config_path)
+
+    def discover_service(self):
+        """发现服务类"""
+        import os
+        # 使用当前工作目录作为搜索路径
+        search_path = os.getcwd()
+        self.service_class = get_single_service_class(
+            search_path=search_path,
+            class_name=self.class_name
+        )
+
+    def setup_environment(self):
+        """设置运行环境"""
+        # 设置日志
+        setup_logging(
+            level=self.config.runtime_env.env_vars.get("LOG_LEVEL", "INFO")
+            if self.config.runtime_env and self.config.runtime_env.env_vars
+            else "INFO",
+            json_format=False,
+            service_name=self.config.name,
+            version=self.config.version
+        )
+        
+        # 安装pip包（如果配置了）
+        self._install_pip_packages()
+
+    def _install_pip_packages(self):
+        """安装runtime_env中指定的pip包"""
+        if not self.config.runtime_env or not self.config.runtime_env.pip:
+            return
+        
+        pip_packages = self.config.runtime_env.pip
+        if not isinstance(pip_packages, list) or len(pip_packages) == 0:
+            return
+        
+        print(f"Installing pip packages: {pip_packages}")
+        
+        try:
+            # 使用 subprocess 调用 pip install
+            # 使用 -q 参数减少输出，--disable-pip-version-check 禁用版本检查警告
+            cmd = [
+                sys.executable, "-m", "pip", "install", 
+                "-q", "--disable-pip-version-check"
+            ] + pip_packages
+            
+            result = subprocess.run(
+                cmd,
+                check=True,
+                capture_output=True,
+                text=True
+            )
+            
+            print(f"✅ Successfully installed packages: {', '.join(pip_packages)}")
+            
+        except subprocess.CalledProcessError as e:
+            error_msg = f"Failed to install pip packages: {pip_packages}\n"
+            if e.stdout:
+                error_msg += f"stdout: {e.stdout}\n"
+            if e.stderr:
+                error_msg += f"stderr: {e.stderr}\n"
+            print(f"❌ {error_msg}", file=sys.stderr)
+            raise RuntimeError(f"Failed to install required pip packages: {error_msg}")
+        except Exception as e:
+            print(f"❌ Error installing pip packages: {e}", file=sys.stderr)
+            raise RuntimeError(f"Failed to install required pip packages: {e}")
+
+    def create_service_instance(self):
+        """创建服务实例"""
+        # 创建 ServiceConfig
+        runtime_env_dict = None
+        if self.config.runtime_env:
+            runtime_env_dict = self.config.runtime_env.model_dump(exclude_none=True)
+            # 如果转换后的字典为空，设置为None
+            if not runtime_env_dict:
+                runtime_env_dict = None
+        
+        service_config = ServiceConfig(
+            name=self.config.name,
+            version=self.config.version,
+            params=self.config.params,
+            runtime_env=runtime_env_dict,
+            work_flow_id=self.config.work_flow_id,
+            work_flow_instance_id=self.config.work_flow_instance_id,
+            task_id=self.config.task_id
+        )
+
+        # 创建服务实例
+        self.service_instance = self.service_class(service_config)
+
+    async def run_async(self):
+        """异步运行服务并执行一次处理"""
+        print(f"Starting service: {self.config.name}")
+        if self.config.version:
+            print(f"Version: {self.config.version}")
+        print(f"Config: {self.config.model_dump_json(indent=2)}")
+        print("\n" + "=" * 60)
+        print("Processing request...")
+        print("=" * 60 + "\n")
+
+        try:
+            # 准备输入数据
+            # 从配置文件的 params 中获取，如果不存在则使用默认值
+            params = self.config.params
+            if params is None:
+                params = {}
+
+            # 执行一次处理（handle_request 会封装结果，包括异常情况）
+            result = await self.service_instance.handle_request(params)
+            
+            # 输出结果
+            import json
+            print("=" * 60)
+            print("Processing Result:")
+            print("=" * 60)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            print("=" * 60)
+            
+            # 发送结果到 MNS 队列
+            self._send_result_to_mns(result)
+            
+            print("Service completed successfully.")
+            print("=" * 60)
+
+        except Exception as e:
+            print(f"\nError processing request: {e}", file=sys.stderr)
+            import traceback
+            traceback.print_exc()
+            
+            # 即使发生异常，也要尝试发送错误结果到队列
+            try:
+                error_result = {
+                    "code": -1,
+                    "message": str(e),
+                    "data": {
+                        "work_flow_id": self.config.work_flow_id,
+                        "work_flow_instance_id": self.config.work_flow_instance_id,
+                        "task_id": self.config.task_id,
+                        "out_put": None
+                    }
+                }
+                self._send_result_to_mns(error_result)
+            except Exception as mns_error:
+                print(f"Failed to send error result to MNS: {mns_error}", file=sys.stderr)
+            
+            raise
+
+    def run(self):
+        """运行服务（主入口）"""
+        try:
+            # 加载配置
+            self.load_config()
+
+            # 发现服务类
+            self.discover_service()
+
+            # 设置环境
+            self.setup_environment()
+
+            # 创建服务实例
+            self.create_service_instance()
+
+            # 运行服务
+            asyncio.run(self.run_async())
+
+        except KeyboardInterrupt:
+            print("\nService stopped by user")
+        except Exception as e:
+            print(f"Error running service: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def _send_result_to_mns(self, result: Dict[str, Any]):
+        """
+        发送结果到 MNS 队列
+        
+        Args:
+            result: 封装后的结果字典
+        """
+        try:
+            from .mns_client import get_mns_client
+            import os
+            
+            # 如果环境变量中没有 MNS_ENDPOINT 配置，则不发送 MNS，静默跳过
+            if not os.environ.get('MNS_ENDPOINT'):
+                return
+            
+            client = get_mns_client()
+            if client:
+                # result 已经是封装好的格式，直接发送
+                success = client.send_message(result)
+                if success:
+                    print("✅ Result sent to MNS queue successfully")
+                else:
+                    print("⚠️  Failed to send result to MNS queue")
+            # 如果 client 为 None（配置不完整），静默跳过，不打印警告
+        except Exception as e:
+            print(f"⚠️  Error sending result to MNS queue: {e}", file=sys.stderr)
+
+    async def process_request(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        处理请求（供外部调用）
+
+        Args:
+            data: 输入数据
+
+        Returns:
+            处理结果
+        """
+        if not self.service_instance:
+            raise RuntimeError("Service not started")
+
+        result = await self.service_instance.handle_request(data)
+        
+        # 发送结果到 MNS 队列
+        self._send_result_to_mns(result)
+        
+        return result