sycommon-python-lib 0.1.46__py3-none-any.whl → 0.1.57b1__py3-none-any.whl

sycommon/synacos/feign.py

@@ -2,6 +2,9 @@ import io
 import os
 import time
 
+from sycommon.tools.merge_headers import merge_headers
+from sycommon.tools.snowflake import Snowflake
+
 import aiohttp
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.synacos.nacos_service import NacosService
@@ -22,12 +25,18 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
     try:
         # 初始化headers，确保是可修改的字典
         headers = headers.copy() if headers else {}
+        headers = merge_headers(SYLogger.get_headers(), headers)
+        if "x-traceId-header" not in headers:
+            headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.id
 
         # 处理JSON请求的Content-Type
         is_json_request = method.upper() in ["POST", "PUT", "PATCH"] and not (
             files or form_data or file_path)
-        if is_json_request and "Content-Type" not in headers:
-            headers["Content-Type"] = "application/json"
+        if is_json_request:
+            # 将headers的key全部转为小写，统一判断
+            headers_lower = {k.lower(): v for k, v in headers.items()}
+            if "content-type" not in headers_lower:
+                headers["Content-Type"] = "application/json"
 
         nacos_service = NacosService(None)
         version = headers.get('s-y-version')
@@ -43,7 +52,7 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
         instance = instances[int(time.time()) % len(instances)]
 
         SYLogger.info(f"nacos:开始调用服务: {service_name}")
-        SYLogger.info(f"nacos:请求头: {headers}")
+        # SYLogger.info(f"nacos:请求头: {headers}")
 
         ip = instance.get('ip')
         port = instance.get('port')
