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

funboost/__init__.py

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

funboost/assist/celery_helper.py

@@ -8,7 +8,7 @@ import threading
 from functools import partial
 
 import celery
-
+from celery.app.task import Task
 import nb_log
 from funboost.funboost_config_deafult import BrokerConnConfig,FunboostCommonConfig
 from funboost import  ConcurrentModeEnum

funboost/concurrent_pool/async_pool_executor.py

@@ -6,6 +6,7 @@ import threading
 import time
 import traceback
 from threading import Thread
+import traceback
 
 from funboost.concurrent_pool.base_pool_type import FunboostBaseConcurrentPool
 from funboost.core.loggers import FunboostFileLoggerMixin
@@ -53,14 +54,17 @@ class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
     使api和线程池一样，最好的性能做法是submit也弄成 async def，生产和消费在同一个线程同一个loop一起运行，但会对调用链路的兼容性产生破坏，从而调用方式不兼容线程池。
     """
 
-    def __init__(self, size, loop=None):
+    def __init__(self, size, specify_async_loop=None,
+                 is_auto_start_specify_async_loop_in_child_thread=True):
         """
 
         :param size: 同时并发运行的协程任务数量。
-        :param loop:
+        :param specify_loop: 可以指定loop,异步三方包的连接池发请求不能使用不同的loop去使用连接池.
         """
         self._size = size
-        self.loop = loop or asyncio.new_event_loop()
+        self._specify_async_loop = specify_async_loop
+        self._is_auto_start_specify_async_loop_in_child_thread = is_auto_start_specify_async_loop_in_child_thread
+        self.loop = specify_async_loop or asyncio.new_event_loop()
         asyncio.set_event_loop(self.loop)
         self._diff_init()
         # self._lock = threading.Lock()
@@ -90,7 +94,7 @@ class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
 
     def submit(self, func, *args, **kwargs):
         future = asyncio.run_coroutine_threadsafe(self._produce(func, *args, **kwargs), self.loop)  # 这个 run_coroutine_threadsafe 方法也有缺点，消耗的性能巨大。
-        future.result()  # 阻止过快放入，放入超过队列大小后，使submit阻塞。
+        future.result()  # 阻止过快放入，放入超过队列大小后，使submit阻塞。 背压是为了防止 迅速掏空消息队列几千万消息到内存.
 
     async def _produce(self, func, *args, **kwargs):
         await self._queue.put((func, args, kwargs))
@@ -119,12 +123,22 @@ class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
         # asyncio.set_event_loop(self.loop)
         # self.loop.run_until_complete(asyncio.wait([self._consume() for _ in range(self._size)], loop=self.loop))
         # self._can_be_closed_flag = True
-        [self.loop.create_task(self._consume()) for _ in range(self._size)]
-        try:
+        if self._specify_async_loop is None:
+            for _ in range(self._size):
+                self.loop.create_task(self._consume())
+        else:
+            for _ in range(self._size):
+                asyncio.run_coroutine_threadsafe(self._consume(),self.loop) # 这是 asyncio 专门提供的用于从其他线程向事件循环安全提交任务的函数。
+        if self._specify_async_loop is None:
             self.loop.run_forever()
-        except Exception as e:
-            self.logger.warning(f'{e}')   # 如果多个线程使用一个loop，不能重复启动loop，否则会报错。
-
+        else:
+            if self._is_auto_start_specify_async_loop_in_child_thread:
+                try:
+                    self.loop.run_forever() #如果是指定的loop不能多次启动一个loop.
+                except Exception as e:
+                    self.logger.warning(f'{e} {traceback.format_exc()}')   # 如果多个线程使用一个loop，不能重复启动loop，否则会报错。
+            else:
+                pass # 用户需要自己在自己的业务代码中去手动启动loop.run_forever() 
 
 
     # def shutdown(self):
@@ -139,14 +153,6 @@ class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
 
 
 
-
-
-
-
-
-
-
-
 if __name__ == '__main__':
     def test_async_pool_executor():
         from funboost.concurrent_pool import CustomThreadPoolExecutor as ThreadPoolExecutor

funboost/constant.py

@@ -101,6 +101,8 @@ class BrokerEnum:
 
     HTTP = 'HTTP'  # 基于http实现的，发布使用的urllib3，消费服务端使用的aiohttp.server实现的，支持分布式但不支持持久化，好处是不需要安装消息队列中间件软件。
 
+    GRPC = 'GRPC' # 使用知名grpc作为broker,可以使用 sync_call 方法同步获取grpc的结果, 简单程度暴击用户手写原生的 grpc客户端 服务端
+
     NATS = 'NATS'  # 高性能中间件nats,中间件服务端性能很好,。
 
     TXT_FILE = 'TXT_FILE'  # 磁盘txt文件作为消息队列，支持单机持久化，不支持多机分布式。不建议这个，用sqlite。
@@ -119,6 +121,27 @@ class BrokerEnum:
 
     NAMEKO = 'NAMEKO'  # funboost支持python微服务框架nameko，用户无需掌握nameko api语法，就玩转python nameko微服务
 
+    
+    """
+    MYSQL_CDC 是 funboost 中 神奇 的 与众不同的 broker 中间件
+    mysql binlog cdc 自动作为消息,用户无需手动发布消息,只需要写处理binlog内容的逻辑, 
+    一行代码就能轻量级实现 mysql2mysql mysql2kafka mysql2rabbitmq 等等.
+    这个是与其他中间件不同,不需要手工发布消息, 任何对数据库的 insert update delete 会自动作为 funboost 的消息.
+    几乎是轻量级平替 canal  flinkcdc 的作用.
+    
+    以此类推, 日志文件也能扩展作为broker,只要另外一个程序写入了文件日志,就能触发funboost消费,
+    然后自己在函数逻辑把消息发到kafka,(虽然是已经有大名鼎鼎elk,这只是举个场景例子,说明funboost broker的灵活性)
+
+    日志文件、文件系统变更（inotify）、甚至是硬件传感器的信号，按照4.21章节文档，都可以被封装成一个 funboost 的 Broker。
+
+    充分说明 funboost 有能力化身为 通用的、事件驱动的函数调度平台,而非仅仅是celery这种传统的消息驱动.
+    """
+    """
+    funboost 有能力消费canal发到kafka的binlog消息,也能不依赖canal,自己捕获cdc数据
+    """
+    MYSQL_CDC = 'MYSQL_CDC'
+
+
 
 class ConcurrentModeEnum:
     THREADING = 'threading'  # 线程方式运行，兼容支持 async def 的异步函数。

funboost/consumers/base_consumer.py

@@ -637,10 +637,13 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         """
         self._do_not_delete_extra_from_msg = True
 
