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

funboost/contrib/{save_result_status_to_sqldb.py → save_function_result_status/save_result_status_to_sqldb.py}

@@ -1,3 +1,11 @@
+
+"""
+一个贡献,保存函数结果状态到 mysql postgre 等等,因为默认是使用mongo保存.
+
+可以在 @boost里面指定 user_custom_record_process_info_func= save_result_status_to_sqlalchemy
+"""
+
+
 import copy
 import functools
 import json
@@ -7,49 +15,8 @@ from sqlalchemy import create_engine
 
 from funboost import boost, FunctionResultStatus, funboost_config_deafult
 
-"""
--- 如果用户是先保存到mysql中而非mongodb,用户自己先创建表,用于保存函数消费状态和结果.
-
-CREATE TABLE funboost_consume_results
-(
-    _id              VARCHAR(255),
-    `function`         VARCHAR(255),
-    host_name        VARCHAR(255),
-    host_process     VARCHAR(255),
-    insert_minutes   VARCHAR(255),
-    insert_time      datetime,
-    insert_time_str  VARCHAR(255),
-    msg_dict         JSON,
-    params           JSON,
-    params_str       VARCHAR(255),
-    process_id       BIGINT(20),
-    publish_time     FLOAT,
-    publish_time_str VARCHAR(255),
-    queue_name       VARCHAR(255),
-    result           VARCHAR(255),
-    run_times        INT,
-    script_name      VARCHAR(255),
-    script_name_long VARCHAR(255),
-    success          BOOLEAN,
-    task_id          VARCHAR(255),
-    thread_id        BIGINT(20),
-    time_cost        FLOAT,
-    time_end         FLOAT,
-    time_start       FLOAT,
-    total_thread     INT,
-    utime            VARCHAR(255),
-    `exception`       MEDIUMTEXT ,
-    rpc_result_expire_seconds BIGINT(20),
-    primary key (_id),
-    key idx_insert_time(insert_time),
-    key idx_queue_name_insert_time(queue_name,insert_time),
-    key idx_params_str(params_str)
-)
-
 
 
-"""
-
 
 def _gen_insert_sql_and_values_by_dict(dictx: dict):
     key_list = [f'`{k}`' for k in dictx.keys()]

funboost/contrib/save_function_result_status/save_result_status_use_dataset.py

@@ -0,0 +1,47 @@
+
+"""
+一个贡献,保存函数结果状态到 mysql postgre 等等,因为默认是使用mongo保存.
+
+可以在 @boost里面指定 user_custom_record_process_info_func= save_result_status_to_sqlalchemy
+"""
+
+import os
+import copy
+import functools
+import json
+import threading
+
+import dataset
+
+from funboost import boost, FunctionResultStatus, funboost_config_deafult,AbstractConsumer
+
+
+
+pid__db_map = {}
+_lock = threading.Lock()
+def get_db(connect_url) -> dataset.Database:
+    """封装一个函数，判断pid"""
+    pid = os.getpid()
+    key = (pid, connect_url,)
+    if key not in pid__db_map:
+        with _lock:
+            if key not in pid__db_map:
+                pid__db_map[key] =  dataset.connect(connect_url)
+    return pid__db_map[key]
+
+
+connect_url ='mysql+pymysql://root:123456@127.0.0.1:3306/testdb7' # dataset或 SQLAlchemy 的url连接形式
+
+# 方式一:@boost 装饰器里面使用函数钩子,user_custom_record_process_info_func
+def save_result_status_use_dataset(result_status: FunctionResultStatus):
+    db = get_db(connect_url)
+    table = db['funboost_consume_results']
+    table.upsert(result_status.get_status_dict(), ['_id'])
+
+# 方式二:装饰器里面使用 consumer_override_cls,重写 user_custom_record_process_info_func
+class ResultStatusUseDatasetMixin(AbstractConsumer):
+    def user_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus):
+        # print(current_function_result_status.get_status_dict())
+        db = get_db(connect_url)
+        table = db['funboost_consume_results']
+        table.upsert(current_function_result_status.get_status_dict(), ['_id'])

funboost/core/booster.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import copy
 import inspect
+from multiprocessing import Process
 import os
 import sys
 import types
@@ -96,7 +97,13 @@ class Booster:
             return types.MethodType(self, instance)
 
     def __call__(self, *args, **kwargs) -> Booster:
