funboost 50.3__py3-none-any.whl → 50.4__py3-none-any.whl

funboost/core/funboost_time.py

@@ -5,7 +5,7 @@ import datetime
 
 import typing
 import threading
-from nb_time import NbTime
+from nb_time import NbTime,NowTimeStrCache
 from funboost.funboost_config_deafult import FunboostCommonConfig
 
 
@@ -29,87 +29,8 @@ class FunboostTime(NbTime):
         return t_str
 
 
-# 缓存时区对象，提升性能（避免重复解析）
-_tz_cache = {}
-
-_DIGIT_MAP = {i: f'{i:02d}' for i in range(100)}
-
-
-def _gen_2_dig_number(n):
-    return _DIGIT_MAP[n]
-
-
-def get_now_time_str_by_tz(tz_name: str = None) -> str:
-    # 生成100万次当前时间字符串%Y-%m-%d %H:%M:%S仅需1.9秒.              
-    """
-    根据时区名（如 'Asia/Shanghai'）返回当前时间字符串，格式：'%Y-%m-%d %H:%M:%S'
-    
-    兼容 Python 3.6+，优先使用 zoneinfo（3.9+），否则尝试 pytz
-    
-    :param tz_name: IANA 时区名称，如 'Asia/Shanghai', 'America/New_York'
-    :return: 格式化时间字符串
-    """
-    # 检查缓存
-    tz_name = tz_name or FunboostCommonConfig.TIMEZONE
-    if tz_name not in _tz_cache:
-        if sys.version_info >= (3, 9):
-            from zoneinfo import ZoneInfo
-            _tz_cache[tz_name] = ZoneInfo(tz_name)
-        else:
-            # Python < 3.9，使用 pytz
-            _tz_cache[tz_name] = pytz.timezone(tz_name)
-
-
-    tz = _tz_cache[tz_name]
-
-    # 获取当前时间并格式化（注意：datetime.now(tz) 是最高效的方式）
-    now = datetime.datetime.now(tz)
-    # return f'{now.year:04d}-{now.month:02d}-{now.day:02d} {now.hour:02d}:{now.minute:02d}:{now.second:02d}'
-    # return now.strftime("%Y-%m-%d %H:%M:%S")
-    return f'{now.year}-{_gen_2_dig_number(now.month)}-{_gen_2_dig_number(now.day)} {_gen_2_dig_number(now.hour)}:{_gen_2_dig_number(now.minute)}:{_gen_2_dig_number(now.second)}'
-
-
-class NowTimeStrCache:
-    # 生成100万次当前时间字符串%Y-%m-%d %H:%M:%S仅需0.4秒.
-    # 全局变量，用于存储缓存的时间字符串和对应的整秒时间戳
-    _cached_time_str: typing.Optional[str] = None
-    _cached_time_second: int = 0
-
-    # 为了线程安全，使用锁。在极高并发下，锁的开销远小于每毫秒都进行时间格式化。
-    _time_cache_lock = threading.Lock()
-
-    @classmethod
-    def fast_get_now_time_str(cls,timezone_str:str=None) -> str:
-        """
-        获取当前时间字符串，格式为 '%Y-%m-%d %H:%M:%S'。
-        通过缓存机制，同一秒内的多次调用直接返回缓存结果，极大提升性能。
-        适用于对时间精度要求不高（秒级即可）的高并发场景。
-        :return: 格式化后的时间字符串，例如 '2024-06-12 15:30:45'
-        """
-        timezone_str = timezone_str or FunboostCommonConfig.TIMEZONE
-
-        # 获取当前的整秒时间戳（去掉小数部分）
-        current_second = int(time.time())
-
-        # 如果缓存的时间戳与当前秒数一致，直接返回缓存的字符串。
-        if current_second == cls._cached_time_second:
-            return cls._cached_time_str
-
-        # 如果不一致，说明进入新的一秒，需要重新计算并更新缓存。
-        # 使用锁确保在多线程环境下，只有一个线程会执行更新操作。
-
-        with cls._time_cache_lock:
-            # 双重检查锁定 (Double-Checked Locking)，防止在等待锁的过程中，其他线程已经更新了缓存。
-            if current_second == cls._cached_time_second:
-                return cls._cached_time_str
-
-            # 重新计算时间字符串。这里直接使用 time.strftime，因为它在秒级更新的场景下性能足够。
-            # 我们不需要像 Funboost 那样为每一毫秒的调用都去做查表优化。
-            now = datetime.datetime.now(tz=pytz.timezone(timezone_str))
-            cls._cached_time_str = now.strftime('%Y-%m-%d %H:%M:%S', )
-            cls._cached_time_second = current_second
-
-        return cls._cached_time_str
+def fast_get_now_time_str() -> str:
+    return NowTimeStrCache.fast_get_now_time_str(FunboostCommonConfig.TIMEZONE)
 
 
 if __name__ == '__main__':

