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

funboost/consumers/http_consumer.py

@@ -1,21 +1,25 @@
 # -*- coding: utf-8 -*-
 # @Author  : ydf
 # @Time    : 2022/8/8 0008 13:32
-import asyncio
-import json
+import logging
+import threading
 
-# from aiohttp import web
-# from aiohttp.web_request import Request
+
+from flask import Flask, request
 
 from funboost.consumers.base_consumer import AbstractConsumer
-from funboost.core.lazy_impoter import AioHttpImporter
+from funboost.core.function_result_status_saver import FunctionResultStatus
+from funboost.core.msg_result_getter import FutureStatusResult
+from funboost.core.serialization import Serialization
+
+
 
 
 class HTTPConsumer(AbstractConsumer, ):
     """
-    http 实现消息队列，不支持持久化，但不需要安装软件。
+    flask 作为消息队列实现 consumer
     """
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None}
+
 
     # noinspection PyAttributeOutsideInit
     def custom_init(self):
@@ -30,42 +34,105 @@ class HTTPConsumer(AbstractConsumer, ):
         if self._port is None:
             raise ValueError('please specify port')
 
-    # noinspection DuplicatedCode
     def _shedual_task(self):
-        # flask_app = Flask(__name__)
-        #
-        # @flask_app.route('/queue', methods=['post'])
-        # def recv_msg():
-        #     msg = request.form['msg']
-        #     kw = {'body': json.loads(msg)}
-        #     self._submit_task(kw)
-        #     return 'finish'
-        #
-        # flask_app.run('0.0.0.0', port=self._port,debug=False)
-
-        routes = AioHttpImporter().web.RouteTableDef()
-
-        # noinspection PyUnusedLocal
-        @routes.get('/')
-        async def hello(request):
-            return AioHttpImporter().web.Response(text="Hello, from funboost")
-
-        @routes.post('/queue')
-        async def recv_msg(request: AioHttpImporter().Request):
-            data = await request.post()
-            msg = data['msg']
-            kw = {'body': msg}
-            self._submit_task(kw)
-            return AioHttpImporter().web.Response(text="finish")
-
-        app = AioHttpImporter().web.Application()
-        app.add_routes(routes)
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        AioHttpImporter().web.run_app(app, host='0.0.0.0', port=self._port, )
+        """
+        使用Flask实现HTTP服务器
+        相比aiohttp，Flask是同步框架，避免了异步阻塞问题
+        """
+     
+
+        # 创建Flask应用
+        flask_app = Flask(__name__)
+        # 关闭Flask的日志，避免干扰funboost的日志
+        flask_app.logger.disabled = True
+        logging.getLogger('werkzeug').disabled = True
+        
+        @flask_app.route('/', methods=['GET'])
+        def hello():
+            """健康检查接口"""
+            return "Hello, from funboost (Flask version)"
+        
+        @flask_app.route('/queue', methods=['POST'])
+        def recv_msg():
+            """
+            接收消息的核心接口
+            支持两种调用类型：
+            1. publish: 异步发布，立即返回
+            2. sync_call: 同步调用，等待结果返回
+            """
+            try:
+                # 获取请求数据
+                msg = request.form.get('msg')
+                call_type = request.form.get('call_type', 'publish')
+                
+                if not msg:
+                    return {"error": "msg parameter is required"}, 400
+                
+                # 构造消息数据
+                kw = {
+                    'body': msg,
+                    'call_type': call_type,
+                }
+                
+                if call_type == 'sync_call':
+                    # 同步调用：需要等待执行结果
+                    future_status_result = FutureStatusResult(call_type=call_type)
+                    kw['future_status_result'] = future_status_result
+                    
+                    # 提交任务到线程池执行
+                    self._submit_task(kw)
+                    
+                    # 等待任务完成（带超时）
+                    if future_status_result.wait_finish(self.consumer_params.rpc_timeout):
+                        # 返回执行结果
+                        result = future_status_result.get_staus_result_obj()
+                        return Serialization.to_json_str(
+                            result.get_status_dict(without_datetime_obj=True)
+                        )
+                    else:
+                        # 超时处理
+                        self.logger.error(f'sync_call wait timeout after {self.consumer_params.rpc_timeout}s')
+                        return {"error": "execution timeout"}, 408
+                        
+                else:
+                    # 异步发布：直接提交任务，立即返回
+                    self._submit_task(kw)
+                    return "finish"
+                    
+            except Exception as e:
+                self.logger.error(f'处理HTTP请求时出错: {e}', exc_info=True)
+                return {"error": str(e)}, 500
+        
+        # 启动Flask服务器
+        # 注意：Flask默认是单线程的，但funboost使用线程池处理任务，所以这里threaded=True
+        self.logger.info(f'启动Flask HTTP服务器，监听 {self._ip}:{self._port}')
+
+        # flask_app.run(
+        #     host='0.0.0.0',  # 监听所有接口
+        #     port=self._port,
+        #     debug=False,     # 生产环境关闭debug
+        #     threaded=True,   # 开启多线程支持
+        #     use_reloader=False,  # 关闭自动重载
+        # )
+
+        import waitress
+        waitress.serve(flask_app, host='0.0.0.0', port=self._port,threads=self.consumer_params.concurrent_num)
+
+    def _frame_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus, kw: dict):
+        """
+        任务执行完成后的回调函数
+        对于sync_call模式，需要通知等待的HTTP请求
+        """
+        if kw['call_type'] == "sync_call":
+            future_status_result: FutureStatusResult = kw['future_status_result']
+            future_status_result.set_staus_result_obj(current_function_result_status)
+            future_status_result.set_finish()
+            # self.logger.info('sync_call任务执行完成，通知HTTP请求返回结果')
 
     def _confirm_consume(self, kw):