-        if len(kwargs) == 0 and len(args) == 1 and isinstance(args[0], typing.Callable):
+        """
+        # 第一次调用__call__，是装饰函数,返回了Booster对象,从此之后,被消费函数就变成了Booster类型对象.
+        # Booster类型对象,怎么支持函数原来本身的直接运行功能? 那就是要让他走到 else 分支,直接用 self.consuming_function 函数本身去运行入参
+        # 这里非常巧妙
+        # 如果用户之后不打算使用funboost 的分布式函数调度功能,那么直接运行函数和原来一模一样,用户不需要删除 @boost装饰器 也能直接运行函数本身
+        """
+        if len(kwargs) == 0 and len(args) == 1 and isinstance(args[0], typing.Callable) and not isinstance(args[0], Booster):
             consuming_function = args[0]
             self.boost_params.consuming_function = consuming_function
             self.boost_params.consuming_function_raw = consuming_function
@@ -242,10 +249,10 @@ class BoostersManager:
     """
 
     # pid_queue_name__booster_map字典存放 {(进程id,queue_name):Booster对象}
-    pid_queue_name__booster_map = {}  # type: typing.Dict[typing.Tuple[int,str],Booster]
+    pid_queue_name__booster_map :typing.Dict[typing.Tuple[int,str],Booster]= {}  
 
     # queue_name__boost_params_consuming_function_map 字典存放  {queue_name,(@boost的入参字典,@boost装饰的消费函数)}
-    queue_name__boost_params_map = {}  # type: typing.Dict[str,BoosterParams]
+    queue_name__boost_params_map :typing.Dict[str,BoosterParams]= {}  
 
     pid_queue_name__has_start_consume_set = set()
 
@@ -392,6 +399,34 @@ class BoostersManager:
 
     m_consume = multi_process_consume_queues
 
+    @classmethod
+    def consume_group(cls, booster_group:str,block=False):
+        """
+        根据@boost装饰器的 booster_group消费分组名字,启动多个消费函数;
+        """
+        if booster_group is None:
+            raise ValueError('booster_group 不能为None')
+        need_consume_queue_names = []
+        for queue_name in cls.get_all_queues():
+            booster= cls.get_or_create_booster_by_queue_name(queue_name)
+            if booster.boost_params.booster_group == booster_group:
+                need_consume_queue_names.append(queue_name)
+        flogger.info(f'according to booster_group:{booster_group} ,start consume queues: {need_consume_queue_names}')
+        for queue_name in need_consume_queue_names:
+            cls.get_or_create_booster_by_queue_name(queue_name).consume()
+        if block:
+            ctrl_c_recv()
+
+    @classmethod
+    def multi_process_consume_group(cls, booster_group:str, process_num=1):
+        """
+        根据@boost装饰器的 booster_group消费分组名字,启动多个消费函数;
+        """
+        for _ in range(process_num):
+            Process(target=cls.consume_group,args=(booster_group,True)).start()
+    
+    m_consume_group = multi_process_consume_group
+            
     @classmethod
     def multi_process_consume_all_queues(cls, process_num=1):
         """

funboost/core/broker_kind__exclusive_config_default_define.py