funboost/core/func_params_model.py

@@ -212,9 +212,15 @@ class BoosterParams(BaseJsonAbleModel):
     consuming_function_raw: typing.Optional[typing.Callable] = None  # 不需要传递，自动生成
     consuming_function_name: str = '' # 不需要传递，自动生成
 
+    
+    """
+    # 加上一个不同种类中间件非通用的配置,不同中间件自身独有的配置，不是所有中间件都兼容的配置，因为框架支持30种消息队列，消息队列不仅仅是一般的先进先出queue这么简单的概念，
+    # 例如kafka支持消费者组，rabbitmq也支持各种独特概念例如各种ack机制 复杂路由机制，有的中间件原生能支持消息优先级有的中间件不支持,每一种消息队列都有独特的配置参数意义，可以通过这里传递。
+    # 每种中间件能传递的键值对可以看 funboost/core/broker_kind__exclusive_config_default.py 的 BROKER_EXCLUSIVE_CONFIG_DEFAULT 属性。
+    """
+    broker_exclusive_config: dict = {} 
+
 
-    broker_exclusive_config: dict = {}  # 加上一个不同种类中间件非通用的配置,不同中间件自身独有的配置，不是所有中间件都兼容的配置，因为框架支持30种消息队列，消息队列不仅仅是一般的先进先出queue这么简单的概念，
-    # 例如kafka支持消费者组，rabbitmq也支持各种独特概念例如各种ack机制 复杂路由机制，有的中间件原生能支持消息优先级有的中间件不支持,每一种消息队列都有独特的配置参数意义，可以通过这里传递。每种中间件能传递的键值对可以看consumer类的 BROKER_EXCLUSIVE_CONFIG_DEFAULT
 
     should_check_publish_func_params: bool = True  # 消息发布时候是否校验消息发布内容,比如有的人发布消息,函数只接受a,b两个入参,他去传2个入参,或者传参不存在的参数名字; 如果消费函数加了装饰器 ，你非要写*args,**kwargs,那就需要关掉发布消息时候的函数入参检查
     publish_msg_log_use_full_msg: bool = False # 发布到消息队列的消息内容的日志，是否显示消息的完整体，还是只显示函数入参。
