sycommon-python-lib 0.1.32__py3-none-any.whl → 0.1.56b5__py3-none-any.whl

sycommon/synacos/nacos_service.py

@@ -10,9 +10,8 @@ import yaml
 import time
 import atexit
 import random
-from concurrent.futures import ThreadPoolExecutor
 
-from sycommon.config.Config import SingletonMeta
+from sycommon.config.Config import Config, SingletonMeta
 from sycommon.logging.kafka_log import SYLogger
 
 
@@ -34,22 +33,17 @@ class NacosService(metaclass=SingletonMeta):
             # 添加可重入锁用于状态同步
             self._state_lock = threading.RLock()
 
-            # 优化线程池配置，增加工作线程数量
-            self._executor = ThreadPoolExecutor(max_workers=1)  # 主线程池
-            self._heartbeat_executor = ThreadPoolExecutor(
-                max_workers=1)  # 增加心跳线程
-            self._monitor_executor = ThreadPoolExecutor(
-                max_workers=1)  # 增加监控线程
-
             # 配置参数
             self.max_retries = self.nacos_config.get('maxRetries', 5)
-            self.retry_delay = self.nacos_config.get('retryDelay', 1)
-            self.retry_backoff = self.nacos_config.get('retryBackoff', 1.5)
+            self.retry_delay = self.nacos_config.get('retryDelay', 5)
             self.max_retry_delay = self.nacos_config.get('maxRetryDelay', 30)
+            # 心跳间隔：优先从配置读取，默认15秒（可通过配置修改）
             self.heartbeat_interval = self.nacos_config.get(
-                'heartbeatInterval', 10)
+                'heartbeatInterval', 15)
+            # 心跳超时：固定设置为15秒
+            self.heartbeat_timeout = 15
             self.register_retry_interval = self.nacos_config.get(
-                'registerRetryInterval', 5)  # 注册重试间隔
+                'registerRetryInterval', 15)  # 注册重试间隔
 
             # 长期重试配置
             self.long_term_retry_delay = self.nacos_config.get(
@@ -57,11 +51,13 @@ class NacosService(metaclass=SingletonMeta):
             self.max_long_term_retries = self.nacos_config.get(
                 'maxLongTermRetries', -1)  # -1表示无限重试
 
-            # 注册验证配置
+            # 注册验证配置：优化默认值（增加次数+延长间隔）
             self.registration_verify_count = self.nacos_config.get(
                 'registrationVerifyCount', 1)  # 验证次数
             self.registration_verify_interval = self.nacos_config.get(
                 'registrationVerifyInterval', 1)  # 验证间隔
+            self.registration_post_delay = self.nacos_config.get(
+                'registrationPostDelay', 3)  # 注册后延迟3秒再开始验证
 
             self.real_ip = self.get_service_ip(self.host)
             self._long_term_retry_count = 0  # 长期重试计数器
@@ -79,6 +75,8 @@ class NacosService(metaclass=SingletonMeta):
                 SYLogger.info("nacos:本地开发模式，不初始化Nacos客户端")
 
             self.share_configs = self.read_configs()
+            # 设置llm相关配置
+            Config().set_attr(self.share_configs)
 
             # 配置监听器
             self._config_listeners = {}
@@ -129,8 +127,7 @@ class NacosService(metaclass=SingletonMeta):
                 self._client_initialized = True
                 return True
             except Exception as e:
-                delay = min(self.retry_delay * (self.retry_backoff **
-                            attempt), self.max_retry_delay)
+                delay = min(self.retry_delay, self.max_retry_delay)
                 SYLogger.error(
                     f"nacos:客户端初始化失败 (尝试 {attempt+1}/{self.max_retries}): {e}")
                 time.sleep(delay)
@@ -193,8 +190,7 @@ class NacosService(metaclass=SingletonMeta):
 
                 except Exception as e:
                     attempt += 1
-                    delay = min(self.retry_delay * (self.retry_backoff **
-                                (attempt - 1)), self.max_retry_delay)
+                    delay = min(self.retry_delay, self.max_retry_delay)
 
                     SYLogger.error(
                         f"nacos:客户端初始化失败 (尝试 {attempt}/{max_attempts}): {e}")
@@ -308,12 +304,12 @@ class NacosService(metaclass=SingletonMeta):
                 if not register_success:
                     raise RuntimeError("nacos:服务注册请求失败")
 
-                # 注册请求发送成功后，等待一小段时间让Nacos服务器处理
+                # 关键优化1：注册请求发送后，延迟一段时间再验证（默认3秒）
                 SYLogger.info(
-                    f"nacos:服务注册请求已发送，等待 {self.registration_verify_interval} 秒后验证")
-                time.sleep(self.registration_verify_interval)
+                    f"nacos:服务注册请求已发送，延迟 {self.registration_post_delay} 秒后开始验证（确保Nacos服务器完成实例写入）")
+                time.sleep(self.registration_post_delay)
 
