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

funboost/consumers/kombu_consumer.py

@@ -81,45 +81,6 @@ class KombuConsumer(AbstractConsumer, ):
     使用kombu作为中间件,这个能直接一次性支持很多种小众中间件，但性能很差，除非是分布式函数调度框架没实现的中间件种类用户才可以用这种，用户也可以自己对比性能。
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'kombu_url': None,  # 如果这里也配置了kombu_url,则优先使用跟着你的kombu_url，否则使用funboost_config. KOMBU_URL
-                                       'transport_options': {},  # transport_options是kombu的transport_options 。
-                                       'prefetch_count': 500
-                                       }
-    # prefetch_count 是预获取消息数量
-    ''' transport_options是kombu的transport_options 。 
-       例如使用kombu使用redis作为中间件时候，可以设置 visibility_timeout 来决定消息取出多久没有ack，就自动重回队列。
-       kombu的每个中间件能设置什么 transport_options 可以看 kombu的源码中的 transport_options 参数说明。
-
-例如kombu redis的Transport Options 说明
-D:\ProgramData\Miniconda3\envs\py311\Lib\site-packages\kombu\transport\redis.py
-
-Transport Options
-=================
-* ``sep``
-* ``ack_emulation``: (bool) If set to True transport will
-  simulate Acknowledge of AMQP protocol.
-* ``unacked_key``
-* ``unacked_index_key``
-* ``unacked_mutex_key``
-* ``unacked_mutex_expire``
-* ``visibility_timeout``
-* ``unacked_restore_limit``
-* ``fanout_prefix``
-* ``fanout_patterns``
-* ``global_keyprefix``: (str) The global key prefix to be prepended to all keys
-  used by Kombu
-* ``socket_timeout``
-* ``socket_connect_timeout``
-* ``socket_keepalive``
-* ``socket_keepalive_options``
-* ``queue_order_strategy``
-* ``max_connections``
-* ``health_check_interval``
-* ``retry_on_timeout``
-* ``priority_steps``
-
-
-      '''
 
     def custom_init(self):
         self.kombu_url = self.consumer_params.broker_exclusive_config['kombu_url'] or BrokerConnConfig.KOMBU_URL

funboost/consumers/mysql_cdc_consumer.py

@@ -21,9 +21,7 @@ class MysqlCdcConsumer(AbstractConsumer):
     This broker is consumer-driven; it automatically generates tasks from database changes.
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {
-        'BinLogStreamReaderConfig': {},
-    }
+
 
     def custom_init(self):
         """Validates the essential configuration."""

funboost/consumers/pulsar_consumer.py

@@ -32,10 +32,7 @@ class PulsarConsumer(AbstractConsumer, ):
     pulsar作为中间件实现的。
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'subscription_name': 'funboost_group',
-                                       'replicate_subscription_state_enabled': True,
-                                       'consumer_type': ConsumerType.Shared,
-                                       }
+
 
     def custom_init(self):
         pass
@@ -46,9 +43,17 @@ class PulsarConsumer(AbstractConsumer, ):
         except ImportError:
             raise ImportError('需要用户自己 pip install pulsar-client ，')
         self._client = pulsar.Client(BrokerConnConfig.PULSAR_URL, )
+
+        consumer_type_map = {
+            'Exclusive':ConsumerType.Exclusive,
+            'Shared':ConsumerType.Shared,
+            'Failover':ConsumerType.Failover,
+            'KeyShared':ConsumerType.KeyShared,
+        }
+        consumer_type_obj = consumer_type_map[self.consumer_params.broker_exclusive_config['consumer_type']]
         self._consumer = self._client.subscribe(self._queue_name, schema=schema.StringSchema(), consumer_name=f'funboost_consumer_{os.getpid()}',
                                                 subscription_name=self.consumer_params.broker_exclusive_config['subscription_name'],
-                                                consumer_type=self.consumer_params.broker_exclusive_config['consumer_type'],
+                                                consumer_type=consumer_type_obj,
                                                 replicate_subscription_state_enabled=self.consumer_params.broker_exclusive_config['replicate_subscription_state_enabled'])
         while True:
             msg = self._consumer.receive()

funboost/consumers/rabbitmq_amqpstorm_consumer.py

@@ -3,10 +3,8 @@
 # @Time    : 2022/8/8 0008 13:30
 
 import amqpstorm
-from funboost.constant import BrokerEnum
 from funboost.consumers.base_consumer import AbstractConsumer