@@ -0,0 +1,229 @@
+# from __future__ import annotations
+# import typing
+# if typing.TYPE_CHECKING:
+#     from logging import Logger
+
+from logging import Logger
+from funboost.constant import BrokerEnum
+
+
+broker_kind__exclusive_config_default_map: dict = {}
+
+
+def register_broker_exclusive_config_default(
+    broker_kind: str, broker_exclusive_config_default: dict
+):
+    broker_kind__exclusive_config_default_map[broker_kind] = broker_exclusive_config_default
+
+
+
+def generate_broker_exclusive_config(
+    broker_kind: str,
+    user_broker_exclusive_config: dict,
+    logger: Logger,
+):
+    broker_exclusive_config_default = broker_kind__exclusive_config_default_map.get(
+        broker_kind, {}
+    )
+    broker_exclusive_config_keys = broker_exclusive_config_default.keys()
+    if user_broker_exclusive_config:
+        if set(user_broker_exclusive_config).issubset(broker_exclusive_config_keys):
+            logger.info(
+                f"当前消息队列中间件能支持特殊独有配置 {broker_exclusive_config_default.keys()}"
+            )
+        else:
+            logger.warning(f"""当前消息队列中间件含有不支持的特殊配置 {user_broker_exclusive_config.keys()} ,
+            能支持的特殊独有配置包括 {broker_exclusive_config_keys}""")
+    broker_exclusive_config_merge = dict()
+    broker_exclusive_config_merge.update(broker_exclusive_config_default)
+    broker_exclusive_config_merge.update(user_broker_exclusive_config)
+    return broker_exclusive_config_merge
+
+
+# celery的可以配置项大全  https://docs.celeryq.dev/en/stable/userguide/configuration.html#new-lowercase-settings
+# celery @app.task() 所有可以配置项可以看  D:\ProgramData\Miniconda3\Lib\site-packages\celery\app\task.py
+register_broker_exclusive_config_default(BrokerEnum.CELERY, {"celery_task_config": {}})
+
+
+# dramatiq_actor_options 的值可以是：
+# {'max_age', 'throws', 'pipe_target', 'pipe_ignore', 'on_success', 'retry_when', 'time_limit', 'min_backoff', 'max_retries', 'max_backoff', 'notify_shutdown', 'on_failure'}
+register_broker_exclusive_config_default(
+    BrokerEnum.DRAMATIQ, {"dramatiq_actor_options": {}}
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.GRPC,
+    {
+        "host": "127.0.0.1",
+        "port": None,
+    },
+)
+
+register_broker_exclusive_config_default(
+    BrokerEnum.HTTP,
+    {
+        "host": "127.0.0.1",
+        "port": None,
+    },
+)
+
+
+"""
+retries=0, retry_delay=0, priority=None, context=False,
+name=None, expires=None, **kwargs
+"""
+register_broker_exclusive_config_default(BrokerEnum.HUEY, {"huey_task_kwargs": {}})
+
+
+"""
+auto_offset_reset 介绍
+
+auto_offset_reset (str): A policy for resetting offsets on
+OffsetOutOfRange errors: 'earliest' will move to the oldest
+available message, 'latest' will move to the most recent. Any
+other value will raise the exception. Default: 'latest'.
+"""
+register_broker_exclusive_config_default(
+    BrokerEnum.KAFKA,
+    {
+        "group_id": "funboost_kafka",
+        "auto_offset_reset": "earliest",
+        "num_partitions": 10,
+        "replication_factor": 1,
+    },
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.KAFKA_CONFLUENT,
+    {
+        "group_id": "funboost_kafka",
+        "auto_offset_reset": "earliest",
+        "num_partitions": 10,
+        "replication_factor": 1,
+    },
+)
+
+
+""" 
+# prefetch_count 是预获取消息数量
+transport_options是kombu的transport_options 。 
+例如使用kombu使用redis作为中间件时候，可以设置 visibility_timeout 来决定消息取出多久没有ack，就自动重回队列。
+kombu的每个中间件能设置什么 transport_options 可以看 kombu的源码中的 transport_options 参数说明。
+"""
+register_broker_exclusive_config_default(
+    BrokerEnum.KOMBU,
+    {
+        "kombu_url": None,  # 如果这里也配置了kombu_url,则优先使用跟着你的kombu_url，否则使用funboost_config. KOMBU_URL
+        "transport_options": {},  # transport_options是kombu的transport_options 。
+        "prefetch_count": 500,
+    },
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.MYSQL_CDC, {"BinLogStreamReaderConfig": {}}
+)  # 入参是 BinLogStreamReader 的入参BinLogStreamReader
+
+
+"""
+consumer_type Members:
+Exclusive  Shared Failover KeyShared
+"""
+register_broker_exclusive_config_default(
+    BrokerEnum.PULSAR,
+    {
+        "subscription_name": "funboost_group",
+        "replicate_subscription_state_enabled": True,
+        "consumer_type": "Shared",
+    },
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.RABBITMQ_AMQPSTORM,
+    {
+        "queue_durable": True,
+        "x-max-priority": None,  # x-max-priority 是 rabbitmq的优先级队列配置，必须为整数，强烈建议要小于5。为None就代表队列不支持优先级。
+        "no_ack": False,
+    },
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.RABBITMQ_COMPLEX_ROUTING,
+    {
+        "queue_durable": True,
+        "x-max-priority": None,  # x-max-priority 是 rabbitmq的优先级队列配置，必须为整数，强烈建议要小于5。为None就代表队列不支持优先级。
+        "no_ack": False,
+        "exchange_name": "",
+        "exchange_type": "direct",
+        "routing_key_for_bind": None,  # 绑定交换机和队列时使用的key。None表示使用queue_name作为绑定键；""(空字符串)也表示使用queue_name。对于fanout和headers交换机，此值会被忽略。对于topic交换机，可以使用通配符*和#。
+        "routing_key_for_publish": None,
+        # for headers exchange
+        "headers_for_bind": {},
+        "x_match_for_bind": "all",  # all or any
+        "exchange_declare_durable": True,
+    },
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.REDIS,
+    {
+        "redis_bulk_push": 1,
+        "pull_msg_batch_size": 100,
+    },
+)  # redis_bulk_push 是否redis批量推送
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.REDIS_ACK_ABLE, {"pull_msg_batch_size": 100}
+)
+
+# RedisConsumerAckUsingTimeout的ack timeot 是代表消息取出后过了多少秒还未ack，就自动重回队列。这个配置一定要大于函数消耗时间，否则不停的重回队列。
+"""
+用法，如何设置ack_timeout，是使用 broker_exclusive_config 中传递，就能覆盖这里的3600，用户不用改BROKER_EXCLUSIVE_CONFIG_DEFAULT的源码。
+@boost(BoosterParams(queue_name='test_redis_ack__use_timeout', broker_kind=BrokerEnum.REIDS_ACK_USING_TIMEOUT,
+                        concurrent_num=5, log_level=20, broker_exclusive_config={'ack_timeout': 30}))
+"""
+register_broker_exclusive_config_default(
+    BrokerEnum.REIDS_ACK_USING_TIMEOUT, {"ack_timeout": 3600}
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.REDIS_PRIORITY, {"x-max-priority": None}
+)  # x-max-priority 是 rabbitmq的优先级队列配置，必须为整数，强烈建议要小于5。为None就代表队列不支持优先级。
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.REDIS_STREAM,
+    {
+        "group": "funboost_group",
+        "pull_msg_batch_size": 100,
+    },
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.TCP,
+    {
+        "host": "127.0.0.1",
+        "port": None,
+        "bufsize": 10240,
+    },
+)
+
+
+register_broker_exclusive_config_default(
+    BrokerEnum.UDP,
+    {
+        "host": "127.0.0.1",
+        "port": None,
+        "bufsize": 10240,
+    },
+)
+
+register_broker_exclusive_config_default(BrokerEnum.ZEROMQ, {"port": None})