-        pass  # 没有确认消费的功能。
+        """HTTP模式没有确认消费的功能"""
+        pass
 
     def _requeue(self, kw):
+        """HTTP模式没有重新入队的功能"""
         pass

funboost/consumers/http_consumer_aiohttp_old.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2022/8/8 0008 13:32
+import asyncio
+import json
+
+# from aiohttp import web
+# from aiohttp.web_request import Request
+
+from funboost.consumers.base_consumer import AbstractConsumer
+from funboost.core.function_result_status_saver import FunctionResultStatus
+from funboost.core.lazy_impoter import AioHttpImporter
+from funboost.core.serialization import Serialization
+
+
+class AioFutureStatusResult:
+    def __init__(self,call_type:str):
+        self.execute_finish_event = asyncio.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()
+
+    async def wait_finish(self,rpc_timeout):
+        return await self.execute_finish_event.wait()
+
+    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
+
+class HTTPConsumer(AbstractConsumer, ):
+    """
+    aiohttp 实现消息队列，不支持持久化，但不需要安装软件。
+    """
+
+
+    # noinspection PyAttributeOutsideInit
+    def custom_init(self):
+        # try:
+        #     self._ip, self._port = self.queue_name.split(':')
+        #     self._port = int(self._port)
+        # except BaseException as e:
+        #     self.logger.critical(f'http作为消息队列时候,队列名字必须设置为 例如 192.168.1.101:8200  这种,  ip:port')
+        #     raise e
+        self._ip = self.consumer_params.broker_exclusive_config['host']
+        self._port = self.consumer_params.broker_exclusive_config['port']
+        if self._port is None:
+            raise ValueError('please specify port')
+
+    # noinspection DuplicatedCode
+    def _shedual_task(self):
+        # flask_app = Flask(__name__)
+        #
+        # @flask_app.route('/queue', methods=['post'])
+        # def recv_msg():
+        #     msg = request.form['msg']
+        #     kw = {'body': json.loads(msg)}
+        #     self._submit_task(kw)
+        #     return 'finish'
+        #
+        # flask_app.run('0.0.0.0', port=self._port,debug=False)
+
+        routes = AioHttpImporter().web.RouteTableDef()
+
+        # noinspection PyUnusedLocal
+        @routes.get('/')
+        async def hello(request):
+            return AioHttpImporter().web.Response(text="Hello, from funboost")
+
+        @routes.post('/queue')
+        async def recv_msg(request: AioHttpImporter().Request):
+            data = await request.post()
+            msg = data['msg']
+            call_type = data['call_type']
+            kw = {'body': msg,'call_type': call_type,}
+            if call_type == 'sync_call':
+                aio_future_status_result = AioFutureStatusResult(call_type=call_type)
+                kw['aio_future_status_result'] = aio_future_status_result
+            self._submit_task(kw)
+            if data['call_type'] == 'sync_call':
+                await aio_future_status_result.wait_finish(self.consumer_params.rpc_timeout)
+                return AioHttpImporter().web.Response(text=Serialization.to_json_str(
+                    aio_future_status_result.get_staus_result_obj().get_status_dict(without_datetime_obj=True)))
+            return AioHttpImporter().web.Response(text="finish")
+
+        app = AioHttpImporter().web.Application()
+        app.add_routes(routes)
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        AioHttpImporter().web.run_app(app, host='0.0.0.0', port=self._port, )
+
+    def _frame_custom_record_process_info_func(self,current_function_result_status: FunctionResultStatus,kw:dict):
+        if  kw['call_type'] == "sync_call":
+            aio_future_status_result: AioFutureStatusResult = kw['aio_future_status_result']
+            aio_future_status_result.set_staus_result_obj(current_function_result_status)
+            aio_future_status_result.set_finish()
+            self.logger.info(f'aio_future_status_result.set_finish()')
+
+    # async def _aio_frame_custom_record_process_info_func(self,current_function_result_status: FunctionResultStatus,kw:dict):
+    #     self.logger.info(666666)
+    #     if kw['call_type'] == "sync_call":
+    #         aio_future_status_result: AioFutureStatusResult = kw['aio_future_status_result']
+    #         aio_future_status_result.set_staus_result_obj(current_function_result_status)
+    #         aio_future_status_result.set_finish()
+    #         self.logger.info(f'aio_future_status_result.set_finish()')
+    def _confirm_consume(self, kw):
+        pass  # 没有确认消费的功能。
+
+    def _requeue(self, kw):
+        pass