-from funboost.publishers.rabbitmq_amqpstorm_publisher import RabbitmqPublisherUsingAmqpStorm
-from funboost.core.func_params_model import PublisherParams
+
 
 
 class RabbitmqConsumerAmqpStorm(AbstractConsumer):
@@ -14,7 +12,8 @@ class RabbitmqConsumerAmqpStorm(AbstractConsumer):
     使用AmqpStorm实现的，多线程安全的，不用加锁。
     funboost 强烈推荐使用这个做消息队列中间件。
     """
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'x-max-priority': None,'no_ack':False}  # x-max-priority 是 rabbitmq的优先级队列配置，必须为整数，强烈建议要小于5。为None就代表队列不支持优先级。
+
+    # _rabbitmq_pb_cls = RabbitmqPublisherUsingAmqpStorm
 
     def _shedual_task(self):
         # noinspection PyTypeChecker
@@ -24,13 +23,14 @@ class RabbitmqConsumerAmqpStorm(AbstractConsumer):
             kw = {'amqpstorm_message': amqpstorm_message, 'body': body}
             self._submit_task(kw)
 
-        rp = RabbitmqPublisherUsingAmqpStorm(publisher_params=PublisherParams(queue_name=self.queue_name,
-                                                                              broker_exclusive_config=self.consumer_params.broker_exclusive_config))
+        # rp = self._rabbitmq_pb_cls(publisher_params=PublisherParams(queue_name=self.queue_name,broker_kind=self.consumer_params.broker_kind,
+                                                                    # broker_exclusive_config=self.consumer_params.broker_exclusive_config))
+        rp = self.bulid_a_new_publisher_of_same_queue()
         rp.init_broker()
         rp.channel_wrapper_by_ampqstormbaic.qos(self.consumer_params.concurrent_num)
         rp.channel_wrapper_by_ampqstormbaic.consume(callback=callback, queue=self.queue_name, no_ack=self.consumer_params.broker_exclusive_config['no_ack'],
                                                     )
-        self._rp=rp
+        self._rp = rp
         rp.channel.start_consuming(auto_decode=True)
 
     def _confirm_consume(self, kw):
@@ -48,4 +48,3 @@ class RabbitmqConsumerAmqpStorm(AbstractConsumer):
         # kw['amqpstorm_message'].reject(requeue=True)
         # kw['amqpstorm_message'].ack()
         # self.publisher_of_same_queue.publish(kw['body'])
-

funboost/consumers/rabbitmq_complex_routing_consumer.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2022/8/8 0008 13:30
+import amqpstorm
+from funboost.consumers.rabbitmq_amqpstorm_consumer import RabbitmqConsumerAmqpStorm
+from amqpstorm.queue import Queue as AmqpStormQueue
+
+
+class RabbitmqComplexRoutingConsumer(RabbitmqConsumerAmqpStorm):
+    """
+    
+    """
+    def custom_init(self):
+        super().custom_init()
+        rp = self.bulid_a_new_publisher_of_same_queue()
+        rp.init_broker()  # 发布者那边只声明了交换机
+
+        # 消费者负责声明队列和唯一的绑定逻辑
+        AmqpStormQueue(rp.channel).declare(**rp.queue_declare_params)
+        
+        # 消费者负责唯一的绑定逻辑
+        if rp._exchange_name:
+            self.logger.info(f'消费者开始绑定: 队列 [{self._queue_name}] <--> 交换机 [{rp._exchange_name}] (类型: {rp._exchange_type})')
+            
+            routing_key_bind = self.consumer_params.broker_exclusive_config.get('routing_key_for_bind')
+            arguments_for_bind = None
+
+            if rp._exchange_type == 'fanout':
+                routing_key_bind = ''  # fanout 必须使用空 routing_key
+            elif rp._exchange_type == 'headers':
+                routing_key_bind = ''  # headers 必须使用空 routing_key
+                arguments_for_bind = self.consumer_params.broker_exclusive_config.get('headers_for_bind', {})
+                arguments_for_bind['x-match'] = self.consumer_params.broker_exclusive_config.get('x_match_for_bind', 'all')
+            elif routing_key_bind is None:  # 用户未指定绑定键时，根据交换机类型设置默认值
+                if rp._exchange_type == 'topic':
+                    routing_key_bind = '#'  # topic 默认订阅所有
+                else:  # direct
+                    routing_key_bind = self._queue_name
+
+            AmqpStormQueue(rp.channel).bind(queue=self._queue_name, exchange=rp._exchange_name,
+                                           routing_key=routing_key_bind, arguments=arguments_for_bind)
+        self._rp = rp
+
+    def _shedual_task(self):
+        # 重写父类的方法，以支持更复杂的绑定逻辑
+        def callback(amqpstorm_message: amqpstorm.Message):
+            body = amqpstorm_message.body
+            kw = {'amqpstorm_message': amqpstorm_message, 'body': body}
+            self._submit_task(kw)
+
+        rp = self._rp
+        rp.channel_wrapper_by_ampqstormbaic.qos(self.consumer_params.concurrent_num)
+        rp.channel_wrapper_by_ampqstormbaic.consume(callback=callback, queue=self.queue_name, no_ack=self.consumer_params.broker_exclusive_config['no_ack'])
+        rp.channel.start_consuming(auto_decode=True)

funboost/consumers/redis_consumer.py

@@ -20,7 +20,7 @@ class RedisConsumer(AbstractConsumer, RedisMixin):
     这个是复杂版，一次性拉取100个,减少和redis的交互，简单版在 funboost/consumers/redis_consumer_simple.py
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'redis_bulk_push':1,'pull_msg_batch_size':100}   #redis_bulk_push 是否redis批量推送
+
 
     # noinspection DuplicatedCode
     def _shedual_task(self):

funboost/consumers/redis_consumer_ack_able.py

@@ -99,7 +99,7 @@ class RedisConsumerAckAble(ConsumerConfirmMixinWithTheHelpOfRedisByHearbeat, Abs
     # print(script_4(keys=["text_pipelien1","text_pipelien1b"]))
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = { 'pull_msg_batch_size': 100}
+
 
     def _shedual_task000(self):
         # 可以采用lua脚本，也可以采用redis的watch配合pipeline使用。比代码分两行pop和zadd比还能减少一次io交互，还能防止丢失小概率一个任务。

funboost/consumers/redis_consumer_ack_using_timeout.py

@@ -15,13 +15,9 @@ class RedisConsumerAckUsingTimeout(AbstractConsumer, RedisMixin):
     使用超时未能ack就自动重入消息队列，例如消息取出后，由于突然断电或重启或其他原因，导致消息以后再也不能主动ack了，超过一定时间就重新放入消息队列
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'ack_timeout': 3600}
 
-    # 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}))
-    '''
+
+
 
     def custom_init(self):
         self._unack_zset_name = f'{self._queue_name}__unack_using_timeout'

funboost/consumers/redis_consumer_priority.py

@@ -50,7 +50,7 @@ class RedisPriorityConsumer(RedisConsumerAckAble):
         f.consume()
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'x-max-priority': None}  # x-max-priority 是 rabbitmq的优先级队列配置，必须为整数，强烈建议要小于5。为None就代表队列不支持优先级。
+
 
     def _shedual_task0000(self):
 

funboost/consumers/redis_stream_consumer.py

@@ -13,11 +13,9 @@ class RedisStreamConsumer(AbstractConsumer, RedisMixin):
     """
     redis 的 stream 结构 作为中间件实现的。需要redis 5.0以上，redis stream结构 是redis的消息队列，概念类似kafka，功能远超 list结构。
     """
-    GROUP = 'funboost_group'
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'group': 'funboost_group','pull_msg_batch_size': 100}
 
     def custom_init(self):
-        self.group = self.consumer_params.broker_exclusive_config['group'] or self.GROUP
+        self.group = self.consumer_params.broker_exclusive_config['group']
 
     def start_consuming_message(self):
         redis_server_info_dict = self.redis_db_frame.info()

funboost/consumers/tcp_consumer.py

@@ -13,7 +13,7 @@ class TCPConsumer(AbstractConsumer, ):
     socket 实现消息队列，不支持持久化，但不需要安装软件。
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None, 'bufsize': 10240}
+
 
     # noinspection PyAttributeOutsideInit
     def custom_init(self):

funboost/consumers/udp_consumer.py

@@ -12,7 +12,7 @@ class UDPConsumer(AbstractConsumer, ):
     socket 实现消息队列，不支持持久化，但不需要安装软件。
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None, 'bufsize': 10240}
+
 
     # noinspection PyAttributeOutsideInit
     def custom_init(self):

funboost/consumers/zeromq_consumer.py

@@ -67,7 +67,7 @@ class ZeroMqConsumer(AbstractConsumer):
     zeromq 中间件的消费者，zeromq基于socket代码，不会持久化，且不需要安装软件。
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'port': None}
+
 
     def custom_init(self):
         self._port = self.consumer_params.broker_exclusive_config['port']

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

@@ -97,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

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})