@@ -131,13 +140,15 @@ async def _handle_feign_response(response, service_name: str, api_path: str):
     """
     try:
         status_code = response.status
-        content_type = response.headers.get('Content-Type', '').lower()
+        content_type = response.headers.get('Content-Type', '')
+        content_type = content_type.lower() if content_type else ''
+
         response_body = None
 
         if status_code == 200:
-            if 'application/json' in content_type:
+            if content_type and 'application/json' in content_type:
                 response_body = await response.json()
-            elif 'text/' in content_type:
+            elif content_type and 'text/' in content_type:
                 # 文本类型（text/plain、text/html等）：按文本读取
                 try:
                     response_body = await response.text(encoding='utf-8')
@@ -154,7 +165,7 @@ async def _handle_feign_response(response, service_name: str, api_path: str):
         else:
             # 非200状态：统一读取响应体（兼容文本/二进制错误信息）
             try:
-                if 'application/json' in content_type:
+                if content_type and 'application/json' in content_type:
                     response_body = await response.json()
                 else:
                     response_body = await response.text(encoding='utf-8', errors='ignore')

sycommon/synacos/feign_client.py

@@ -5,6 +5,9 @@ import inspect
 from typing import Any, Dict, Optional, Literal, Type, TypeVar
 from urllib.parse import urljoin
 
+from sycommon.tools.merge_headers import merge_headers
+from sycommon.tools.snowflake import Snowflake
+
 import aiohttp
 from pydantic import BaseModel
 from sycommon.synacos.param import Body, Cookie, File, Form, Header, Param, Path, Query
@@ -26,6 +29,9 @@ def feign_client(
     default_headers: Optional[Dict[str, str]] = None
 ):
     default_headers = default_headers or {}
+    default_headers = {k.lower(): v for k, v in default_headers.items()}
+    default_headers = merge_headers(SYLogger.get_headers(), default_headers)
+    default_headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.id
 
     def decorator(cls):
         class FeignClient:
@@ -33,7 +39,8 @@ def feign_client(
                 self.service_name = service_name
                 self.path_prefix = path_prefix
                 self.default_timeout = default_timeout
-                self.default_headers = default_headers.copy()
+                self.default_headers = {
+                    k.lower(): v for k, v in default_headers.copy().items()}
                 self.nacos_manager: Optional[NacosService] = None
                 self.session: Optional[aiohttp.ClientSession] = None
 
@@ -62,7 +69,8 @@ def feign_client(
                         method = request_meta.get("method", "GET").upper()
                         path = request_meta.get("path", "")
                         is_upload = request_meta.get("is_upload", False)
-                        method_headers = request_meta.get("headers", {})
+                        method_headers = {
+                            k.lower(): v for k, v in request_meta.get("headers", {}).items()}
                         timeout = request_meta.get(
                             "timeout", self.default_timeout)
 
@@ -152,11 +160,16 @@ def feign_client(
             def _build_headers(self, param_meta: Dict[str, Param], bound_args: Dict[str, Any], method_headers: Dict[str, str]) -> Dict[str, str]:
                 headers = self.default_headers.copy()
                 headers.update(method_headers)
+                headers = merge_headers(SYLogger.get_headers(), headers)
+                headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.id
+
+                # 处理参数中的Header类型
                 for name, meta in param_meta.items():
                     if isinstance(meta, Header) and name in bound_args:
                         value = bound_args[name]
                         if value is not None:
-                            headers[meta.get_key(name)] = str(value)
+                            header_key = meta.get_key(name).lower()
+                            headers[header_key] = str(value)
                 return headers
 
             def _replace_path_params(self, path: str, param_meta: Dict[str, Param], bound_args: Dict[str, Any]) -> str:
@@ -221,10 +234,14 @@ def feign_client(
                             value) if not isinstance(value, dict) else value)
                     return form_data
 
-                # 处理表单提交（x-www-form-urlencoded）
+                # 从headers中获取Content-Type（已小写key）
                 content_type = self.default_headers.get(
-                    "Content-Type") or method_headers.get("Content-Type", "")
-                if "application/x-www-form-urlencoded" in content_type:
+                    "content-type") or method_headers.get("content-type", "")
+                # 转为小写进行判断
+                content_type_lower = content_type.lower()
+
+                # 处理表单提交（x-www-form-urlencoded）
+                if "application/x-www-form-urlencoded" in content_type_lower:
                     form_data = {}
                     for name, value in bound_args.items():
                         meta = param_meta.get(name)
@@ -270,7 +287,8 @@ def feign_client(
                 """处理响应（支持 Pydantic 模型解析）"""
                 status = response.status
                 if 200 <= status < 300:
-                    content_type = response.headers.get("Content-Type", "")
+                    content_type = response.headers.get(
+                        "content-type", "").lower()
                     if "application/json" in content_type:
                         json_data = await response.json()
                         # 若指定了 Pydantic 响应模型，自动解析
@@ -299,7 +317,7 @@ def feign_request(
         func._feign_meta = {
             "method": method.upper(),
             "path": path,
-            "headers": headers.copy() if headers else {},
+            "headers": {k.lower(): v for k, v in headers.items()} if headers else {},
             "is_upload": False,
             "timeout": timeout
         }

sycommon/synacos/nacos_client_base.py

@@ -0,0 +1,119 @@
+import threading
+import time
+from typing import Optional
+import nacos
+from sycommon.logging.kafka_log import SYLogger
+
+
+class NacosClientBase:
+    """Nacos客户端基础类 - 负责客户端初始化和连接管理"""
+
+    def __init__(self, nacos_config: dict, enable_register_nacos: bool):
+        self.nacos_config = nacos_config
+        self.enable_register_nacos = enable_register_nacos
+
+        # 客户端配置
+        self.max_retries = self.nacos_config.get('maxRetries', 5)
+        self.retry_delay = self.nacos_config.get('retryDelay', 5)
+        self.max_retry_delay = self.nacos_config.get('maxRetryDelay', 30)
+
+        # 状态管理
+        self._client_initialized = False
+        self._state_lock = threading.RLock()
+        self._shutdown_event = threading.Event()
+        self.nacos_client: Optional[nacos.NacosClient] = None
+
+    def _initialize_client(self) -> bool:
+        """初始化Nacos客户端（仅首次调用时执行）"""
+        if self._client_initialized:
+            return True
+
+        for attempt in range(self.max_retries):
+            try:
+                register_ip = self.nacos_config['registerIp']
+                namespace_id = self.nacos_config['namespaceId']
+                self.nacos_client = nacos.NacosClient(
+                    server_addresses=register_ip,
+                    namespace=namespace_id
+                )
+                SYLogger.info("nacos:客户端初始化成功")
+                self._client_initialized = True
+                return True
+            except Exception as e:
+                delay = min(self.retry_delay, self.max_retry_delay)
+                SYLogger.error(
+                    f"nacos:客户端初始化失败 (尝试 {attempt+1}/{self.max_retries}): {e}")
+                time.sleep(delay)
+
+        SYLogger.warning("nacos:无法连接到 Nacos 服务器，已达到最大重试次数")
+        return False
+
+    def ensure_client_connected(self, retry_once: bool = False) -> bool:
+        """确保Nacos客户端已连接，返回连接状态"""
+        with self._state_lock:
+            if self._client_initialized:
+                return True
+
+        SYLogger.warning("nacos:客户端未初始化，尝试连接...")
+
+        max_attempts = 2 if retry_once else self.max_retries
+        attempt = 0
+
+        while attempt < max_attempts:
+            try:
+                register_ip = self.nacos_config['registerIp']
+                namespace_id = self.nacos_config['namespaceId']
+
+                self.nacos_client = nacos.NacosClient(
+                    server_addresses=register_ip,
+                    namespace=namespace_id
+                )
+
+                if self._verify_client_connection():
+                    with self._state_lock:
+                        self._client_initialized = True
+                    SYLogger.info("nacos:客户端初始化成功")
+                    return True
+                else:
+                    raise ConnectionError("nacos:客户端初始化后无法验证连接")
+
+            except Exception as e:
+                attempt += 1
+                delay = min(self.retry_delay, self.max_retry_delay)
+                SYLogger.error(
+                    f"nacos:客户端初始化失败 (尝试 {attempt}/{max_attempts}): {e}")
+                time.sleep(delay)
+
+        SYLogger.error("nacos:无法连接到 Nacos 服务器，已达到最大重试次数")
+        return False
+
+    def _verify_client_connection(self) -> bool:
+        """验证客户端是否真正连接成功"""
+        if not self.enable_register_nacos:
+            return True
+
+        try:
+            namespace_id = self.nacos_config['namespaceId']
+            self.nacos_client.list_naming_instance(
+                service_name="",  # 空服务名仅用于验证连接
+                namespace_id=namespace_id,
+                group_name="DEFAULT_GROUP",
+                healthy_only=True
+            )
+            return True
+        except Exception as e:
+            SYLogger.warning(f"nacos:客户端连接验证失败: {e}")
+            return False
+
+    def reconnect_nacos_client(self) -> bool:
+        """重新连接Nacos客户端"""
+        SYLogger.warning("nacos:尝试重新连接Nacos客户端")
+        with self._state_lock:
+            self._client_initialized = False
+        return self.ensure_client_connected()
+
+    @property
+    def is_connected(self) -> bool:
+        """检查客户端是否已连接"""
+        with self._state_lock:
+            return self._client_initialized

sycommon/synacos/nacos_config_manager.py

@@ -0,0 +1,107 @@
+import json
+import threading
+import time
+from typing import Callable, Optional, Dict, List
+from sycommon.synacos.nacos_client_base import NacosClientBase
+import yaml
+from sycommon.logging.kafka_log import SYLogger
+
+
+class NacosConfigManager:
+    """Nacos配置管理类 - 负责配置读取、监听和更新"""
+
+    def __init__(self, client_base: NacosClientBase):
+        self.client_base = client_base
+
+        # 配置
+        self.config_watch_interval = self.client_base.nacos_config.get(
+            'configWatchInterval', 30)
+
+        # 状态
+        self.share_configs: Dict = {}
+        self._config_listeners: Dict[str, Callable[[str], None]] = {}
+        self._config_cache: Dict[str, str] = {}
+        self._watch_thread: Optional[threading.Thread] = None
+
+    def read_configs(self, shared_configs: List[Dict]) -> dict:
+        """读取共享配置"""
+        configs = {}
+
+        for config in shared_configs:
+            data_id = config['dataId']
+            group = config['group']
+
+            for attempt in range(self.client_base.max_retries):
+                try:
+                    if not self.client_base.ensure_client_connected():
+                        self.client_base.reconnect_nacos_client()
+
+                    content = self.client_base.nacos_client.get_config(
+                        data_id, group)
+
+                    try:
+                        configs[data_id] = json.loads(content)
+                    except json.JSONDecodeError:
+                        try:
+                            configs[data_id] = yaml.safe_load(content)
+                        except yaml.YAMLError:
+                            SYLogger.error(f"nacos:无法解析 {data_id} 的内容")
+                    break
+                except Exception as e:
+                    if attempt < self.client_base.max_retries - 1:
+                        SYLogger.warning(
+                            f"nacos:读取配置 {data_id} 失败 (尝试 {attempt+1}/{self.client_base.max_retries}): {e}")
+                        time.sleep(self.client_base.retry_delay)
+                    else:
+                        SYLogger.error(
+                            f"nacos:读取配置 {data_id} 失败，已达到最大重试次数: {e}")
+
+        self.share_configs = configs
+        return configs
+
+    def add_config_listener(self, data_id: str, callback: Callable[[str], None]):
+        """添加配置变更监听器"""
+        self._config_listeners[data_id] = callback
+        if config := self.get_config(data_id):
+            callback(config)
+
+    def get_config(self, data_id: str, group: str = "DEFAULT_GROUP") -> Optional[str]:
+        """获取配置内容"""
+        if not self.client_base.ensure_client_connected():
+            return None
+
+        try:
+            return self.client_base.nacos_client.get_config(data_id, group=group)
+        except Exception as e:
+            SYLogger.error(f"nacos:获取配置 {data_id} 失败: {str(e)}")
+            return None
+
+    def start_watch_configs(self):
+        """启动配置监视线程"""
+        self._watch_thread = threading.Thread(
+            target=self._watch_configs, daemon=True)
+        self._watch_thread.start()
+
+    def _watch_configs(self):
+        """配置监听线程"""
+        check_interval = self.config_watch_interval
+
+        while not self.client_base._shutdown_event.is_set():
+            try:
+                for data_id, callback in list(self._config_listeners.items()):
+                    new_config = self.get_config(data_id)
+                    if new_config and new_config != self._config_cache.get(data_id):
+                        callback(new_config)
+                        self._config_cache[data_id] = new_config
+                        try:
+                            self.share_configs[data_id] = json.loads(
+                                new_config)
+                        except json.JSONDecodeError:
+                            try:
+                                self.share_configs[data_id] = yaml.safe_load(
+                                    new_config)
+                            except yaml.YAMLError:
+                                SYLogger.error(f"nacos:无法解析 {data_id} 的内容")
+            except Exception as e:
+                SYLogger.error(f"nacos:配置监视线程异常: {str(e)}")
+            self.client_base._shutdown_event.wait(check_interval)

sycommon/synacos/nacos_heartbeat_manager.py

@@ -0,0 +1,144 @@
+import threading
+import time
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.synacos.nacos_client_base import NacosClientBase
+from sycommon.synacos.nacos_service_registration import NacosServiceRegistration
+
+
+class NacosHeartbeatManager:
+    """Nacos心跳管理类 - 负责心跳发送和监控"""
+
+    def __init__(self, client_base: NacosClientBase, registration: NacosServiceRegistration, heartbeat_interval: int = 15):
+        self.client_base = client_base
+        self.registration = registration
+
+        # 心跳配置
+        self.heartbeat_interval = heartbeat_interval
+        self.heartbeat_timeout = 15
+        self.max_heartbeat_timeout = self.client_base.nacos_config.get(
+            'maxHeartbeatTimeout', 30)
+
+        # 状态管理
+        self._heartbeat_lock = threading.Lock()
+        self._heartbeat_thread = None
+        self._last_heartbeat_time = 0
+        self._heartbeat_fail_count = 0
+
+    def start_heartbeat(self):
+        """启动心跳线程（确保单例）"""
+        with self._heartbeat_lock:
+            if self._heartbeat_thread is not None and self._heartbeat_thread.is_alive():
+                return
+
+            self._heartbeat_thread = None
+
+            self._heartbeat_thread = threading.Thread(
+                target=self._send_heartbeat_loop,
+                name="NacosHeartbeatThread",
+                daemon=True
+            )
+            self._heartbeat_thread.start()
+            SYLogger.info(
+                f"nacos:心跳线程启动，线程ID: {self._heartbeat_thread.ident}，"
+                f"心跳间隔: {self.heartbeat_interval}秒，"
+                f"心跳超时: {self.heartbeat_timeout}秒"
+            )
+
+    def _send_heartbeat_loop(self):
+        """心跳发送循环"""
+        current_thread = threading.current_thread()
+        thread_ident = current_thread.ident
+        SYLogger.info(
+            f"nacos:心跳循环启动 - 线程ID: {thread_ident}, "
+            f"配置间隔: {self.heartbeat_interval}秒, "
+            f"超时时间: {self.heartbeat_timeout}秒"
+        )
+
+        consecutive_fail = 0
+
+        while not self.client_base._shutdown_event.is_set():
+            current_time = time.time()
+
+            try:
+                registered_status = self.registration.registered
+
+                if not registered_status:
+                    SYLogger.warning(
+                        f"nacos:服务未注册，跳过心跳 - 线程ID: {thread_ident}")
+                    consecutive_fail = 0
+                else:
+                    success = self.send_heartbeat()
+                    if success:
+                        consecutive_fail = 0
+                        SYLogger.info(
+                            f"nacos:心跳发送成功 - 时间: {current_time:.3f}, "
+                            f"间隔: {self.heartbeat_interval}秒"
+                        )
+                    else:
+                        consecutive_fail += 1
+                        SYLogger.warning(
+                            f"nacos:心跳发送失败 - 连续失败: {consecutive_fail}次"
+                        )
+                        if consecutive_fail >= 5:
+                            SYLogger.error("nacos:心跳连续失败5次，尝试重连")
+                            self.client_base.reconnect_nacos_client()
+                            consecutive_fail = 0
+
+            except Exception as e:
+                consecutive_fail += 1
+                SYLogger.error(
+                    f"nacos:心跳异常: {str(e)}, 连续失败: {consecutive_fail}次")
+
+            self.client_base._shutdown_event.wait(self.heartbeat_interval)
+
+        SYLogger.info(f"nacos:心跳循环已停止 - 线程ID: {thread_ident}")
+
+    def send_heartbeat(self) -> bool:
+        """发送心跳并添加超时控制"""
+        if not self.client_base.ensure_client_connected():
+            SYLogger.warning("nacos:客户端未连接，心跳发送失败")
+            return False
+
+        result_list = []
+
+        def heartbeat_task():
+            try:
+                result = self._send_heartbeat_internal()
+                result_list.append(result)
+            except Exception as e:
+                SYLogger.error(f"nacos:心跳任务执行异常: {e}")
+                result_list.append(False)
+
+        task_thread = threading.Thread(
+            target=heartbeat_task,
+            daemon=True,
+            name="NacosHeartbeatTaskThread"
+        )
+        task_thread.start()
+        task_thread.join(timeout=self.heartbeat_timeout)
+
+        if not result_list:
+            SYLogger.error(f"nacos:心跳发送超时（{self.heartbeat_timeout}秒）")
+            self.client_base._client_initialized = False
+            return False
+
+        return result_list[0]
+
+    def _send_heartbeat_internal(self) -> bool:
+        """实际的心跳发送逻辑"""
+        result = self.client_base.nacos_client.send_heartbeat(
+            service_name=self.registration.service_name,
+            ip=self.registration.real_ip,
+            port=int(self.registration.port),
+            cluster_name="DEFAULT",
+            weight=1.0,
+            metadata={
+                "version": self.registration.version} if self.registration.version else None
+        )
+
+        if result and isinstance(result, dict) and result.get('lightBeatEnabled', False):
+            SYLogger.info(f"nacos:心跳发送成功，Nacos返回: {result}")
+            return True
+        else:
+            SYLogger.warning(f"nacos:心跳发送失败，Nacos返回: {result}")
+            return False