-    def user_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus):  # 这个可以继承
+    def _frame_custom_record_process_info_func(self,current_function_result_status: FunctionResultStatus,kw:dict):
         pass
 
-    async def aio_user_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus):  # 这个可以继承
+    def user_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus,):  # 这个可以继承
+        pass
+
+    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,extra_params:dict):
@@ -729,9 +732,10 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
 
             with self._lock_for_count_execute_task_times_every_unit_time:
                 self.metric_calculation.cal(t_start_run_fun,current_function_result_status)
-            self.user_custom_record_process_info_func(current_function_result_status)  # 两种方式都可以自定义,记录结果,建议继承方式,不使用boost中指定 user_custom_record_process_info_func
+            self._frame_custom_record_process_info_func(current_function_result_status,kw)
+            self.user_custom_record_process_info_func(current_function_result_status,)  # 两种方式都可以自定义,记录结果,建议继承方式,不使用boost中指定 user_custom_record_process_info_func
             if self.consumer_params.user_custom_record_process_info_func:
-                self.consumer_params.user_custom_record_process_info_func(current_function_result_status)
+                self.consumer_params.user_custom_record_process_info_func(current_function_result_status,)
         except BaseException as e:
             log_msg = f' error 严重错误 {type(e)} {e} '
             # self.logger.critical(msg=f'{log_msg} \n', exc_info=True)
@@ -888,10 +892,11 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             async with self._async_lock_for_count_execute_task_times_every_unit_time:
                 self.metric_calculation.cal(t_start_run_fun, current_function_result_status)
 