funboost/core/funboost_time.py

@@ -4,19 +4,20 @@ import sys
 import datetime
 
 import typing
-
-from nb_time import NbTime
+import threading
+from nb_time import NbTime,NowTimeStrCache
 from funboost.funboost_config_deafult import FunboostCommonConfig
 
+
 class FunboostTime(NbTime):
     default_formatter = NbTime.FORMATTER_DATETIME_NO_ZONE
 
-    def get_time_zone_str(self,time_zone: typing.Union[str, datetime.tzinfo,None] = None):
-        return time_zone or self.default_time_zone or  FunboostCommonConfig.TIMEZONE  or self.get_localzone_name()
+    def get_time_zone_str(self, time_zone: typing.Union[str, datetime.tzinfo, None] = None):
+        return time_zone or self.default_time_zone or FunboostCommonConfig.TIMEZONE or self.get_localzone_name()
 
     @staticmethod
-    def _get_tow_digist(num:int)->str:
-        if len(str(num)) ==1:
+    def _get_tow_digist(num: int) -> str:
+        if len(str(num)) == 1:
             return f'0{num}'
         return str(num)
 
@@ -28,49 +29,13 @@ class FunboostTime(NbTime):
         return t_str
 
 
+def fast_get_now_time_str() -> str:
+    return NowTimeStrCache.fast_get_now_time_str(FunboostCommonConfig.TIMEZONE)
 
 
-# 缓存时区对象，提升性能（避免重复解析）
-_tz_cache = {}
-
-def get_now_time_str_by_tz(tz_name: str=None) -> str:                   
-    """
-    根据时区名（如 '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
-            try:
-                import pytz
-                _tz_cache[tz_name] = pytz.timezone(tz_name)
-            except ImportError:
-                raise RuntimeError(
-                    f"Python < 3.9 requires 'pytz' to handle timezones. "
-                    f"Install it with: pip install pytz"
-                ) from None
-            except pytz.UnknownTimeZoneError:
-                raise pytz.UnknownTimeZoneError(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")
-
 if __name__ == '__main__':
     print(FunboostTime().get_str())
-    tz=pytz.timezone(FunboostCommonConfig.TIMEZONE)
+    tz = pytz.timezone(FunboostCommonConfig.TIMEZONE)
     for i in range(1000000):
         pass
         # FunboostTime()#.get_str_fast()

funboost/core/func_params_model.py

@@ -201,15 +201,26 @@ class BoosterParams(BaseJsonAbleModel):
     schedule_tasks_on_main_thread: bool = False  # 直接在主线程调度任务，意味着不能直接在当前主线程同时开启两个消费者。
 
     is_auto_start_consuming_message: bool = False  # 是否在定义后就自动启动消费，无需用户手动写 .consume() 来启动消息消费。
+    
+    # booster_group :消费分组名字， BoostersManager.consume_group 时候根据 booster_group 启动多个消费函数,减少需要写 f1.consume() f2.consume() ...这种。
+    # 不像BoostersManager.consume_all() 会启动所有不相关消费函数,也不像  f1.consume() f2.consume() 这样需要逐个启动消费函数。
+    # 可以根据业务逻辑创建不同的分组，实现灵活的消费启动策略。
+    # 用法见文档 4.2d.3 章节.   使用 BoostersManager ,通过 consume_group 启动一组消费函数
+    booster_group:typing.Union[str, None] = None
 
     consuming_function: typing.Optional[typing.Callable] = None  # 消费函数,在@boost时候不用指定,因为装饰器知道下面的函数.
     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 # 发布到消息队列的消息内容的日志，是否显示消息的完整体，还是只显示函数入参。
@@ -228,9 +239,20 @@ class BoosterParams(BaseJsonAbleModel):
         COMMON_FUNCTION = 'COMMON_FUNCTION'
     """
 