-                # 多次验证服务是否真正注册成功
+                # 关键优化2：多次验证服务是否真正注册成功（默认3次，每次间隔2秒）
                 registered = self.verify_registration()
 
                 # 带锁更新注册状态
@@ -342,8 +338,7 @@ class NacosService(metaclass=SingletonMeta):
             except Exception as e:
                 last_error = str(e)
                 retry_count += 1
-                delay = min(self.register_retry_interval *
-                            (self.retry_backoff ** (retry_count - 1)), self.max_retry_delay)
+                delay = min(self.register_retry_interval, self.max_retry_delay)
 
                 SYLogger.warning(
                     f"nacos:服务注册尝试 {retry_count} 失败: {last_error}，{delay}秒后重试")
@@ -429,8 +424,13 @@ class NacosService(metaclass=SingletonMeta):
             timeout = 60  # 60秒超时
             start_time = time.time()
 
-            # 启动注册线程，不阻塞主线程
-            instance._executor.submit(instance.register_with_retry)
+            # 启动注册线程，不阻塞主线程（替换原线程池）
+            register_thread = threading.Thread(
+                target=instance.register_with_retry,
+                daemon=True,
+                name="NacosRegisterThread"
+            )
+            register_thread.start()
 
             # 等待注册完成或超时
             while True:
@@ -461,7 +461,7 @@ class NacosService(metaclass=SingletonMeta):
 
             # 启动连接监控线程
             threading.Thread(target=instance.monitor_connection,
-                             daemon=True).start()
+                             daemon=True, name="NacosConnectionMonitorThread").start()
         else:
             SYLogger.info("nacos:本地开发模式，跳过服务注册流程")
 
@@ -485,7 +485,11 @@ class NacosService(metaclass=SingletonMeta):
             )
             self._heartbeat_thread.daemon = True
             self._heartbeat_thread.start()
-            SYLogger.info(f"nacos:心跳线程启动，线程ID: {self._heartbeat_thread.ident}")
+            SYLogger.info(
+                f"nacos:心跳线程启动，线程ID: {self._heartbeat_thread.ident}，"
+                f"心跳间隔: {self.heartbeat_interval}秒，"
+                f"心跳超时: {self.heartbeat_timeout}秒"
+            )
 
     def _send_heartbeat_loop(self):
         """优化后的心跳发送循环，确保严格按间隔执行"""
@@ -493,7 +497,8 @@ class NacosService(metaclass=SingletonMeta):
         thread_ident = current_thread.ident
         SYLogger.info(
             f"nacos:心跳循环启动 - 线程ID: {thread_ident}, "
-            f"配置间隔: {self.heartbeat_interval}秒"
+            f"配置间隔: {self.heartbeat_interval}秒, "
+            f"超时时间: {self.heartbeat_timeout}秒"
         )
 
         consecutive_fail = 0  # 连续失败计数器
@@ -512,7 +517,7 @@ class NacosService(metaclass=SingletonMeta):
                         f"nacos:服务未注册，跳过心跳 - 线程ID: {thread_ident}")
                     consecutive_fail = 0
                 else:
-                    # 发送心跳
+                    # 发送心跳（10秒超时）
                     success = self.send_heartbeat()
                     if success:
                         consecutive_fail = 0