-            self.user_custom_record_process_info_func(current_function_result_status)  # 两种方式都可以自定义,记录结果.建议使用文档4.21.b的方式继承来重写
-            await self.aio_user_custom_record_process_info_func(current_function_result_status)
+            self._frame_custom_record_process_info_func(current_function_result_status)
+            self.user_custom_record_process_info_func(current_function_result_status,)  # 两种方式都可以自定义,记录结果.建议使用文档4.21.b的方式继承来重写
+            await self.aio_user_custom_record_process_info_func(current_function_result_status,)
             if self.consumer_params.user_custom_record_process_info_func:
-                self.consumer_params.user_custom_record_process_info_func(current_function_result_status)
+                self.consumer_params.user_custom_record_process_info_func(current_function_result_status,)
 
         except BaseException as e:
             log_msg = f' error 严重错误 {type(e)} {e} '
@@ -1126,7 +1131,9 @@ class ConcurrentModeDispatcher(FunboostFileLoggerMixin):
         # pool_type = ProcessPoolExecutor
         if self._concurrent_mode == ConcurrentModeEnum.ASYNC:
             self.consumer._concurrent_pool = self.consumer.consumer_params.specify_concurrent_pool or pool_type(
-                self.consumer.consumer_params.concurrent_num, loop=self.consumer.consumer_params.specify_async_loop)
+                self.consumer.consumer_params.concurrent_num,
+                  specify_async_loop=self.consumer.consumer_params.specify_async_loop,
+                  is_auto_start_specify_async_loop_in_child_thread=self.consumer.consumer_params.is_auto_start_specify_async_loop_in_child_thread)
         else:
             # print(pool_type)
             self.consumer._concurrent_pool = self.consumer.consumer_params.specify_concurrent_pool or pool_type(self.consumer.consumer_params.concurrent_num)

funboost/consumers/grpc_consumer.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2023/8/8 0008 13:32
+
+import abc
+import threading
+import grpc
+import time
+
+from funboost import FunctionResultStatus
+from funboost.assist.grpc_helper import funboost_grpc_pb2_grpc, funboost_grpc_pb2
+from funboost.consumers.base_consumer import AbstractConsumer
+from funboost.core.serialization import Serialization
+from funboost.core.exceptions import FunboostWaitRpcResultTimeout
+from funboost.concurrent_pool.flexible_thread_pool import FlexibleThreadPool
+
+
+class FutureStatusResult:
+    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
+
+
+
+
+class GrpcConsumer(AbstractConsumer, ):
+    """
+     grpc as  broker
+    """
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None}
+
+    def custom_init(self):
+        class FunboostGrpcServicer(funboost_grpc_pb2_grpc.FunboostBrokerServiceServicer):
+            """
+            HelloService 的实现类
+            """
+
+            def Call(this, request, context):
+                """
+                实现 SayHello 方法
+                """
+                future_status_result = FutureStatusResult(call_type=request.call_type)
+                kw = {'body': request.json_req, 'future_status_result': future_status_result,}
+                self._submit_task(kw)
+                if request.call_type =="sync_call":
+                    if future_status_result.wait_finish(self.consumer_params.rpc_timeout):  # 等待并发出的消费结果
+                        return funboost_grpc_pb2.FunboostGrpcResponse(json_resp=Serialization.to_json_str(
+                            future_status_result.get_staus_result_obj().get_status_dict(without_datetime_obj=True)))
+                    else:
+                        self.logger.error(f'wait rpc data timeout')
+                        context.set_code(grpc.StatusCode.DEADLINE_EXCEEDED)
+                        context.set_details(f'wait rpc data timeout')
+                        # raise FunboostWaitRpcResultTimeout(f'wait rpc data timeout')
+                else:
+                    return funboost_grpc_pb2.FunboostGrpcResponse(json_resp='{"publish_status":"ok"}')
+
+        self.GRPC_SERVICER_CLS = FunboostGrpcServicer
+
+    def _shedual_task(self):
+        server = grpc.server(self.concurrent_pool)
+
+        # 添加服务
+        funboost_grpc_pb2_grpc.add_FunboostBrokerServiceServicer_to_server(self.GRPC_SERVICER_CLS(), server)
+
+        # 绑定端口
+        port = self.consumer_params.broker_exclusive_config['port']
+        if port is None:
+            raise ValueError('please specify port')
+        listen_addr = f'[::]:{port}'
+        server.add_insecure_port(listen_addr)
+
+        # 启动服务器
+        server.start()
+        print(f"GRPC Has started. listening on: {listen_addr}")
+
+        while True:
+            time.sleep(100)  # 保持服务器运行
+
+    def _confirm_consume(self, kw):
+        pass
+
+    def _requeue(self, kw):
+        pass
+
+    def _frame_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus, kw):
+        future_status_result: FutureStatusResult = kw['future_status_result']
+        if future_status_result.call_type == "sync_call":
+            future_status_result.set_staus_result_obj(current_function_result_status)
+            future_status_result.set_finish()  # 这是最重要最核心的, 并发池里面处理函数完成,马上告诉grpc服务端，已经处理完成.