+    """
+    user_options:
+    用户额外自定义的配置,高级用户或者奇葩需求可以用得到,用户可以自由发挥,存放任何设置.
+    user_options 提供了一个统一的、用户自定义的命名空间，让用户可以为自己的“奇葩需求”或“高级定制”传递配置，而无需等待框架开发者添加官方支持。
+    funboost 是自由框架不是奴役框架,不仅消费函数逻辑自由,目录层级结构自由,自定义奇葩扩展也要追求自由,用户不用改funboost BoosterParams 源码来加装饰器参数
+    
+    使用场景见文档 4b.6 章节.
+    """
+    user_options: dict = {} # 用户自定义的配置,高级用户或者奇葩需求可以用得到,用户可以自由发挥,存放任何设置,例如配合 consumer_override_cls中读取 或 register_custom_broker 使用
+    
+    
     auto_generate_info: dict = {}  # 自动生成的信息,不需要用户主动传参.
-
-
+    
+    
 
     @root_validator(skip_on_failure=True, )
     def check_values(cls, values: dict):
@@ -358,6 +380,8 @@ class PublisherParams(BaseJsonAbleModel):
     publish_msg_log_use_full_msg: bool = False # 发布到消息队列的消息内容的日志，是否显示消息的完整体，还是只显示函数入参。
     consuming_function_kind: typing.Optional[str] = None  # 自动生成的信息,不需要用户主动传参.
     rpc_timeout: int = 1800 # rpc模式下，等待rpc结果返回的超时时间
+    user_options: dict = {}  # 用户自定义的配置,高级用户或者奇葩需求可以用得到,用户可以自由发挥,存放任何设置.
+
 
 if __name__ == '__main__':
     from funboost.concurrent_pool import FlexibleThreadPool

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
+from funboost.core.funboost_time import FunboostTime, fast_get_now_time_str
 
 
 def get_publish_time(paramsx: dict):
@@ -57,13 +57,13 @@ class MsgGenerater:
     def generate_publish_time() -> float:
         return round(time.time(),4)
 
-    # @staticmethod  # 性能不好
-    # def generate_publish_time_format() -> str:
-    #     return FunboostTime().get_str()
-    
+
     @staticmethod
     def generate_publish_time_format() -> str:
-        return get_now_time_str_by_tz()
+        # return FunboostTime().get_str()  # 性能不好
+        # return get_now_time_str_by_tz()  # 2秒100万次
+        return fast_get_now_time_str() # 0.4秒100万次
+
 
     @classmethod
     def generate_pulish_time_and_task_id(cls,queue_name:str,task_id=None):
@@ -81,8 +81,9 @@ if __name__ == '__main__':
     print(FunboostTime())
     for i in range(1000000):
         # time.time()