funboost/consumers/huey_consumer.py

@@ -12,11 +12,8 @@ class HueyConsumer(AbstractConsumer):
     huey作为中间件实现的。
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'huey_task_kwargs': {}}
-    """
-    retries=0, retry_delay=0, priority=None, context=False,
-             name=None, expires=None, **kwargs
-    """
+
+
 
     def custom_init(self):
         # 这就是核心，

funboost/consumers/kafka_consumer.py

@@ -22,8 +22,6 @@ class KafkaConsumer(AbstractConsumer):
     可以让消费函数内部 sleep60秒，突然停止消费代码，使用 kafka-consumer-groups.sh --bootstrap-server 127.0.0.1:9092 --describe --group funboost 来证实自动确认消费和手动确认消费的区别。
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'group_id': 'funboost_kafka', 'auto_offset_reset': 'earliest','num_partitions':10,'replication_factor':1,}
-    # not_all_brokers_general_settings配置 ，支持独立的中间件配置参数是 group_id 和 auto_offset_reset
     """
     auto_offset_reset 介绍
       auto_offset_reset (str): A policy for resetting offsets on
@@ -60,10 +58,7 @@ class KafkaConsumer(AbstractConsumer):
         # REMIND 好处是并发高。topic像翻书一样，随时可以设置偏移量重新消费。多个分组消费同一个主题，每个分组对相同主题的偏移量互不干扰 。
         for message in consumer:
             # 注意: message ,value都是原始的字节数据，需要decode
-            if self.consumer_params.is_show_message_get_from_broker:
-                self.logger.debug(
-                    f'从kafka的 [{message.topic}] 主题,分区 {message.partition} 中 取出的消息是：  {message.value.decode()}')
-            kw = {'consumer': consumer, 'message': message, 'body': message.value}
+            kw = {'consumer': consumer, 'message': message, 'body': message.value.decode('utf-8')}
             self._submit_task(kw)
 
     def _confirm_consume(self, kw):

funboost/consumers/kafka_consumer_manually_commit.py

@@ -31,7 +31,6 @@ class KafkaConsumerManuallyCommit(AbstractConsumer):
     可以让消费函数内部 sleep 60秒，突然停止消费代码，使用 kafka-consumer-groups.sh --bootstrap-server 127.0.0.1:9092 --describe --group frame_group 来证实自动确认消费和手动确认消费的区别。
     """
 
-    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'group_id': 'funboost_kafka', 'auto_offset_reset': 'earliest','num_partitions':10,'replication_factor':1,}
 
     def custom_init(self):
         self._lock_for_operate_offset_dict = threading.Lock()

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']