funboost/consumers/kafka_consumer.py

@@ -22,7 +22,7 @@ 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'}
+    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 介绍
@@ -35,7 +35,9 @@ class KafkaConsumer(AbstractConsumer):
     def _shedual_task(self):
         try:
             admin_client = KafkaPythonImporter().KafkaAdminClient(bootstrap_servers=BrokerConnConfig.KAFKA_BOOTSTRAP_SERVERS)
-            admin_client.create_topics([KafkaPythonImporter().NewTopic(self._queue_name, 10, 1)])
+            admin_client.create_topics([KafkaPythonImporter().NewTopic(self._queue_name,
+                                                                       self.consumer_params.broker_exclusive_config['num_partitions'],
+                                                                       self.consumer_params.broker_exclusive_config['replication_factor'])])
             # admin_client.create_partitions({self._queue_name: NewPartitions(total_count=16)})
         except KafkaPythonImporter().TopicAlreadyExistsError:
             pass

funboost/consumers/kafka_consumer_manually_commit.py

@@ -2,6 +2,9 @@
 # @Author  : ydf
 # @Time    : 2021/4/18 0008 13:32
 
+"""
+    这个可以实现kafka topic单分区,但funboost 200线程消费消息,并且随意强制重启消费进程,不丢失消息
+"""
 
 import json
 import threading
@@ -28,7 +31,7 @@ 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_confluent_kafka', 'auto_offset_reset': 'earliest'}
+    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()
@@ -37,7 +40,9 @@ class KafkaConsumerManuallyCommit(AbstractConsumer):
 
         try:
             admin_client = KafkaPythonImporter().KafkaAdminClient(bootstrap_servers=BrokerConnConfig.KAFKA_BOOTSTRAP_SERVERS)
-            admin_client.create_topics([KafkaPythonImporter().NewTopic(self._queue_name, 10, 1)])
+            admin_client.create_topics([KafkaPythonImporter().NewTopic(self._queue_name,
+                                                                       self.consumer_params.broker_exclusive_config['num_partitions'],
+                                                                       self.consumer_params.broker_exclusive_config['replication_factor'])])
             # admin_client.create_partitions({self._queue_name: NewPartitions(total_count=16)})
         except KafkaPythonImporter().TopicAlreadyExistsError:
             pass

funboost/consumers/mysql_cdc_consumer.py

@@ -0,0 +1,95 @@
+# funboost/consumers/cdc_consumer.py
+
+import time
+import typing
+from funboost.consumers.base_consumer import AbstractConsumer
+from funboost.core.loggers import develop_logger
+
+# pip install mysql-replication==1.0.9
+from pymysqlreplication import BinLogStreamReader
+from pymysqlreplication.row_event import (
+    DeleteRowsEvent,
+    UpdateRowsEvent,
+    WriteRowsEvent,
+)
+
+
+
+class MysqlCdcConsumer(AbstractConsumer):
+    """
+    A consumer that listens to MySQL binlog events (CDC) and treats them as tasks.
+    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."""
+        config = self.consumer_params.broker_exclusive_config['BinLogStreamReaderConfig']
+        if not config.get('connection_settings') or not config.get('server_id'):
+            raise ValueError("For 'funboost_cdc' broker, 'connection_settings' and 'server_id' must be provided in 'broker_exclusive_config'.")
+        self.logger.info("FunboostCdcConsumer initialized. Ready to listen for binlog events.")
+        self._bin_log_stream_reader_config = config
+
+    def _shedual_task(self):
+        """
+        This is the main loop that connects to MySQL, reads binlog events,
+        and submits them as tasks to the funboost engine.
+        """
+        # Prepare the arguments for BinLogStreamReader by filtering out None values
+
+
+        stream = BinLogStreamReader(**self._bin_log_stream_reader_config)
+
+        try:
+            for binlogevent in stream:
+                event_type = None
+                if isinstance(binlogevent, WriteRowsEvent):
+                    event_type = 'INSERT'
+                elif isinstance(binlogevent, UpdateRowsEvent):
+                    event_type = 'UPDATE'
+                elif isinstance(binlogevent, DeleteRowsEvent):
+                    event_type = 'DELETE'
+
+                if event_type:
+                    for row in binlogevent.rows:
+                        # Construct a clear, flat dictionary to be used as function kwargs
+                        task_body = {
+                            'event_type': event_type,
+                            'schema': binlogevent.schema,
+                            'table': binlogevent.table,
+                            'timestamp': binlogevent.timestamp,
+                        }
+                        # Unpack row data ('values' or 'before_values'/'after_values')
+                        task_body.update(row)
+
+                        # Submit the structured data as a task to the funboost engine
+                        self._submit_task({'body': task_body})
+        except Exception as e:
+            self.logger.critical(f"An error occurred in the binlog stream: {e}", exc_info=True)
+            # A small delay before potentially restarting or exiting, depending on supervisor.
+            time.sleep(10)
+        finally:
+            self.logger.info("Closing binlog stream.")
+            stream.close()
+
+    def _confirm_consume(self, kw: dict):
+        """
+        Confirmation is implicitly handled by the BinLogStreamReader's position management.
+        When resume_stream=True, the library automatically saves its position.
+        Funboost's ACK here confirms that the *processing* of the event is complete.
+        """
+        pass
+
+    def _requeue(self, kw: dict):
+        """
+        Requeuing a binlog event is not a standard operation.
+        Funboost's built-in retry mechanism should be used for transient processing errors.
+        If a task fails permanently, it will be ACK'd after exhausting retries,
+        and the binlog position will eventually advance.
+        """
+        self.logger.warning(f"Requeuing a CDC event is not supported. "
+                            f"Use funboost's retry mechanism for processing failures. Task: {kw.get('body')}")
+        pass

funboost/contrib/cdc/mysql2mysql.py

@@ -0,0 +1,44 @@
+import dataset
+from typing import Dict
+
+class MySql2Mysql:
+    """
+    使用dataset封装的mysql binlog消息数据,保存到目标库中
+    有了这个贡献类, 用户只需要一行代码就能通过cdc 实现 mysql2mysql,非常方便把数据库实例1的源表a,自动实时同步到数据库实例2的目标表a
+
+    这个只是贡献类,用户想怎么插入表,想怎么清洗都可以,可以参考这个例子,dataset把一个字典保存到mysql的一行,真的很方便.
+    用户还可以自定义批量插入目标表,都可以. 这个类不是必须使用,是做个示范.
+    """
+    def __init__(self, primary_key: str,
+                 target_table_name: str,
+                 target_sink_db: dataset.Database, ):
+        self.primary_key = primary_key
+        self.target_table_name = target_table_name
+        self.target_sink_db = target_sink_db
+
+    def sync_data(self, event_type: str,
+                  schema: str,
+                  table: str,
+                  timestamp: int,
+                  row_data: Dict, ):
+        # 例如把这个表里面的数据原封不动 插入到 testdb7.users 表里面
+        target_table: dataset.Table = self.target_sink_db[self.target_table_name]  # dataset会根据表名自动获取或创建表
+        print(f"接收到事件: {event_type} on schema: {schema},  table: {table}, timestamp: {timestamp}")
+
+        if event_type == 'INSERT':
+            # `row_data` 中包含 'values' 字典
+            data_to_insert = row_data['values']
+            target_table.upsert(data_to_insert, [self.primary_key])
+            print(f"  [INSERT] 成功同步数据: {data_to_insert}")
+
+        elif event_type == 'UPDATE':
+            # `row_data` 中包含 'before_values' 和 'after_values'
+            data_to_update = row_data['after_values']
+            target_table.upsert(data_to_update, [self.primary_key])
+            print(f"  [UPDATE] 成功同步数据: {data_to_update}")
+
+        elif event_type == 'DELETE':
+            # `row_data` 中包含 'values' 字典，即被删除的行的数据
+            data_to_delete = row_data['values']
+            target_table.delete(**{self.primary_key: data_to_delete[self.primary_key]})
+            print(f"  [DELETE] 成功同步数据: {data_to_delete}")