@@ -241,7 +247,7 @@ class BoosterParams(BaseJsonAbleModel):
     
     使用场景见文档 4b.6 章节.
     """
-    user_options: dict = {} # 用户自定义的配置,高级用户或者奇葩需求可以用得到,用户可以自由发挥,存放任何设置.
+    user_options: dict = {} # 用户自定义的配置,高级用户或者奇葩需求可以用得到,用户可以自由发挥,存放任何设置,例如配合 consumer_override_cls中读取 或 register_custom_broker 使用
     
     
     auto_generate_info: dict = {}  # 自动生成的信息,不需要用户主动传参.

funboost/core/helper_funs.py

@@ -3,7 +3,7 @@ import pytz
 import time
 import uuid
 import datetime
-from funboost.core.funboost_time import FunboostTime, get_now_time_str_by_tz, NowTimeStrCache
+from funboost.core.funboost_time import FunboostTime, fast_get_now_time_str
 
 
 def get_publish_time(paramsx: dict):
@@ -62,7 +62,7 @@ class MsgGenerater:
     def generate_publish_time_format() -> str:
         # return FunboostTime().get_str()  # 性能不好
         # return get_now_time_str_by_tz()  # 2秒100万次
-        return NowTimeStrCache.fast_get_now_time_str() # 0.4秒100万次
+        return fast_get_now_time_str() # 0.4秒100万次
 
 
     @classmethod

funboost/factories/broker_kind__publsiher_consumer_type_map.py

@@ -115,6 +115,11 @@ def regist_to_funboost(broker_kind: str):
         from funboost.consumers.rabbitmq_amqpstorm_consumer import RabbitmqConsumerAmqpStorm
         register_custom_broker(BrokerEnum.RABBITMQ_AMQPSTORM, RabbitmqPublisherUsingAmqpStorm, RabbitmqConsumerAmqpStorm)
 
+    if broker_kind == BrokerEnum.RABBITMQ_COMPLEX_ROUTING:
+        from funboost.publishers.rabbitmq_complex_routing_publisher import RabbitmqComplexRoutingPublisher
+        from funboost.consumers.rabbitmq_complex_routing_consumer import RabbitmqComplexRoutingConsumer
+        register_custom_broker(BrokerEnum.RABBITMQ_COMPLEX_ROUTING, RabbitmqComplexRoutingPublisher, RabbitmqComplexRoutingConsumer)
+
     if broker_kind == BrokerEnum.RABBITMQ_RABBITPY:
         from funboost.publishers.rabbitmq_rabbitpy_publisher import RabbitmqPublisherUsingRabbitpy
         from funboost.consumers.rabbitmq_rabbitpy_consumer import RabbitmqConsumerRabbitpy

funboost/funboost_config_deafult.py

@@ -1,9 +1,6 @@
 # -*- coding: utf-8 -*-
 import logging
 from pathlib import Path
-import pytz
-from funboost.constant import BrokerEnum, ConcurrentModeEnum
-from funboost.core.func_params_model import FunctionResultStatusPersistanceConfig
 from funboost.utils.simple_data_class import DataClassBase
 from nb_log import nb_log_config_default
 

funboost/function_result_web/templates/fun_result_table.html

@@ -325,7 +325,7 @@
                         var time_start_obj = new Date(item.time_start * 1000);
                         var time_start_str = dateToString(time_start_obj);
 
-                        tr = tr.format(displayLevel, item.host_process + ' - ' + item.script_name, item.function, item.params_str, item.result, item.publish_time_str,
+                        tr = tr.format(displayLevel, item.host_process + ' - ' + item.script_name, item.function, item.params_str, item.result, item.publish_time_format,
                             time_start_str, item.time_cost, item.run_times, run_status_text, successText, item.exception, item.total_thread);
                         html += tr;
                     }

funboost/publishers/base_publisher.py

@@ -10,7 +10,6 @@ import atexit
 import json
 import logging
 import multiprocessing
-from re import S
 import sys
 import threading
 import time
@@ -20,6 +19,7 @@ from threading import Lock
 
 import nb_log
 from funboost.constant import ConstStrForClassMethod, FunctionKind
+from funboost.core.broker_kind__exclusive_config_default_define import generate_broker_exclusive_config
 from funboost.core.func_params_model import PublisherParams, PriorityConsumingControlConfig
 from funboost.core.function_result_status_saver import FunctionResultStatus
 from funboost.core.helper_funs import MsgGenerater
@@ -140,11 +140,12 @@ class PublishParamsChecker(FunboostFileLoggerMixin):
 class AbstractPublisher(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     def __init__(self, publisher_params: PublisherParams, ):
         self.publisher_params = publisher_params
+        
         self.queue_name = self._queue_name = publisher_params.queue_name
         self.logger: logging.Logger
         self._build_logger()
         self.publish_params_checker = PublishParamsChecker(publisher_params.consuming_function) if publisher_params.consuming_function else None
-
+        self.publisher_params.broker_exclusive_config = generate_broker_exclusive_config(self.publisher_params.broker_kind,self.publisher_params.broker_exclusive_config,self.logger)
         self.has_init_broker = 0
         self._lock_for_count = Lock()
         self._current_time = None

funboost/publishers/rabbitmq_amqpstorm_publisher.py

@@ -12,19 +12,20 @@ from funboost.utils import decorators
 class RabbitmqPublisherUsingAmqpStorm(AbstractPublisher):
     # 使用amqpstorm包实现的mq操作。
     # 实例属性没在__init__里面写，造成代码补全很麻烦，写在这里做类属性，方便pycharm补全
-    connection = amqpstorm.UriConnection
-    channel = amqpstorm.Channel
-    channel_wrapper_by_ampqstormbaic = AmqpStormBasic
-    queue = AmqpStormQueue
-    DURABLE = True
+    connection : amqpstorm.UriConnection
+    channel : amqpstorm.Channel
+    channel_wrapper_by_ampqstormbaic : AmqpStormBasic
+    queue : AmqpStormQueue
+
 
     def custom_init(self):
         arguments = {}     #  {'x-queue-type':'classic'} classic stream lazy quorum
         if self.publisher_params.broker_exclusive_config.get('x-max-priority'):
             arguments['x-max-priority'] = self.publisher_params.broker_exclusive_config['x-max-priority']
-        self.queue_declare_params = dict(queue=self._queue_name, durable=self.DURABLE, arguments=arguments,auto_delete=False)
+        self._queue_durable =  self.publisher_params.broker_exclusive_config['queue_durable']
+        self.queue_declare_params = dict(queue=self._queue_name, durable=self._queue_durable, arguments=arguments,auto_delete=False)
 
-    # noinspection PyAttributeOutsideInit
+    # noinspection PyAttrib_durableuteOutsideInit
     # @decorators.synchronized
     def init_broker(self):
         # username=app_config.RABBITMQ_USER, password=app_config.RABBITMQ_PASS, host=app_config.RABBITMQ_HOST, port=app_config.RABBITMQ_PORT, virtual_host=app_config.RABBITMQ_VIRTUAL_HOST, heartbeat=60 * 10

funboost/publishers/rabbitmq_complex_routing_publisher.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2022/8/8 0008 12:06
+import amqpstorm
+from amqpstorm.basic import Basic as AmqpStormBasic
+from amqpstorm.queue import Queue as AmqpStormQueue
+from funboost.funboost_config_deafult import BrokerConnConfig
+from funboost.publishers.base_publisher import AbstractPublisher, deco_mq_conn_error
+from funboost.utils import decorators
+
+
+class RabbitmqComplexRoutingPublisher(AbstractPublisher):
+    # 使用amqpstorm包实现的mq操作。
+    # 实例属性没在__init__里面写，造成代码补全很麻烦，写在这里做类属性，方便pycharm补全
+    connection : amqpstorm.UriConnection
+    channel : amqpstorm.Channel
+    channel_wrapper_by_ampqstormbaic : AmqpStormBasic
+    queue : AmqpStormQueue
+
+
+    def custom_init(self):
+        arguments = {}     #  {'x-queue-type':'classic'} classic stream lazy quorum
+        if self.publisher_params.broker_exclusive_config.get('x-max-priority'):
+            arguments['x-max-priority'] = self.publisher_params.broker_exclusive_config['x-max-priority']
+        self._queue_durable = self.publisher_params.broker_exclusive_config['queue_durable']
+        self.queue_declare_params = dict(queue=self._queue_name, durable=self._queue_durable,
+                                         arguments=arguments,auto_delete=False)
+        
+        self._exchange_name = self.publisher_params.broker_exclusive_config['exchange_name']
+        self._exchange_type = self.publisher_params.broker_exclusive_config['exchange_type']
+        # 如果用户没有在 broker_exclusive_config 中指定 routing_key_for_publish，则默认使用队列名作为 routing_key
+        self._routing_key_for_publish = self.publisher_params.broker_exclusive_config.get('routing_key_for_publish') or self._queue_name  # 这里你已经用了很好的实践
+
+        self._exchange_declare_durable = self.publisher_params.broker_exclusive_config['exchange_declare_durable']
+
+        self.init_broker()
+
+
+    # noinspection PyAttributeOutsideInit
+    # @decorators.synchronized
+    def init_broker(self):
+        # username=app_config.RABBITMQ_USER, password=app_config.RABBITMQ_PASS, host=app_config.RABBITMQ_HOST, port=app_config.RABBITMQ_PORT, virtual_host=app_config.RABBITMQ_VIRTUAL_HOST, heartbeat=60 * 10
+        self.logger.warning(f'使用AmqpStorm包 链接mq')
+        self.connection = amqpstorm.UriConnection(
+            f'amqp://{BrokerConnConfig.RABBITMQ_USER}:{BrokerConnConfig.RABBITMQ_PASS}@{BrokerConnConfig.RABBITMQ_HOST}:{BrokerConnConfig.RABBITMQ_PORT}/{BrokerConnConfig.RABBITMQ_VIRTUAL_HOST}?heartbeat={60 * 10}&timeout=20000'
+        )
+        self.channel = self.connection.channel()  # type:amqpstorm.Channel
+        self.channel_wrapper_by_ampqstormbaic = AmqpStormBasic(self.channel)
+        # 发布者不声明队列，队列的声明和绑定完全由消费者负责。
+        if self._exchange_name:
+            self.channel.exchange.declare(exchange=self._exchange_name, exchange_type=self._exchange_type,
+                                          durable=self._exchange_declare_durable)
+
+    # @decorators.tomorrow_threads(10)
+    @deco_mq_conn_error
+    def concrete_realization_of_publish(self, msg: str):
+        routing_key_publish_dynamic = self._get_from_other_extra_params('routing_key_for_publish', msg)
+        routing_key_publish = routing_key_publish_dynamic if routing_key_publish_dynamic is not None else self._routing_key_for_publish
+        # 核心修正2：为 headers 交换机添加 headers 支持
+        headers = self._get_from_other_extra_params('headers_for_publish', msg)
+
+        self.channel_wrapper_by_ampqstormbaic.publish(exchange=self._exchange_name,
+                                                      routing_key=routing_key_publish,
+                                                      body=msg,
+                                                      properties={'delivery_mode': 2,
+                                                                  'priority': self._get_from_other_extra_params('priority', msg),
+                                                                  'headers': headers}, )
+        # nb_print(msg)
+
+    @deco_mq_conn_error
+    def clear(self):
+        AmqpStormQueue(self.channel).purge(self._queue_name)
+        self.logger.warning(f'清除 {self._queue_name} 队列中的消息成功')
+
+    @deco_mq_conn_error
+    def get_message_count(self):
+        # noinspection PyUnresolvedReferences
+        return AmqpStormQueue(self.channel).declare(**self.queue_declare_params)['message_count']
+
+    # @deco_mq_conn_error
+    def close(self):
+        self.channel.close()
+        self.connection.close()
+        self.logger.warning('关闭amqpstorm包 链接mq')

funboost/utils/redis_manager.py

@@ -1,6 +1,8 @@
 # coding=utf8
 
 import copy
+import os
+import threading
 # import redis2 as redis
 # import redis3
 import redis5
@@ -25,14 +27,18 @@ def _get_redis_conn_kwargs_by_db(db):
 
 class RedisManager(object):
     _redis_db__conn_map = {}
+    _lock = threading.Lock()
 
     def __init__(self, host='127.0.0.1', port=6379, db=0, username='', password='',ssl=False):
-        self._key = (host, port, db, username, password,ssl)
+        pid = os.getpid()
+        self._key = (host, port, db, username, password,ssl,pid)
         if self._key not in self.__class__._redis_db__conn_map:
-            self.__class__._redis_db__conn_map[self._key] = redis5.Redis(host=host, port=port, db=db, username=username,
-                                                                         password=password, max_connections=1000,
-                                                                         ssl=ssl,
-                                                                         decode_responses=True)
+            with self.__class__._lock:
+                 if self._key not in self.__class__._redis_db__conn_map:
+                     self.__class__._redis_db__conn_map[self._key] = redis5.Redis(host=host, port=port, db=db, username=username,
+                                                                            password=password, max_connections=100,
+                                                                            ssl=ssl,
+                                                                            decode_responses=True)
         self.redis = self.__class__._redis_db__conn_map[self._key]
 
     def get_redis(self) -> redis5.Redis: