funboost 49.5__py3-none-any.whl → 49.7__py3-none-any.whl

funboost/__init__.py

@@ -13,7 +13,7 @@ set_frame_config这个模块的 use_config_form_funboost_config_module() 是核
 这段注释说明和使用的用户无关,只和框架开发人员有关.
 '''
 
-__version__ = "49.5"
+__version__ = "49.7"
 
 from funboost.set_frame_config import show_frame_config
 

funboost/beggar_version_implementation/beggar_redis_consumer.py

@@ -19,7 +19,9 @@ from concurrent.futures import ThreadPoolExecutor
 from funboost.funboost_config_deafult import BrokerConnConfig
 
 redis_db_frame = redis.Redis(host=BrokerConnConfig.REDIS_HOST, password=BrokerConnConfig.REDIS_PASSWORD,
-                             port=BrokerConnConfig.REDIS_PORT, db=BrokerConnConfig.REDIS_DB, decode_responses=True)
+                             port=BrokerConnConfig.REDIS_PORT, db=BrokerConnConfig.REDIS_DB,
+                             ssl=BrokerConnConfig.REDIS_USE_SSL,
+                             decode_responses=True)
 
 
 class BeggarRedisConsumer:

funboost/constant.py

@@ -3,6 +3,25 @@
 
 
 class BrokerEnum:
+    """
+    在funboost中万物皆可为消息队列broker,funboost内置了所有 知名的正经经典消息队列作为broker,
+    也支持了基于 内存 各种数据库 文件系统 tcp/udp/http这些socket 模拟作为broker.
+    funboost也内置支持了各种python三方包和消费框架作为broker,例如 sqlachemy kombu celery rq dramtiq huey nameko 等等
+
+    用户也可以按照文档4.21章节,轻松扩展任何物质概念作为funboost的broker.
+    """
+    
+    # funboost框架能轻松兼容消息队列各种工作模式, 拉模式/推模式/轮询模式，单条获取 批量获取
+    """
+    funboost 的 consumer的 _shedual_task 非常灵活，用户实现把从消息队列取出的消息通过_submit_task方法
+    丢到并发池，他不是强制用户重写实现怎么取一条消息，例如强制你实现一个 _get_one_message的法，
+    那就不灵活和限制扩展任意东西作为broker了，而是用户完全自己来写灵活代码。
+    所以无论获取消息是 拉模式 还是推模式 还是轮询模式，是单条获取 还是多条批量获取，
+    不管你的新中间件和rabbitmq api用法差别有多么巨大，都能轻松扩展任意东西作为funboost的中间件。 
+    所以你能看到funboost源码中能轻松实现任物质概念作为funboost的broker。
+    """
+
+
     EMPTY = 'EMPTY'  # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
 
     RABBITMQ_AMQPSTORM = 'RABBITMQ_AMQPSTORM'  # 使用 amqpstorm 包操作rabbitmq  作为 分布式消息队列，支持消费确认.强烈推荐这个作为funboost中间件。
@@ -10,12 +29,21 @@ class BrokerEnum:
 
     RABBITMQ_RABBITPY = 'RABBITMQ_RABBITPY'  # 使用 rabbitpy 包操作rabbitmq  作为 分布式消息队列，支持消费确认，不建议使用
 
+    """
+    以下是各种redis数据结构和各种方式来实现作为消息队列的,redis简直被作者玩出花来了.
+    因为redis本身是缓存数据库,不是消息队列,redis没有实现经典AMQP协议,所以redis是模拟消息队列不是真消息队列.
+    例如要实现消费确认,随意重启但消息万无一失,你搞个简单的 redis.blpop 弹出删除消息,那就压根不行.重启就丢失了,但消息可能还没开始运行或者正在运行中.
+    
+    redis做ack挑战难点不是怎么实现确认消费本身,而是何时应该把关闭或宕机进程的消费者的待确认消费的孤儿消息重回队列.  
+    在 Redis 上实现 ACK 的真正难点，根本不在于“确认”这个动作本身，而在于建立一套可靠的、能够准确判断“何时可以安全地及时地进行任务恢复”的分布式故障检测机制。
+    所以你以为只要使用 brpoplpush 或者 REDIS_STREAM 就能自动轻易解决ack问题,那就太天真了,因为redis服务端不能像rabbitmq服务端那样天生自带自动重回宕机消费者的消息机制,需要你在redis客户端来维护实现这套机制.
+    """
     REDIS = 'REDIS'  # 使用 redis 的 list结构，brpop 作为分布式消息队列。随意重启和关闭会丢失大量消息，不支持消费确认。注重性能不在乎丢失消息可以选这个redis方案。
     REDIS_ACK_ABLE = 'REDIS_ACK_ABLE'  # 基于redis的 list + 临时unack的set队列，采用了 lua脚本操持了取任务和加到pengding为原子性，,基于进程心跳消失判断消息是否为掉线进程的，随意重启和掉线不会丢失任务。
-    REIDS_ACK_USING_TIMEOUT = 'reids_ack_using_timeout'  # 基于redis的 list + 临时unack的set队列，使用超时多少秒没确认消费就自动重回队列，请注意 ack_timeout的设置值和函数耗时大小，否则会发生反复重回队列的后果,boost可以设置ack超时，broker_exclusive_config={'ack_timeout': 1800}
+    REIDS_ACK_USING_TIMEOUT = 'reids_ack_using_timeout'  # 基于redis的 list + 临时unack的set队列，使用超时多少秒没确认消费就自动重回队列，请注意 ack_timeout的设置值和函数耗时大小，否则会发生反复重回队列的后果,boost可以设置ack超时，broker_exclusive_config={'ack_timeout': 1800}.缺点是无法区分执行太慢还是真宕机
     REDIS_PRIORITY = 'REDIS_PRIORITY'  # # 基于redis的多 list + 临时unack的set队列，blpop监听多个key，和rabbitmq的x-max-priority属性一样，支持任务优先级。看文档4.29优先级队列说明。
     REDIS_STREAM = 'REDIS_STREAM'  # 基于redis 5.0 版本以后，使用 stream 数据结构作为分布式消息队列，支持消费确认和持久化和分组消费，是redis官方推荐的消息队列形式，比list结构更适合。
-    RedisBrpopLpush = 'RedisBrpopLpush'  # 基于redis的list结构但是采用brpoplpush 双队列形式，和 redis_ack_able的实现差不多，实现上采用了原生命令就不需要lua脚本来实现取出和加入unack了。
+    RedisBrpopLpush = 'RedisBrpopLpush'  # 基于redis的list结构但是采用 brpoplpush 双队列形式，和 redis_ack_able的实现差不多，实现上采用了原生命令就不需要lua脚本来实现取出和加入unack了。
     REDIS_PUBSUB = 'REDIS_PUBSUB'  # 基于redis 发布订阅的，发布一个消息多个消费者都能收到同一条消息，但不支持持久化
 
     MEMORY_QUEUE = 'MEMORY_QUEUE'  # 使用python queue.Queue实现的基于当前python进程的消息队列，不支持跨进程 跨脚本 跨机器共享任务，不支持持久化，适合一次性短期简单任务。
@@ -44,8 +72,15 @@ class BrokerEnum:
 
     ZEROMQ = 'ZEROMQ'  # 基于zeromq作为分布式消息队列，不需要安装中间件，可以支持跨机器但不支持持久化。
 
+
     """
-    操作 kombu 包，这个包也是celery的中间件依赖包，这个包可以操作10种中间件(例如rabbitmq redis)，但没包括分布式函数调度框架的kafka nsq zeromq 等。
+    kombu 和 celery 都是 funboost中的神级别broker_kind。
+    使得funboost以逸待劳，支持kombu的所有现有和未来的消息队列。
+    通过直接支持 kombu，funboost 相当于一瞬间就继承了 `kombu` 支持的所有现有和未来的消息队列能力。无论 kombu 社区未来增加了对哪种新的云消息服务（如 Google
+    Pub/Sub、Azure Service Bus）或小众 MQ 的支持，funboost 无需修改自身代码，就能自动获得这种能力。这
+    是一种“以逸待劳”的策略，极大地扩展了 funboost 的适用范围。
+
+    kombu 包可以作为funboost的broker，这个包也是celery的中间件依赖包，这个包可以操作10种中间件(例如rabbitmq redis)，但没包括分布式函数调度框架的kafka nsq zeromq 等。
     同时 kombu 包的性能非常差，可以用原生redis的lpush和kombu的publish测试发布，使用brpop 和 kombu 的 drain_events测试消费，对比差距相差了5到10倍。
     由于性能差，除非是分布式函数调度框架没实现的中间件才选kombu方式(例如kombu支持亚马逊队列  qpid pyro 队列)，否则强烈建议使用此框架的操作中间件方式而不是使用kombu。
     """
@@ -74,6 +109,7 @@ class BrokerEnum:
 
     CELERY = 'CELERY'  # funboost支持celery框架来发布和消费任务，由celery框架来调度执行任务，但是写法简单远远暴击用户亲自使用celery的麻烦程度，
     # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和includes配置,funboost来自动化设置这些celery配置。
+    # funboost将Celery本身纳入了自己的Broker体系。能“吞下”另一个大型框架，简直太妙了。本身就证明了funboost架构的包容性和精妙性和复杂性。
 
     DRAMATIQ = 'DRAMATIQ'  # funboost使用 dramatiq 框架作为消息队列，dramatiq类似celery也是任务队列框架。用户使用funboost api来操作dramatiq核心调度。
 

funboost/consumers/base_consumer.py

@@ -37,7 +37,7 @@ from funboost.core.current_task import funboost_current_task, FctContext
 from funboost.core.loggers import develop_logger
 
 from funboost.core.func_params_model import BoosterParams, PublisherParams, BaseJsonAbleModel
-from funboost.core.serialization import Serialization
+from funboost.core.serialization import PickleHelper, Serialization
 from funboost.core.task_id_logger import TaskIdLogger
 from funboost.constant import FunctionKind
 
@@ -437,14 +437,21 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     def _shedual_task(self):
         """
         每个子类必须实现这个的方法，完成如何从中间件取出消息，并将函数和运行参数添加到工作池。
+
+        funboost 的 _shedual_task 哲学是：“我不管你怎么从你的系统里拿到任务，我只要求你拿到任务后，
+        调用 self._submit_task(msg) 方法把它交给我处理就行。”
+
+        所以无论获取消息是 拉模式 还是推模式 还是轮询模式，无论是是单条获取 还是多条批量多条获取，
+        都能轻松扩展任意东西作为funboost的中间件。 
+
         :return:
         """
         raise NotImplementedError
 
-    def convert_msg_before_run(self, msg: typing.Union[str, dict]) -> dict:
+    def _convert_msg_before_run(self, msg: typing.Union[str, dict]) -> dict:
         """
         转换消息,消息没有使用funboost来发送,并且没有extra相关字段时候
-        用户也可以按照4.21文档,继承任意Consumer类,并实现这个方法 convert_msg_before_run,先转换不规范的消息.
+        用户也可以按照4.21文档,继承任意Consumer类,并实现方法 _user_convert_msg_before_run,先转换不规范的消息.
         """
         """ 一般消息至少包含这样
         {
@@ -462,6 +469,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         extra_params = {'task_id': task_id, 'publish_time': round(time.time(), 4),
                         'publish_time_format': time.strftime('%Y-%m-%d %H:%M:%S')}
         """
+        msg = self._user_convert_msg_before_run(msg)
         msg = Serialization.to_dict(msg)
         # 以下是清洗补全字段.
         if 'extra' not in msg:
@@ -474,10 +482,17 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         if 'publish_time_format':
             extra['publish_time_format'] = MsgGenerater.generate_publish_time_format()
         return msg
+    
+    def _user_convert_msg_before_run(self, msg: typing.Union[str, dict]) -> dict:
+        """
+        用户也可以提前清洗数据
+        """
+        # print(msg)
+        return msg
 
     def _submit_task(self, kw):
 
-        kw['body'] = self.convert_msg_before_run(kw['body'])
+        kw['body'] = self._convert_msg_before_run(kw['body'])
         self._print_message_get_from_broker(kw['body'])
         if self._judge_is_daylight():
             self._requeue(kw)
@@ -628,8 +643,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     async def aio_user_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus):  # 这个可以继承
         pass
 
-    def _convert_real_function_only_params_by_conusuming_function_kind(self, function_only_params: dict):
+    def _convert_real_function_only_params_by_conusuming_function_kind(self, function_only_params: dict,extra_params:dict):
         """对于实例方法和classmethod 方法， 从消息队列的消息恢复第一个入参， self 和 cls"""
+        can_not_json_serializable_keys = extra_params.get('can_not_json_serializable_keys',[])
         if self.consumer_params.consuming_function_kind in [FunctionKind.CLASS_METHOD, FunctionKind.INSTANCE_METHOD]:
             real_function_only_params = copy.copy(function_only_params)
             method_first_param_name = None
@@ -651,8 +667,14 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                 obj = method_cls(**method_first_param_value[ConstStrForClassMethod.OBJ_INIT_PARAMS])
                 real_function_only_params[method_first_param_name] = obj
             # print(real_function_only_params)
+            if can_not_json_serializable_keys:
+                for key in can_not_json_serializable_keys:
+                    real_function_only_params[key] = PickleHelper.to_obj(real_function_only_params[key])
             return real_function_only_params
         else:
+            if can_not_json_serializable_keys:
+                for key in can_not_json_serializable_keys:
+                    function_only_params[key] = PickleHelper.to_obj(function_only_params[key])
             return function_only_params
 
     # noinspection PyProtectedMember
@@ -751,7 +773,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                     self.logger.warning(f'取消运行 {task_id} {function_only_params}')
                     return function_result_status
                 function_run = kill_remote_task.kill_fun_deco(task_id)(function_run)  # 用杀死装饰器包装起来在另一个线程运行函数,以便等待远程杀死。
-            function_result_status.result = function_run(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params))
+            function_result_status.result = function_run(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params,kw['body']['extra']))
             # if asyncio.iscoroutine(function_result_status.result):
             #     log_msg = f'''异步的协程消费函数必须使用 async 并发模式并发,请设置消费函数 {self.consuming_function.__name__} 的concurrent_mode 为 ConcurrentModeEnum.ASYNC 或 4'''
             #     # self.logger.critical(msg=f'{log_msg} \n')
@@ -806,6 +828,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             self.logger.error(msg=log_msg, exc_info=self._get_priority_conf(kw, 'is_print_detail_exception'))
             # traceback.print_exc()
             function_result_status.exception = f'{e.__class__.__name__}    {str(e)}'
+            function_result_status.exception_msg = str(e)
+            function_result_status.exception_type = e.__class__.__name__
+
             function_result_status.result = FunctionResultStatus.FUNC_RUN_ERROR
         return function_result_status
 
@@ -892,7 +917,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                                  logger=self.logger,queue_name=self.queue_name,)
         fct.set_fct_context(fct_context)
         try:
-            corotinue_obj = self.consuming_function(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params))
+            corotinue_obj = self.consuming_function(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params,kw['body']['extra']))
             if not asyncio.iscoroutine(corotinue_obj):
                 log_msg = f'''当前设置的并发模式为 async 并发模式，但消费函数不是异步协程函数，请不要把消费函数 {self.consuming_function.__name__} 的 concurrent_mode 设置错误'''
                 # self.logger.critical(msg=f'{log_msg} \n')
@@ -939,6 +964,8 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             # self.error_file_logger.error(msg=f'{log_msg} \n', exc_info=self._get_priority_conf(kw, 'is_print_detail_exception'))
             self.logger.error(msg=log_msg, exc_info=self._get_priority_conf(kw, 'is_print_detail_exception'))
             function_result_status.exception = f'{e.__class__.__name__}    {str(e)}'
+            function_result_status.exception_msg = str(e)
+            function_result_status.exception_type = e.__class__.__name__
             function_result_status.result = FunctionResultStatus.FUNC_RUN_ERROR
         return function_result_status
 

funboost/consumers/celery_consumer.py

@@ -197,6 +197,7 @@ class CeleryConsumer(AbstractConsumer):
             time.sleep(100)
 
     def _confirm_consume(self, kw):
+        """完全由celery框架接管控制消费和ack确认消费，不需要funboost自己的代码来执行"""
         pass
 
     def _requeue(self, kw):

funboost/consumers/empty_consumer.py

@@ -8,19 +8,30 @@ from funboost.consumers.base_consumer import AbstractConsumer
 
 class EmptyConsumer(AbstractConsumer, metaclass=abc.ABCMeta):
     """
-    空的消费者没实现，空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
+    一个空的消费者基类，作为自定义 Broker 的模板。
+
+    这个类其实是多余的，因为用户完全可以继承AbstractConsumer，然后实现custom_init方法，然后实现_shedual_task, _confirm_consume, _requeue方法来新增自定义broker。
+    这个类是为了清晰明确的告诉你，仅仅需要下面三个方法，就可以实现一个自定义broker，因为AbstractConsumer基类功能太丰富了，基类方法是在太多了，用户不知道需要继承重写哪方法
+    
+    
     """
     def custom_init(self):
         pass
 
     @abc.abstractmethod
     def _shedual_task(self):
+        """
+        核心调度任务。此方法需要实现一个循环，负责从你的中间件中获取消息，
+        然后调用 `self._submit_task(msg)` 将任务提交到框架的并发池中执行。 可以参考funboos源码中的各种消费者实现。
+        """
         raise NotImplemented('not realization')
 
     @abc.abstractmethod
     def _confirm_consume(self, kw):
+        """确认消费，就是ack概念"""
         raise NotImplemented('not realization')
 
     @abc.abstractmethod
     def _requeue(self, kw):
+        """重新入队"""
         raise NotImplemented('not realization')

funboost/consumers/faststream_consumer.py

@@ -22,7 +22,7 @@ class FastStreamConsumer(EmptyConsumer):
             # print(logger.name)
             # return self.consuming_function(*args, **kwargs) # 如果没有声明 autoretry_for ，那么消费函数出错了就不会自动重试了。
             # print(msg)
-            function_only_params = delete_keys_and_return_new_dict(json.loads(msg))
+            function_only_params = delete_keys_and_return_new_dict(Serialization.to_dict(msg))
             if self._consuming_function_is_asyncio:
                 result = await self.consuming_function(**function_only_params)
             else:

funboost/consumers/http_consumer.py

@@ -10,20 +10,25 @@ import json
 from funboost.consumers.base_consumer import AbstractConsumer
 from funboost.core.lazy_impoter import AioHttpImporter
 
+
 class HTTPConsumer(AbstractConsumer, ):
     """
     http 实现消息队列，不支持持久化，但不需要安装软件。
     """
-
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None}
 
     # 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
+        # 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):

funboost/consumers/kafka_consumer_manually_commit.py

@@ -72,8 +72,6 @@ class KafkaConsumerManuallyCommit(AbstractConsumer):
                     f'从kafka的 [{self._queue_name}] 主题,分区 {msg.partition()} 中 的 offset {msg.offset()} 取出的消息是：  {msg.value()}')  # noqa
             self._submit_task(kw)
 
-            # kw = {'consumer': consumer, 'message': message, 'body': json.loads(message.value)}
-            # self._submit_task(kw)
 
     def _manually_commit(self):
         """

funboost/consumers/kombu_consumer.py

@@ -17,55 +17,6 @@ from kombu.transport.redis import Empty
 from funboost.consumers.base_consumer import AbstractConsumer
 from funboost.funboost_config_deafult import BrokerConnConfig
 
-def patch_kombu_redis000():
-    # 这个也可以，代码长了一点。
-    """
-    给kombu的redis 模式打猴子补丁
-    kombu有bug，redis中间件 unnacked 中的任务即使客户端掉线了或者突然关闭脚本中正在运行的任务，也永远不会被重新消费。
-    这个很容易验证那个测试，把消费函数写成sleep 100秒，启动20秒后把脚本关掉，取出来的任务在 unacked 队列中那个永远不会被确认消费，也不会被重新消费。
-    """
-
-    # noinspection PyUnusedLocal
-    def monkey_get(self, callback, timeout=None):
-        self._in_protected_read = True
-        try:
-            for channel in self._channels:
-                if channel.active_queues:  # BRPOP mode?
-                    if channel.qos.can_consume():
-                        self._register_BRPOP(channel)
-                if channel.active_fanout_queues:  # LISTEN mode?
-                    self._register_LISTEN(channel)
-
-            events = self.poller.poll(timeout)
-            if events:
-                for fileno, event in events:
-                    ret = None
-                    # noinspection PyBroadException,PyUnusedLocal
-                    try:
-                        ret = self.handle_event(fileno, event)  # 主要是这行改了加了try，不然会raise empty 导致self.maybe_restore_messages()没执行
-                    except BaseException as e:
-                        pass
-                        # print(traceback.format_exc())
-                        # print(e)
-                    if ret:
-                        return
-            # - no new data, so try to restore messages.
-            # - reset active redis commands.
-            self.maybe_restore_messages()
-            raise Empty()
-            # raise Exception('kombu.five.Empty')
-        finally:
-            self._in_protected_read = False
-            # print(self.after_read)
-            while self.after_read:
-                try:
-                    fun = self.after_read.pop()
-                except KeyError:
-                    break
-                else:
-                    fun()
-
-    redis.MultiChannelPoller.get = monkey_get
 
 
 has_patch_kombu_redis = False
@@ -211,7 +162,6 @@ Transport Options
                 self.conn.drain_events()
 
     def _confirm_consume(self, kw):
-        pass  # redis没有确认消费的功能。
         kw['message'].ack()
 
     def _requeue(self, kw):

funboost/consumers/tcp_consumer.py

@@ -13,32 +13,34 @@ class TCPConsumer(AbstractConsumer, ):
     socket 实现消息队列，不支持持久化，但不需要安装软件。
     """
 
-
-    BUFSIZE = 10240
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None, 'bufsize': 10240}
 
     # noinspection PyAttributeOutsideInit
     def custom_init(self):
-        ip__port_str = self.queue_name.split(':')
-        ip_port = (ip__port_str[0], int(ip__port_str[1]))
-        self._ip_port_raw = ip_port
-        self._ip_port = ('', ip_port[1])
+        # ip__port_str = self.queue_name.split(':')
+        # ip_port = (ip__port_str[0], int(ip__port_str[1]))
+        # self._ip_port_raw = ip_port
+        # self._ip_port = ('', ip_port[1])
         # ip_port = ('', 9999)
+        self._ip_port = (self.consumer_params.broker_exclusive_config['host'],
+                         self.consumer_params.broker_exclusive_config['port'])
+        self.bufsize = self.consumer_params.broker_exclusive_config['bufsize']
 
     # noinspection DuplicatedCode
     def _shedual_task(self):
-        """ tcp为消息队列中间件 时候 queue_name 要设置为例如  127.0.0.1:5689"""
+      
         server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # tcp协议
         server.bind(self._ip_port)
         server.listen(128)
         self._server = server
         while True:
             tcp_cli_sock, addr = self._server.accept()
-            Thread(target=self.__handle_conn, args=(tcp_cli_sock,)).start() # 服务端多线程，可以同时处理多个tcp长链接客户端发来的消息。
+            Thread(target=self.__handle_conn, args=(tcp_cli_sock,)).start()  # 服务端多线程，可以同时处理多个tcp长链接客户端发来的消息。
 
     def __handle_conn(self, tcp_cli_sock):
         try:
             while True:
-                data = tcp_cli_sock.recv(self.BUFSIZE)
+                data = tcp_cli_sock.recv(self.bufsize)
                 # print('server收到的数据', data)
                 if not data:
                     break
@@ -56,4 +58,3 @@ class TCPConsumer(AbstractConsumer, ):
 
     def _requeue(self, kw):
         pass
-

funboost/consumers/udp_consumer.py

@@ -12,14 +12,17 @@ class UDPConsumer(AbstractConsumer, ):
     socket 实现消息队列，不支持持久化，但不需要安装软件。
     """
 
-    BUFSIZE = 10240
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None, 'bufsize': 10240}
 
     # noinspection PyAttributeOutsideInit
     def custom_init(self):
-        """ udp为消息队列中间件 时候 queue_name 要设置为例如  127.0.0.1:5689"""
+        
         self.__udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        ip__port_str = self.queue_name.split(':')
-        self.__ip_port = (ip__port_str[0], int(ip__port_str[1]))
+        # ip__port_str = self.queue_name.split(':')
+        # self.__ip_port = (ip__port_str[0], int(ip__port_str[1]))
+        self.__ip_port = (self.consumer_params.broker_exclusive_config['host'],
+                          self.consumer_params.broker_exclusive_config['port'])
+        self._bufsize = self.consumer_params.broker_exclusive_config['bufsize']
         self.__udp_client.connect(self.__ip_port)
 
     # noinspection DuplicatedCode
@@ -29,7 +32,7 @@ class UDPConsumer(AbstractConsumer, ):
         server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # udp协议
         server.bind(ip_port)
         while True:
-            data, client_addr = server.recvfrom(self.BUFSIZE)
+            data, client_addr = server.recvfrom(self._bufsize)
             # print('server收到的数据', data)
             # self._print_message_get_from_broker(f'udp {ip_port}', data.decode())
             server.sendto('has_recived'.encode(), client_addr)
@@ -41,4 +44,4 @@ class UDPConsumer(AbstractConsumer, ):
 
     def _requeue(self, kw):
         self.__udp_client.send(json.dumps(kw['body']).encode())
-        data = self.__udp_client.recv(self.BUFSIZE)
+        data = self.__udp_client.recv(self._bufsize)

funboost/consumers/zeromq_consumer.py

@@ -67,31 +67,38 @@ class ZeroMqConsumer(AbstractConsumer):
     zeromq 中间件的消费者，zeromq基于socket代码，不会持久化，且不需要安装软件。
     """
 
-    def start_broker_queue_name_as_port(self):
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'port': None}
+
+    def custom_init(self):
+        self._port = self.consumer_params.broker_exclusive_config['port']
+        if self._port is None:
+            raise ValueError('please specify port')
+
+    def _start_broker_port(self):
         # threading.Thread(target=self._start_broker).start()
         # noinspection PyBroadException
         try:
-            if not (10000 < int(self._queue_name) < 65535):
-                raise ValueError("，请设置queue的名字是一个 10000到65535的之间的一个端口数字")
+            if not (10000 < int(self._port) < 65535):
+                raise ValueError("请设置port是一个 10000到65535的之间的一个端口数字")
         except BaseException:
-            self.logger.critical(f" zeromq 模式以 queue 的民资作为tcp 端口，请设置queue的名字是一个 10000 到 65535 之间的一个端口数字")
+            self.logger.critical(f" 请设置port是一个 10000到65535的之间的一个端口数字")
             # noinspection PyProtectedMember
             os._exit(444)
-        if check_port_is_used('127.0.0.1', int(self._queue_name)):
-            self.logger.debug(f"""{int(self._queue_name)} router端口已经启动(或占用) """)
+        if check_port_is_used('127.0.0.1', int(self._port)):
+            self.logger.debug(f"""{int(self._port)} router端口已经启动(或占用) """)
             return
-        if check_port_is_used('127.0.0.1', int(self._queue_name) + 1):
-            self.logger.debug(f"""{int(self._queue_name) + 1} dealer 端口已经启动(或占用) """)
+        if check_port_is_used('127.0.0.1', int(self._port) + 1):
+            self.logger.debug(f"""{int(self._port) + 1} dealer 端口已经启动(或占用) """)
             return
-        multiprocessing.Process(target=start_broker, args=(int(self._queue_name), int(self._queue_name) + 1)).start()
+        multiprocessing.Process(target=start_broker, args=(int(self._port), int(self._port) + 1)).start()
 
     # noinspection DuplicatedCode
     def _shedual_task(self):
-        self.start_broker_queue_name_as_port()
+        self._start_broker_port()
         context = ZmqImporter().zmq.Context()
         # noinspection PyUnresolvedReferences
         zsocket = context.socket(ZmqImporter().zmq.REP)
-        zsocket.connect(f"tcp://localhost:{int(self._queue_name) + 1}")
+        zsocket.connect(f"tcp://localhost:{int(self._port) + 1}")
 
         while True:
             message = zsocket.recv()

funboost/core/exceptions.py

@@ -11,6 +11,11 @@ class ExceptionForRetry(FunboostException):
 class ExceptionForRequeue(FunboostException):
     """框架检测到此错误，重新放回当前队列中"""
 
+class FunboostWaitRpcResultTimeout(FunboostException):
+    """等待rpc结果超过了指定时间"""
+
+class FunboostRpcResultError(FunboostException):
+    """rpc结果是错误状态"""
 
 class ExceptionForPushToDlxqueue(FunboostException):
     """框架检测到ExceptionForPushToDlxqueue错误，发布到死信队列"""
@@ -40,3 +45,5 @@ def f(x):
 
     def __str__(self):
         return self.new_version_change_hint
+
+

funboost/core/func_params_model.py

@@ -109,8 +109,8 @@ class FunctionResultStatusPersistanceConfig(BaseJsonAbleModel):
             flogger.warning(f'你设置的过期时间为 {value} ,设置的时间过长。 ')
         return value
 
-    @root_validator(skip_on_failure=True,allow_reuse=True)
-    def cehck_values(cls, values: dict):
+    @root_validator(skip_on_failure=True)
+    def check_values(cls, values: dict):
         if not values['is_save_status'] and values['is_save_result']:
             raise ValueError(f'你设置的是不保存函数运行状态但保存函数运行结果。不允许你这么设置')
         return values
@@ -159,10 +159,18 @@ class BoosterParams(BaseJsonAbleModel):
     consumin_function_decorator: typing.Optional[typing.Callable] = None  # 函数的装饰器。因为此框架做参数自动转指点，需要获取精准的入参名称，不支持在消费函数上叠加 @ *args  **kwargs的装饰器，如果想用装饰器可以这里指定。
     function_timeout: typing.Union[int, float,None] = None  # 超时秒数，函数运行超过这个时间，则自动杀死函数。为0是不限制。 谨慎使用,非必要别去设置超时时间,设置后性能会降低(因为需要把用户函数包装到另一个线单独的程中去运行),而且突然强制超时杀死运行中函数,可能会造成死锁.(例如用户函数在获得线程锁后突然杀死函数,别的线程再也无法获得锁了)
 
-    log_level: int = logging.DEBUG  # 消费者和发布者的日志级别,建议设置DEBUG级别,不然无法知道正在运行什么消息
+    """
+    log_level:
+        logger_name 对应的 日志级别
+        消费者和发布者的日志级别,建议设置DEBUG级别,不然无法知道正在运行什么消息.
+        这个是funboost每个队列的单独命名空间的日志级别,丝毫不会影响改变用户其他日志以及root命名空间的日志级别,所以DEBUG级别就好,
+        用户不要压根不懂什么是python logger 的name,还去手痒调高级别. 
+        不懂python日志命名空间的小白去看nb_log文档,或者直接问 ai大模型 python logger name的作用是什么.
+    """
+    log_level: int = logging.DEBUG # 不需要改这个级别,请看上面原因
     logger_prefix: str = ''  # 日志名字前缀,可以设置前缀
     create_logger_file: bool = True  # 发布者和消费者是否创建文件文件日志,为False则只打印控制台不写文件.
-    logger_name: str = ''  # 队列消费者发布者的日志命名空间.
+    logger_name: typing.Union[str, None] = ''  # 队列消费者发布者的日志命名空间.
     log_filename: typing.Union[str, None] = None  # 消费者发布者的文件日志名字.如果为None,则自动使用 funboost.队列 名字作为文件日志名字.  日志文件夹是在nb_log_config.py的 LOG_PATH中决定的.
     is_show_message_get_from_broker: bool = False  # 运行时候,是否记录从消息队列获取出来的消息内容
     is_print_detail_exception: bool = True  # 消费函数出错时候,是否打印详细的报错堆栈,为False则只打印简略的报错信息不包含堆栈.
@@ -221,7 +229,7 @@ class BoosterParams(BaseJsonAbleModel):
 
 
 
-    @root_validator(skip_on_failure=True)
+    @root_validator(skip_on_failure=True, )
     def check_values(cls, values: dict):
        
 
@@ -307,7 +315,7 @@ class PriorityConsumingControlConfig(BaseJsonAbleModel):
     eta: typing.Union[datetime.datetime, str,None] = None  # 时间对象， 或 %Y-%m-%d %H:%M:%S 字符串。
     misfire_grace_time: typing.Union[int, None] = None
 
-    other_extra_params: dict = None  # 其他参数, 例如消息优先级 , priority_control_config=PriorityConsumingControlConfig(other_extra_params={'priroty': priorityxx})，
+    other_extra_params: typing.Optional[dict] = None  # 其他参数, 例如消息优先级 , priority_control_config=PriorityConsumingControlConfig(other_extra_params={'priroty': priorityxx})，
     
     """filter_str:
     用户指定过滤字符串， 例如函数入参是 def fun(userid,username,sex，user_description),
@@ -318,6 +326,7 @@ class PriorityConsumingControlConfig(BaseJsonAbleModel):
     """
     filter_str :typing.Optional[str] = None 
 
+    can_not_json_serializable_keys: typing.List[str] = None # 不能json序列化的入参名字，反序列化时候需要使用pickle来反序列化这些字段(这个是自动生成的，用户不需要手动指定此入参。)
     @root_validator(skip_on_failure=True)
     def cehck_values(cls, values: dict):
         if values['countdown'] and values['eta']:
@@ -356,4 +365,4 @@ if __name__ == '__main__':
     # print(PriorityConsumingControlConfig().get_str_dict())
 
     print(BoosterParams(queue_name='3213', specify_concurrent_pool=FlexibleThreadPool(100)).json_pre())
-    print(PublisherParams.schema_json())
+    # print(PublisherParams.schema_json())  # 注释掉，因为 PublisherParams 包含 Callable 类型字段，无法生成 JSON Schema

funboost/core/function_result_status_saver.py

@@ -51,6 +51,9 @@ class FunctionResultStatus():
         self.result = None
         self.run_times = 0
         self.exception = None
+        self.exception_type = None
+        self.exception_msg = None
+        self.rpc_chain_error_msg_dict:dict  = None
         self.time_start = time.time()
         self.time_cost = None
         self.time_end = None
@@ -62,6 +65,15 @@ class FunctionResultStatus():
         self._has_kill_task = False
         self.rpc_result_expire_seconds = None
 
+    @classmethod
+    def parse_status_and_result_to_obj(cls,status_dict:dict):
+        obj = cls(status_dict['queue_name'],status_dict['function'],status_dict['msg_dict'])
+        for k,v in status_dict.items():
+            # if k.startswith('_'):
+            #     continue
+            setattr(obj,k,v)
+        return obj
+
     def get_status_dict(self, without_datetime_obj=False):
         self.time_end = time.time()
         if self.run_status == RunStatus.running:
@@ -102,6 +114,9 @@ class FunctionResultStatus():
     def __str__(self):
         return f'''{self.__class__}   {Serialization.to_json_str(self.get_status_dict())}'''
 
+    def to_pretty_json_str(self):
+        return json.dumps(self.get_status_dict(),indent=4,ensure_ascii=False)
+
 
 class ResultPersistenceHelper(MongoMixin, FunboostFileLoggerMixin):
     TASK_STATUS_DB = 'task_status'