funboost/core/booster.py

@@ -142,6 +142,7 @@ class Booster:
 
     def _safe_push(self, *func_args, **func_kwargs) -> AsyncResult:
         """ 多进程安全的,在fork多进程(非spawn多进程)情况下,有的包多进程不能共用一个连接,例如kafka"""
+        # print( self.__dict__)
         consumer = BoostersManager.get_or_create_booster_by_queue_name(self.queue_name).consumer
         return consumer.publisher_of_same_queue.push(*func_args, **func_kwargs)
 
@@ -155,14 +156,14 @@ class Booster:
         """asyncio 生态下发布消息,因为同步push只需要消耗不到1毫秒,所以基本上大概可以直接在asyncio异步生态中直接调用同步的push方法,
         但为了更好的防止网络波动(例如发布消息到外网的消息队列耗时达到10毫秒),可以使用aio_push"""
         async_result = await simple_run_in_executor(self.push, *func_args, **func_kwargs)
-        return AioAsyncResult(async_result.task_id, )
+        return AioAsyncResult(async_result.task_id,timeout=async_result.timeout )
 
     async def aio_publish(self, msg: typing.Union[str, dict], task_id=None,
                           priority_control_config: PriorityConsumingControlConfig = None) -> AioAsyncResult:
         """asyncio 生态下发布消息,因为同步push只需要消耗不到1毫秒,所以基本上大概可以直接在asyncio异步生态中直接调用同步的push方法,
         但为了更好的防止网络波动(例如发布消息到外网的消息队列耗时达到10毫秒),可以使用aio_push"""
         async_result = await simple_run_in_executor(self.publish, msg, task_id, priority_control_config)
-        return AioAsyncResult(async_result.task_id, )
+        return AioAsyncResult(async_result.task_id, timeout=async_result.timeout)
 
     # noinspection PyMethodMayBeStatic
     def multi_process_consume(self, process_num=1):
@@ -207,6 +208,23 @@ class Booster:
         from funboost.core.fabric_deploy_helper import fabric_deploy
         fabric_deploy(self, **params)
 
+    def __getstate__(self):
+        state = {}
+        state['queue_name'] = self.boost_params.queue_name
+        return state
+
+    def __setstate__(self, state):
+        """非常高级的骚操作,支持booster对象pickle序列化和反序列化,设计非常巧妙，堪称神来之笔
+        这样当使用redis作为apscheduler的 jobstores时候,aps_obj.add_job(booster.push,...) 可以正常工作,
+        使不报错 booster对象无法pickle序列化.
+
+        这个反序列化,没有执着于对 socket threding.Lock 怎么反序列化,而是偷换概念，绕过难题,基于标识的代理反序列化
+        """
+        _booster = BoostersManager.get_or_create_booster_by_queue_name(state['queue_name'])
+        self.__dict__.update(_booster.__dict__)
+
+
+
 
 boost = Booster  # @boost 后消费函数.  不能自动补全方法就用 Booster就可以。 2024版本的 pycharm抽风了，@boost的消费函数不能自动补全提示 .consume  .push 这些方法。
 task_deco = boost  # 两个装饰器名字都可以。task_deco是原来名字，兼容一下。
@@ -214,8 +232,13 @@ task_deco = boost  # 两个装饰器名字都可以。task_deco是原来名字
 
 class BoostersManager:
     """
+    这个BoostersManager类是后来加的不是一开始就规划了的.
+
     消费函数生成Booster对象时候,会自动调用BoostersManager.regist_booster方法,把队列名和入参信息保存到pid_queue_name__booster_map字典中.
     使用这个类,可以创建booster对象,达到无需使用装饰器的目的.
+
+    如果你想一次性启动所有函数消费,不想 f1.consume()  f2.consume() f3.consume() 一个个的启动.
+    可以  BoostersManager.consume_all_queues()
     """
 
     # pid_queue_name__booster_map字典存放 {(进程id,queue_name):Booster对象}