@@ -545,26 +550,46 @@ class NacosService(metaclass=SingletonMeta):
         SYLogger.info(f"nacos:心跳循环已停止 - 线程ID: {thread_ident}")
 
     def send_heartbeat(self):
-        """发送心跳并添加超时控制"""
+        """发送心跳并添加10秒超时控制（替换线程池实现）"""
         if not self.ensure_client_connected():
             SYLogger.warning("nacos:客户端未连接，心跳发送失败")
             return False
 
-        try:
-            # 严格控制心跳超时（3秒）
-            future = self._heartbeat_executor.submit(
-                self._send_heartbeat_internal)
-            result = future.result(timeout=3)  # 超时后抛出异常
-
-            if result:
-                # 只有确认成功才更新时间戳
-                self._last_successful_heartbeat = time.time()
-            return result
-        except Exception as e:
-            SYLogger.error(f"nacos:发送心跳时发生异常: {e}")
+        # 用线程+join实现10秒超时控制
+        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()
+
+        # 等待线程完成，最多等待10秒
+        task_thread.join(timeout=self.heartbeat_timeout)
+
+        # 处理结果
+        if not result_list:
+            # 超时未返回
+            SYLogger.error(f"nacos:心跳发送超时（{self.heartbeat_timeout}秒）")
             self._client_initialized = False  # 强制重连
             return False
 
+        # 检查心跳结果
+        if result_list[0]:
+            self._last_successful_heartbeat = time.time()
+        return result_list[0]
+
     def _send_heartbeat_internal(self):
         """实际的心跳发送逻辑"""
         result = self.nacos_client.send_heartbeat(
@@ -620,9 +645,13 @@ class NacosService(metaclass=SingletonMeta):
                         else:
                             self.registered = False
                             SYLogger.warning(f"nacos:服务实例未注册，尝试重新注册")
-                            # 不在锁内调用可能耗时的操作
-                            self._monitor_executor.submit(
-                                self.register_with_retry)
+                            # 启动临时线程执行重新注册（替换原线程池）
+                            retry_thread = threading.Thread(
+                                target=self.register_with_retry,
+                                daemon=True,
+                                name="NacosRetryRegisterThread"
+                            )
+                            retry_thread.start()
 
                 # 20%的概率执行深度检查
                 if random.random() < 0.2:
@@ -673,13 +702,6 @@ class NacosService(metaclass=SingletonMeta):
             SYLogger.error(f"nacos:注销服务时发生错误: {e}")
         finally:
             self._shutdown_event.set()
-            # 优雅地关闭线程池
-            if self._executor and not self._executor._shutdown:
-                self._executor.shutdown(wait=True)
-            if self._heartbeat_executor and not self._heartbeat_executor._shutdown:
-                self._heartbeat_executor.shutdown(wait=True)
-            if self._monitor_executor and not self._monitor_executor._shutdown:
-                self._monitor_executor.shutdown(wait=True)
 
     def handle_signal(self, signum, frame):
         """处理退出信号"""
@@ -751,8 +773,18 @@ class NacosService(metaclass=SingletonMeta):
                 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):
-                        self._executor.submit(callback, new_config)
+                        # 直接执行回调（替换原线程池，配置回调通常为轻量操作）
+                        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._shutdown_event.wait(check_interval)
@@ -785,6 +817,11 @@ class NacosService(metaclass=SingletonMeta):
                 return []
 
             all_instances = instances.get('hosts', [])
+            # 筛选已上线实例
+            all_instances = [
+                instance for instance in all_instances
+                if instance.get('enabled', True)  # 默认True担心阿里变更sdk
+            ]
             SYLogger.info(
                 f"nacos:共发现 {len(all_instances)} 个 {service_name} 服务实例")
 

sycommon/tools/merge_headers.py

