sycommon-python-lib 0.1.54__tar.gz → 0.1.55a0__tar.gz

{sycommon_python_lib-0.1.54 → sycommon_python_lib-0.1.55a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.54
+Version: 0.1.55a0
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -12,6 +12,7 @@ Requires-Dist: kafka-python>=2.2.16
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
 Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
+Requires-Dist: netifaces>=0.11.0
 Requires-Dist: pydantic>=2.12.4
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3

{sycommon_python_lib-0.1.54 → sycommon_python_lib-0.1.55a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.54"
+version = "0.1.55-alpha"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -13,6 +13,7 @@ dependencies = [
     "loguru>=0.7.3",
     "mysql-connector-python>=9.5.0",
     "nacos-sdk-python>=2.0.9,<3.0",
+    "netifaces>=0.11.0",
     "pydantic>=2.12.4",
     "python-dotenv>=1.2.1",
     "pyyaml>=6.0.3",

{sycommon_python_lib-0.1.54 → sycommon_python_lib-0.1.55a0}/src/sycommon/services.py

@@ -92,17 +92,22 @@ class Services(metaclass=SingletonMeta):
         async def combined_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
             # 1. 执行Services自身的初始化
             instance = cls(config, app)
-            has_listeners = bool(
+
+            # 明确判断是否有有效的监听器/发送器配置
+            has_valid_listeners = bool(
                 rabbitmq_listeners and len(rabbitmq_listeners) > 0)
-            has_senders = bool(rabbitmq_senders and len(rabbitmq_senders) > 0)
+            has_valid_senders = bool(
+                rabbitmq_senders and len(rabbitmq_senders) > 0)
 
             try:
-                await instance._setup_mq_async(
-                    rabbitmq_listeners=rabbitmq_listeners,
-                    rabbitmq_senders=rabbitmq_senders,
-                    has_listeners=has_listeners,
-                    has_senders=has_senders
-                )
+                # 只有存在监听器或发送器时才初始化RabbitMQService
+                if has_valid_listeners or has_valid_senders:
+                    await instance._setup_mq_async(
+                        rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
+                        rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
+                        has_listeners=has_valid_listeners,
+                        has_senders=has_valid_senders
+                    )
                 cls._initialized = True
                 logging.info("Services初始化完成")
             except Exception as e:
@@ -145,7 +150,12 @@ class Services(metaclass=SingletonMeta):
         has_senders: bool = False,
     ):
         """异步设置MQ相关服务（适配单通道RabbitMQService）"""
-        # 初始化RabbitMQ服务，传递状态
+        # ========== 只有需要使用MQ时才初始化 ==========
+        if not (has_listeners or has_senders):
+            logging.info("无RabbitMQ监听器/发送器配置，跳过RabbitMQService初始化")
+            return
+
+        # 仅当有监听器或发送器时，才执行RabbitMQService初始化
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
         # 优化：等待连接池“存在且初始化完成”（避免提前执行后续逻辑）
@@ -156,25 +166,25 @@ class Services(metaclass=SingletonMeta):
             logging.info("等待RabbitMQ连接池初始化...")
             await asyncio.sleep(0.5)
 
-        # 设置发送器，传递是否有监听器的标志
-        if rabbitmq_senders:
+        # ========== 保留原有严格的发送器/监听器初始化判断 ==========
+        # 只有配置了发送器才执行发送器初始化
+        if has_senders and rabbitmq_senders:
             # 判断是否有监听器，如果有遍历监听器列表，队列名一样将prefetch_count属性设置到发送器对象中
-            if rabbitmq_listeners:
+            if has_listeners and rabbitmq_listeners:
                 for sender in rabbitmq_senders:
                     for listener in rabbitmq_listeners:
                         if sender.queue_name == listener.queue_name:
                             sender.prefetch_count = listener.prefetch_count
             await self._setup_senders_async(rabbitmq_senders, has_listeners)
 
-        # 设置监听器，传递是否有发送器的标志
-        if rabbitmq_listeners:
+        # 只有配置了监听器才执行监听器初始化
+        if has_listeners and rabbitmq_listeners:
             await self._setup_listeners_async(rabbitmq_listeners, has_senders)
 
         # 验证初始化结果
         if has_listeners:
             # 异步获取客户端数量（适配新的RabbitMQService）
-            listener_count = len(
-                RabbitMQService._consumer_tasks)
+            listener_count = len(RabbitMQService._consumer_tasks)
             logging.info(f"监听器初始化完成，共启动 {listener_count} 个消费者")
             if listener_count == 0:
                 logging.warning("未成功初始化任何监听器，请检查配置或MQ服务状态")

{sycommon_python_lib-0.1.54 → sycommon_python_lib-0.1.55a0}/src/sycommon/synacos/feign.py

@@ -135,13 +135,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')
@@ -158,7 +160,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_python_lib-0.1.54 → sycommon_python_lib-0.1.55a0}/src/sycommon/synacos/nacos_service.py

@@ -1,3 +1,4 @@
+import logging
 import threading
 import json
 from typing import Callable, Dict, List, Optional
@@ -14,6 +15,8 @@ import random
 from sycommon.config.Config import SingletonMeta
 from sycommon.logging.kafka_log import SYLogger
 
+logging.getLogger("nacos.client").setLevel(logging.WARNING)
+
 
 class NacosService(metaclass=SingletonMeta):
     def __init__(self, config):

sycommon_python_lib-0.1.55a0/src/sycommon/tools/snowflake.py

@@ -0,0 +1,221 @@
+import time
+import threading
+import socket
+import hashlib
+import random
+from typing import Optional
+from os import environ
+import netifaces
+
+
+class Snowflake:
+    """雪花算法生成器（无公网依赖，适配内网环境）"""
+    START_TIMESTAMP = 1388534400000  # 2014-01-01 00:00:00
+    SEQUENCE_BITS = 12
+    MACHINE_ID_BITS = 10
+    MAX_MACHINE_ID = (1 << MACHINE_ID_BITS) - 1  # 0~1023
+    MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1
+    MACHINE_ID_SHIFT = SEQUENCE_BITS
+    TIMESTAMP_SHIFT = SEQUENCE_BITS + MACHINE_ID_BITS
+
+    # 类级别的单例实例
+    _instance = None
+    _instance_lock = threading.Lock()
+
+    def __init__(self, machine_id: Optional[int] = None):
+        """
+        初始化：优先使用传入的machine_id，否则自动从K8s环境获取
+        :param machine_id: 手动指定机器ID（None则自动计算）
+        """
+        # 自动计算K8s环境下的machine_id
+        if machine_id is None:
+            machine_id = self._get_k8s_machine_id()
+
+        if not (0 <= machine_id <= self.MAX_MACHINE_ID):
+            raise ValueError(f"机器ID必须在0~{self.MAX_MACHINE_ID}之间")
+
+        self.machine_id = machine_id
+        self.last_timestamp = -1
+        self.sequence = 0
+        self.lock = threading.Lock()
+
+    def _get_k8s_machine_id(self) -> int:
+        """
+        从K8s环境自动计算唯一machine_id（无公网依赖，多层兜底）：
+        优先级：POD_NAME > POD_IP > 容器内网IP（网卡读取） > 容器主机名 > 随机数（最终兜底）
+        """
+        # 1. 优先读取K8s内置的POD_NAME（默认注入，优先级最高）
+        pod_name = environ.get("POD_NAME")
+        if pod_name:
+            return self._hash_to_machine_id(pod_name)
+
+        # 2. 读取POD_IP（手动配置downwardAPI后必存在）
+        pod_ip = environ.get("POD_IP")
+        if pod_ip:
+            return self._hash_to_machine_id(pod_ip)
+
+        # 3. 兜底1：读取本机网卡获取内网IP（无公网依赖）
+        try:
+            local_ip = self._get_local_internal_ip()
+            if local_ip:
+                return self._hash_to_machine_id(local_ip)
+            else:
+                # logger.warning("读取网卡信息成功，但未找到非回环内网IP")
+                pass
+        except Exception as e:
+            # logger.warning(f"读取本机网卡IP失败: {e}，尝试使用主机名")
+            pass
+
+        # 4. 兜底2：获取容器主机名（K8s中默认等于Pod名称，保证唯一）
+        hostname = socket.gethostname()
+        if hostname:
+            # logger.info(
+            #     f"未读取到POD_NAME/POD_IP/内网IP，使用主机名: {hostname}生成machine_id")
+            return self._hash_to_machine_id(hostname)
+
+        # 5. 最终兜底：生成随机数（仅极端情况使用，日志告警）
+        random_id = random.randint(0, self.MAX_MACHINE_ID)
+        # logger.warning(f"所有方式均失败，使用随机数生成machine_id: {random_id}（可能重复！）")
+        return random_id
+
+    def _get_local_internal_ip(self) -> Optional[str]:
+        """
+        读取本机网卡信息，获取非回环的内网IP（无公网依赖）
+        :return: 内网IP字符串，失败返回None
+        """
+        try:
+            # 遍历所有网卡
+            for interface in netifaces.interfaces():
+                # 获取网卡的IP地址信息
+                addrs = netifaces.ifaddresses(interface)
+                # 只取IPv4地址
+                if netifaces.AF_INET in addrs:
+                    for addr in addrs[netifaces.AF_INET]:
+                        ip = addr.get('addr')
+                        # 过滤回环地址（127.0.0.1）和docker虚拟地址（172.17.0.0/16可选过滤）
+                        if ip and not ip.startswith('127.'):
+                            # 可选：过滤docker0的默认地址段（根据实际内网段调整）
+                            # if not ip.startswith('172.17.'):
+                            return ip
+            return None
+        except ImportError:
+            # 若未安装netifaces，降级为socket方式（仅尝试本地解析，无公网连接）
+            # logger.warning("未安装netifaces库，尝试降级方式获取IP")
+            return self._get_local_ip_fallback()
+
+    def _get_local_ip_fallback(self) -> Optional[str]:
+        """
+        降级方案：不连接公网，仅通过本地socket获取IP（兼容无netifaces的场景）
+        """
+        try:
+            # 创建socket但不连接任何地址，仅绑定到本地
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            # 绑定到0.0.0.0:0（仅用于获取本机IP，不发送数据）
+            s.bind(('', 0))
+            local_ip = s.getsockname()[0]
+            s.close()
+            # 过滤回环地址
+            if not local_ip.startswith('127.'):
+                return local_ip
+            return None
+        except Exception:
+            return None
+
+    def _hash_to_machine_id(self, text: str) -> int:
+        """将字符串哈希后取模，得到0~1023的machine_id（保证分布均匀）"""
+        hash_bytes = hashlib.md5(text.encode("utf-8")).digest()
+        hash_int = int.from_bytes(hash_bytes[:4], byteorder="big")
+        return hash_int % self.MAX_MACHINE_ID
+
+    def _get_current_timestamp(self) -> int:
+        return int(time.time() * 1000)
+
+    def _wait_next_millisecond(self, current_timestamp: int) -> int:
+        while current_timestamp <= self.last_timestamp:
+            current_timestamp = self._get_current_timestamp()
+        return current_timestamp
+
+    def generate_id(self) -> int:
+        with self.lock:
+            current_timestamp = self._get_current_timestamp()
+
+            if current_timestamp < self.last_timestamp:
+                raise RuntimeError(
+                    f"时钟回拨检测：当前时间戳({current_timestamp}) < 上一次时间戳({self.last_timestamp})"
+                )
+
+            if current_timestamp == self.last_timestamp:
+                self.sequence = (self.sequence + 1) & self.MAX_SEQUENCE
+                if self.sequence == 0:
+                    current_timestamp = self._wait_next_millisecond(
+                        current_timestamp)
+            else:
+                self.sequence = 0
+
+            self.last_timestamp = current_timestamp
+
+            snowflake_id = (
+                ((current_timestamp - self.START_TIMESTAMP) << self.TIMESTAMP_SHIFT)
+                | (self.machine_id << self.MACHINE_ID_SHIFT)
+                | self.sequence
+            )
+
+            return snowflake_id
+
+    @staticmethod
+    def parse_id(snowflake_id: int) -> dict:
+        from datetime import datetime
+        sequence = snowflake_id & Snowflake.MAX_SEQUENCE
+        machine_id = (snowflake_id >>
+                      Snowflake.MACHINE_ID_SHIFT) & Snowflake.MAX_MACHINE_ID
+        timestamp = (snowflake_id >> Snowflake.TIMESTAMP_SHIFT) + \
+            Snowflake.START_TIMESTAMP
+        generate_time = datetime.fromtimestamp(
+            timestamp / 1000).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+        return {
+            "snowflake_id": snowflake_id,
+            "generate_time": generate_time,
+            "machine_id": machine_id,
+            "sequence": sequence
+        }
+
+    @classmethod
+    def next_id(cls) -> str:
+        """
+        生成雪花ID（单例模式，避免重复创建实例）
+        :return: 雪花ID字符串
+        """
+        # 单例模式创建实例
+        if cls._instance is None:
+            with cls._instance_lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        # 生成ID并转为字符串返回
+        return str(cls._instance.generate_id())
+
+
+if __name__ == "__main__":
+    # 生成1000个ID并验证
+    id_set = set()  # 用于检测重复ID
+    _MAX_JAVA_LONG = 9223372036854775807
+
+    for i in range(1000):
+        id_str = Snowflake.next_id()
+        id_num = int(id_str)
+
+        # 验证ID不超过Java long最大值
+        assert id_num <= _MAX_JAVA_LONG, f"ID超过Java long最大值: {id_num}"
+
+        # 验证ID不重复
+        assert id_str not in id_set, f"重复生成ID: {id_str}"
+        id_set.add(id_str)
+
+        # 每100个ID打印一次解析结果
+        if i % 100 == 0:
+            parse_result = Snowflake.parse_id(id_num)
+            print(f"生成ID: {id_str}")
+            print(f"解析结果: {parse_result}")
+            print("-" * 50)
+
+    print(f"成功生成{len(id_set)}个唯一雪花ID，验证通过！")

{sycommon_python_lib-0.1.54 → sycommon_python_lib-0.1.55a0}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.54
+Version: 0.1.55a0
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -12,6 +12,7 @@ Requires-Dist: kafka-python>=2.2.16
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
 Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
+Requires-Dist: netifaces>=0.11.0
 Requires-Dist: pydantic>=2.12.4
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3

{sycommon_python_lib-0.1.54 → sycommon_python_lib-0.1.55a0}/src/sycommon_python_lib.egg-info/requires.txt

@@ -6,6 +6,7 @@ kafka-python>=2.2.16
 loguru>=0.7.3
 mysql-connector-python>=9.5.0
 nacos-sdk-python<3.0,>=2.0.9
+netifaces>=0.11.0
 pydantic>=2.12.4
 python-dotenv>=1.2.1
 pyyaml>=6.0.3

sycommon_python_lib-0.1.54/src/sycommon/tools/snowflake.py

@@ -1,33 +0,0 @@
-import uuid
-
-
-class Snowflake:
-    """基于UUID生成兼容Java long类型的唯一ID"""
-    _MAX_JAVA_LONG = 9223372036854775807  # Java long最大值（18位）
-
-    @staticmethod
-    def next_id() -> str:
-        """生成不超过Java long最大值的唯一ID字符串（18位以内）"""
-        while True:
-            # 生成UUID并转换为整数
-            uuid_int = int(uuid.uuid4().hex, 16)
-
-            # 取低63位，并强制限制不超过Java long最大值
-            id_num = uuid_int & ((1 << 63) - 1)  # 取低63位
-            id_num = min(id_num, Snowflake._MAX_JAVA_LONG)  # 强制限制最大值
-
-            # 转换为字符串并验证长度（确保18位以内）
-            id_str = str(id_num)
-            if len(id_str) <= 18:
-                return id_str
-
-
-# 使用示例
-if __name__ == "__main__":
-    # 生成1000个ID并验证
-    for _ in range(1000):
-        id_str = Snowflake.next_id()
-        id_num = int(id_str)
-        print(f"ID: {id_str} (长度: {len(id_str)})")
-        assert len(id_str) <= 18, f"ID长度超过18位: {id_str}"
-        assert id_num <= Snowflake._MAX_JAVA_LONG, f"ID超过Java long最大值: {id_num}"