funboost/core/exceptions.py

@@ -17,6 +17,9 @@ class FunboostWaitRpcResultTimeout(FunboostException):
 class FunboostRpcResultError(FunboostException):
     """rpc结果是错误状态"""
 
+class HasNotAsyncResult(FunboostException):
+    pass
+
 class ExceptionForPushToDlxqueue(FunboostException):
     """框架检测到ExceptionForPushToDlxqueue错误，发布到死信队列"""
 

funboost/core/func_params_model.py

@@ -57,7 +57,7 @@ class BaseJsonAbleModel(BaseModel):
 
     def json_str_value(self):
         try:
-            return json.dumps(self.get_str_dict(), ensure_ascii=False, )
+            return json.dumps(dict(self.get_str_dict()), ensure_ascii=False, )
         except TypeError as e:
             return str(self.get_str_dict())
 
@@ -134,8 +134,10 @@ class BoosterParams(BaseJsonAbleModel):
     concurrent_mode: str = ConcurrentModeEnum.THREADING  # 并发模式,支持THREADING,GEVENT,EVENTLET,ASYNC,SINGLE_THREAD并发,multi_process_consume 支持协程/线程 叠加多进程并发,性能炸裂.
     concurrent_num: int = 50  # 并发数量，并发种类由concurrent_mode决定
     specify_concurrent_pool: typing.Optional[FunboostBaseConcurrentPool] = None  # 使用指定的线程池/携程池，可以多个消费者共使用一个线程池,节约线程.不为None时候。threads_num失效
+    
     specify_async_loop: typing.Optional[asyncio.AbstractEventLoop] = None  # 指定的async的loop循环，设置并发模式为async才能起作用。 有些包例如aiohttp,发送请求和httpclient的实例化不能处在两个不同的loop中,可以传过来.
-
+    is_auto_start_specify_async_loop_in_child_thread: bool = True  # 是否自动在funboost asyncio并发池的子线程中自动启动指定的async的loop循环，设置并发模式为async才能起作用。如果是False,用户自己在自己的代码中去手动启动自己的loop.run_forever() 
+    
     """qps:
     强悍的控制功能,指定1秒内的函数执行次数，例如可以是小数0.01代表每100秒执行一次，也可以是50代表1秒执行50次.为None则不控频。 设置qps时候,不需要指定并发数量,funboost的能够自适应智能动态调节并发池大小."""
     qps: typing.Union[float, int, None] = None
@@ -186,7 +188,8 @@ class BoosterParams(BaseJsonAbleModel):
     user_custom_record_process_info_func: typing.Optional[typing.Callable] = None  # 提供一个用户自定义的保存消息处理记录到某个地方例如mysql数据库的函数，函数仅仅接受一个入参，入参类型是 FunctionResultStatus，用户可以打印参数
 
     is_using_rpc_mode: bool = False  # 是否使用rpc模式，可以在发布端获取消费端的结果回调，但消耗一定性能，使用async_result.result时候会等待阻塞住当前线程。
-    rpc_result_expire_seconds: int = 600  # 保存rpc结果的过期时间.
+    rpc_result_expire_seconds: int = 1800  # redis保存rpc结果的过期时间.
+    rpc_timeout:int = 1800 # rpc模式下，等待rpc结果返回的超时时间
 
     delay_task_apscheduler_jobstores_kind :Literal[ 'redis', 'memory'] = 'redis'  # 延时任务的aspcheduler对象使用哪种jobstores ，可以为 redis memory 两种作为jobstore
 
@@ -354,7 +357,7 @@ class PublisherParams(BaseJsonAbleModel):
     # func_params_is_pydantic_model: bool = False  # funboost 兼容支持 函数娼还是 pydantic model类型，funboost在发布之前和取出来时候自己转化。
     publish_msg_log_use_full_msg: bool = False # 发布到消息队列的消息内容的日志，是否显示消息的完整体，还是只显示函数入参。
     consuming_function_kind: typing.Optional[str] = None  # 自动生成的信息,不需要用户主动传参.
-
+    rpc_timeout: int = 1800 # rpc模式下，等待rpc结果返回的超时时间
 
 if __name__ == '__main__':
     from funboost.concurrent_pool import FlexibleThreadPool