-        # MsgGenerater.generate_publish_time_format()
+        MsgGenerater.generate_publish_time_format()
+        # FunboostTime().get_str()
 
-        datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE)).strftime(FunboostTime.FORMATTER_DATETIME_NO_ZONE)
+        # datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE)).strftime(FunboostTime.FORMATTER_DATETIME_NO_ZONE)
 
     print(FunboostTime())

funboost/core/msg_result_getter.py

@@ -1,4 +1,5 @@
 import asyncio
+import threading
 import time
 
 import typing
@@ -278,6 +279,32 @@ class ResultFromMongo(MongoMixin):
         return (self.mongo_row or {}).get('result', NO_RESULT)
 
 
+class FutureStatusResult:
+    """
+    用于sync_call模式的结果等待和通知
+    使用threading.Event实现同步等待
+    """
+    def __init__(self, call_type: str):
+        self.execute_finish_event = threading.Event()
+        self.staus_result_obj: FunctionResultStatus = None
+        self.call_type = call_type  # sync_call or publish
+
+    def set_finish(self):
+        """标记任务完成"""
+        self.execute_finish_event.set()
+
+    def wait_finish(self, rpc_timeout):
+        """等待任务完成，带超时"""
+        return self.execute_finish_event.wait(rpc_timeout)
+
+    def set_staus_result_obj(self, staus_result_obj: FunctionResultStatus):
+        """设置任务执行结果"""
+        self.staus_result_obj = staus_result_obj
+
+    def get_staus_result_obj(self):
+        """获取任务执行结果"""
+        return self.staus_result_obj
+
 if __name__ == '__main__':
     print(ResultFromMongo('test_queue77h6_result:764a1ba2-14eb-49e2-9209-ac83fc5db1e8').get_status_and_result())
     print(ResultFromMongo('test_queue77h6_result:5cdb4386-44cc-452f-97f4-9e5d2882a7c1').get_result())

funboost/factories/broker_kind__publsiher_consumer_type_map.py

@@ -1,7 +1,7 @@
 import typing
 
 from funboost.publishers.empty_publisher import EmptyPublisher
-from funboost.publishers.http_publisher import HTTPPublisher
+
 from funboost.publishers.nats_publisher import NatsPublisher
 from funboost.publishers.peewee_publisher import PeeweePublisher
 from funboost.publishers.redis_publisher_lpush import RedisPublisherLpush
@@ -28,7 +28,7 @@ from funboost.publishers.httpsqs_publisher import HttpsqsPublisher
 from funboost.consumers.empty_consumer import EmptyConsumer
 from funboost.consumers.redis_consumer_priority import RedisPriorityConsumer
 from funboost.consumers.redis_pubsub_consumer import RedisPbSubConsumer
-from funboost.consumers.http_consumer import HTTPConsumer
+
 from funboost.consumers.kafka_consumer import KafkaConsumer
 from funboost.consumers.local_python_queue_consumer import LocalPythonQueueConsumer
 from funboost.consumers.mongomq_consumer import MongoMqConsumer
@@ -74,7 +74,7 @@ broker_kind__publsiher_consumer_type_map = {
     BrokerEnum.HTTPSQS: (HttpsqsPublisher, HttpsqsConsumer),
     BrokerEnum.UDP: (UDPPublisher, UDPConsumer),
     BrokerEnum.TCP: (TCPPublisher, TCPConsumer),
-    BrokerEnum.HTTP: (HTTPPublisher, HTTPConsumer),
+
     BrokerEnum.NATS: (NatsPublisher, NatsConsumer),
     BrokerEnum.TXT_FILE: (TxtFilePublisher, TxtFileConsumer),
     BrokerEnum.PEEWEE: (PeeweePublisher, PeeweeConsumer),
@@ -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
@@ -184,6 +189,11 @@ def regist_to_funboost(broker_kind: str):
         from funboost.consumers.mysql_cdc_consumer import MysqlCdcConsumer
         from funboost.publishers.mysql_cdc_publisher import MysqlCdcPublisher
         register_custom_broker(broker_kind, MysqlCdcPublisher, MysqlCdcConsumer)
+    
+    if broker_kind == BrokerEnum.HTTP:
+        from funboost.consumers.http_consumer import HTTPConsumer
+        from funboost.publishers.http_publisher import HTTPPublisher
+        register_custom_broker(broker_kind, HTTPPublisher, HTTPConsumer)
 
 if __name__ == '__main__':
     import sys