@@ -0,0 +1,97 @@
+def merge_headers(
+    source_headers,  # 来源headers（支持多种格式：字典/MutableHeaders/键值对列表/元组）
+    target_headers,  # 目标headers（原有值需保留，同名覆盖source）
+    keep_keys=None,  # 需保留的key集合（None表示保留所有）
+    delete_keys={'content-length', 'accept',
+                 'content-type', 'sec-fetch-mode',
+                 'sec-fetch-dest', 'sec-fetch-site',
+                 'pragma', 'cache-control',
+                 'accept-encoding', 'priority'},  # 需删除的source key集合
+    encoding='utf-8'  # 字符编码（处理bytes转换）
+) -> dict:
+    """
+    合并headers，最终规则：
+    1. 所有key统一转为小写进行比较判断（完全大小写无关）
+    2. target_headers 同名key 完全覆盖 source_headers（source同名key不生效）
+    3. delete_keys 作用于source_headers：source中所有该列表内的key一律不添加（无论是否新增）
+    4. target_headers 中的key即使在delete_keys也始终保留，不受删除规则影响
+    5. 自动处理bytes/其他类型的键值转换为字符串
+    6. 最终输出的key全部为小写
+    """
+    # 初始化并统一转为小写集合
+    keep_keys = {k.lower() for k in keep_keys} if keep_keys else set()
+    delete_keys = {k.lower() for k in delete_keys} if delete_keys else set()
+
+    # 修复1：兼容 MutableHeaders/普通字典/None 等 target_headers 类型
+    if target_headers is None:
+        target_dict = {}
+    elif hasattr(target_headers, 'items'):
+        # 支持 MutableHeaders/Headers/普通字典（都有items()方法）
+        target_dict = dict(target_headers.items())
+    else:
+        # 兜底：可迭代对象转为字典
+        target_dict = dict(target_headers) if isinstance(
+            target_headers, (list, tuple)) else {}
+
+    # 标准化target_headers：key转为小写，保留原有值
+    processed_headers = {k.lower(): v for k, v in target_dict.items()}
+    target_original_keys = set(processed_headers.keys())
+
+    # 修复2：统一处理 source_headers 格式，确保是键值对迭代器
+    # 步骤1：将source_headers转为标准的键值对列表
+    if source_headers is None:
+        source_kv_list = []
+    elif hasattr(source_headers, 'items'):
+        # 字典/MutableHeaders → 转为键值对列表
+        source_kv_list = list(source_headers.items())
+    elif isinstance(source_headers, (list, tuple)):
+        # 列表/元组 → 校验并过滤合法的键值对（仅保留长度为2的元组/列表）
+        source_kv_list = []
+        for item in source_headers:
+            if isinstance(item, (list, tuple)) and len(item) == 2:
+                source_kv_list.append(item)
+            else:
+                # 跳过非法格式（如长度≠2的元素），避免解包报错
+                continue
+    else:
+        # 其他类型 → 空列表（避免迭代报错）
+        source_kv_list = []
+
+    # 处理来源headers的键值转换和合并（遍历标准化后的键值对）
+    for key, value in source_kv_list:
+        # 转换key为字符串并统一转为小写（判断用）
+        if not isinstance(key, str):
+            try:
+                key = key.decode(encoding, errors='replace') if isinstance(
+                    key, bytes) else str(key)
+            except Exception:
+                # 极端情况：无法转换的key直接跳过
+                continue
+
+        key_lower = key.lower()
+
+        # 转换value为字符串
+        if not isinstance(value, str):
+            try:
+                value = value.decode(encoding, errors='replace') if isinstance(
+                    value, bytes) else str(value)
+            except Exception:
+                # 无法转换的value设为空字符串
+                value = ""
+
+        # 过滤1：source的key在删除列表 → 直接跳过
+        if key_lower in delete_keys:
+            continue
+
+        # 过滤2：仅保留指定的key（如果设置了keep_keys）
+        if keep_keys and key_lower not in keep_keys:
+            continue
+
+        # 过滤3：target已有同名key → 直接跳过（target值覆盖source）
+        if key_lower in target_original_keys:
+            continue
+
+        # 仅添加符合条件的key-value（最终key为小写）
+        processed_headers[key_lower] = value
+
+    return processed_headers