funboost 44.4__tar.gz → 44.5__tar.gz

{funboost-44.4/funboost.egg-info → funboost-44.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 44.4
+Version: 44.5
 Summary: pip install funboost，python全功能分布式函数调度框架,。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
@@ -492,4 +492,3 @@ funboost通过支持celery作为broker_kind,使celer框架变成了funboost的
 ![](https://visitor-badge.glitch.me/badge?page_id=distributed_framework)
 
 <div> </div>
-

{funboost-44.4 → funboost-44.5}/funboost/__init__.py

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

{funboost-44.4 → funboost-44.5}/funboost/constant.py

@@ -3,14 +3,20 @@ class BrokerEnum:
     RABBITMQ_AMQPSTORM = 'RABBITMQ_AMQPSTORM'  # 使用 amqpstorm 包操作rabbitmq  作为 分布式消息队列，支持消费确认.强烈推荐这个作为funboost中间件。
     RABBITMQ = RABBITMQ_AMQPSTORM
 
-    RABBITMQ_RABBITPY = 'RABBITMQ_RABBITPY'  # 使用 rabbitpy 包操作rabbitmq  作为 分布式消息队列，支持消费确认。
+    RABBITMQ_RABBITPY = 'RABBITMQ_RABBITPY'  # 使用 rabbitpy 包操作rabbitmq  作为 分布式消息队列，支持消费确认，不建议使用
 
     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}
+    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了。
+    REDIS_PUBSUB = 'REDIS_PUBSUB'  # 基于redis 发布订阅的，发布一个消息多个消费者都能收到同一条消息，但不支持持久化
 
     MEMORY_QUEUE = 'MEMORY_QUEUE'  # 使用python queue.Queue实现的基于当前python进程的消息队列，不支持跨进程 跨脚本 跨机器共享任务，不支持持久化，适合一次性短期简单任务。
     LOCAL_PYTHON_QUEUE = MEMORY_QUEUE  # 别名，python本地queue就是基于python自带的语言的queue.Queue，消息存在python程序的内存中，不支持重启断点接续。
 
-    RABBITMQ_PIKA = 'RABBITMQ_PIKA'  # 使用pika包操作rabbitmq  作为 分布式消息队列。
+    RABBITMQ_PIKA = 'RABBITMQ_PIKA'  # 使用pika包操作rabbitmq  作为 分布式消息队列。，不建议使用
 
     MONGOMQ = 'MONGOMQ'  # 使用mongo的表中的行模拟的 作为分布式消息队列，支持消费确认。
 
@@ -27,19 +33,13 @@ class BrokerEnum:
 
     KAFKA_CONFLUENT_SASlPlAIN = 'KAFKA_CONFLUENT_SASlPlAIN'  # 可以设置账号密码的kafka
 
-    REDIS_ACK_ABLE = 'REDIS_ACK_ABLE'  # 基于redis的 list + 临时unack的set队列，采用了 lua脚本操持了取任务和加到pengding为原子性，随意重启和掉线不会丢失任务。
-
-    REDIS_PRIORITY = 'REDIS_PRIORITY'  # # 基于redis的多 list + 临时unack的set队列，blpop监听多个key，和rabbitmq的x-max-priority属性一样，支持任务优先级。看文档4.29优先级队列说明。
-
     SQLACHEMY = 'SQLACHEMY'  # 基于SQLACHEMY 的连接作为分布式消息队列中间件支持持久化和消费确认。支持mysql oracle sqlserver等5种数据库。
 
     ROCKETMQ = 'ROCKETMQ'  # 基于 rocketmq 作为分布式消息队列，这个中间件必须在linux下运行，win不支持。
 
-    REDIS_STREAM = 'REDIS_STREAM'  # 基于redis 5.0 版本以后，使用 stream 数据结构作为分布式消息队列，支持消费确认和持久化和分组消费，是redis官方推荐的消息队列形式，比list结构更适合。
-
     ZEROMQ = 'ZEROMQ'  # 基于zeromq作为分布式消息队列，不需要安装中间件，可以支持跨机器但不支持持久化。
 
-    RedisBrpopLpush = 'RedisBrpopLpush'  # 基于redis的list结构但是采用brpoplpush 双队列形式，和 redis_ack_able的实现差不多，实现上采用了原生命令就不需要lua脚本来实现取出和加入unack了。
+
 
     """
     操作 kombu 包，这个包也是celery的中间件依赖包，这个包可以操作10种中间件(例如rabbitmq redis)，但没包括分布式函数调度框架的kafka nsq zeromq 等。
@@ -69,7 +69,6 @@ class BrokerEnum:
 
     PEEWEE = 'PEEWEE'  # peewee包操作mysql，使用表模拟消息队列
 
-    REDIS_PUBSUB = 'REDIS_PUBSUB'  # 基于redis 发布订阅的，发布一个消息多个消费者都能收到同一条消息，但不支持持久化
 
     CELERY = 'CELERY'  # funboost支持celery框架来发布和消费任务，由celery框架来调度执行任务，但是写法简单远远暴击用户亲自使用celery的麻烦程度，
     # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和include配置,funboost来自动化设置这些celery配置。

{funboost-44.4 → funboost-44.5}/funboost/consumers/base_consumer.py

@@ -35,6 +35,7 @@ from funboost.core.loggers import develop_logger
 
 from funboost.core.func_params_model import BoosterParams, PublisherParams, BaseJsonAbleModel
 from funboost.core.task_id_logger import TaskIdLogger
+from funboost.utils.json_helper import JsonUtils
 from nb_log import (get_logger, LoggerLevelSetterMixin, LogManager,  is_main_process,
                     nb_log_config_default)
 from funboost.core.loggers import FunboostFileLoggerMixin, logger_prompt
@@ -428,8 +429,8 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                     self._last_show_pause_log_time = time.time()
             else:
                 break
-        self._print_message_get_from_broker(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)
             time.sleep(self.time_interval_for_check_do_not_run_time)
@@ -531,10 +532,8 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     def _print_message_get_from_broker(self, msg, broker_name=None):
         # print(999)
         if self.consumer_params.is_show_message_get_from_broker:
-            if isinstance(msg, (dict, list)):
-                msg = json.dumps(msg, ensure_ascii=False)
             # self.logger.debug(f'从 {broker_name} 中间件 的 {self._queue_name} 中取出的消息是 {msg}')
-            self.logger.debug(f'从 {broker_name or self.consumer_params.broker_kind} 中间件 的 {self._queue_name} 中取出的消息是 {msg}')
+            self.logger.debug(f'从 {broker_name or self.consumer_params.broker_kind} 中间件 的 {self._queue_name} 中取出的消息是 {JsonUtils.to_json_str(msg)}')
 
     def _get_priority_conf(self, kw: dict, broker_task_config_key: str):
         broker_task_config = kw['body'].get('extra', {}).get(broker_task_config_key, None)

funboost-44.5/funboost/consumers/redis_consumer_ack_using_timeout.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2024/8/8 0008 13:32
+import json
+import time
+from funboost.consumers.base_consumer import AbstractConsumer
+from funboost.utils.decorators import RedisDistributedLockContextManager
+from funboost.utils.json_helper import JsonUtils
+from funboost.utils.redis_manager import RedisMixin
+
+
+class RedisConsumerAckUsingTimeout(AbstractConsumer, RedisMixin):
+    """
+    redis作为中间件实现的。
+    使用超时未能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'
+        self._ack_timeout = self.consumer_params.broker_exclusive_config['ack_timeout']
+        self._last_show_unack_ts = time.time()
+
+    def start_consuming_message(self):
+        self._is_send_consumer_hearbeat_to_redis = True
+        super().start_consuming_message()
+        self.keep_circulating(10, block=False)(self._requeue_tasks_which_unconfirmed)()
+
+    # def _add_task_str_to_unack_zset(self, task_str, ):
+    #     self.redis_db_frame.zadd(self._unack_zset_name, {task_str: time.time()})
+
+    def _confirm_consume(self, kw):
+        self.redis_db_frame.zrem(self._unack_zset_name, kw['task_str'])
+
+    def _requeue(self, kw):
+        self.redis_db_frame.rpush(self._queue_name, JsonUtils.to_json_str(kw['body']))
+
+    def _shedual_task(self):
+        lua = '''
+                     local v = redis.call("lpop", KEYS[1])
+                     if v then
+                     redis.call('zadd',KEYS[2],ARGV[1],v)
+                      end
+                     return v
+                '''
+        script = self.redis_db_frame.register_script(lua)
+        while True:
+            return_v = script(keys=[self._queue_name, self._unack_zset_name], args=[time.time()])
+            if return_v:
+                task_str = return_v
+                kw = {'body': task_str, 'task_str': task_str}
+                self._submit_task(kw)
+            else:
+                time.sleep(0.1)
+
+    def _requeue_tasks_which_unconfirmed(self):
+        """不使用这种方案，不适合本来来就需要长耗时的函数，很死板"""
+        # 防止在多个进程或多个机器中同时做扫描和放入未确认消费的任务。使用个分布式锁。
+        lock_key = f'funboost_lock__requeue_tasks_which_unconfirmed_timeout:{self._queue_name}'
+        with RedisDistributedLockContextManager(self.redis_db_frame, lock_key, ) as lock:
+            if lock.has_aquire_lock:
+                time_max = time.time() - self._ack_timeout
+                for value in self.redis_db_frame.zrangebyscore(self._unack_zset_name, 0, time_max):
+                    self.logger.warning(f'超过了 {self._ack_timeout} 秒未能确认消费, 向 {self._queue_name} 队列重新放入未消费确认的任务 {value} ,')
+                    self._requeue({'body': value})
+                    self.redis_db_frame.zrem(self._unack_zset_name, value)
+                if time.time() - self._last_show_unack_ts > 600:  # 不要频繁提示打扰
+                    self.logger.info(f'{self._unack_zset_name} 中有待确认消费任务的数量是'
+                                     f' {self.redis_db_frame.zcard(self._unack_zset_name)}')
+                    self._last_show_unack_ts = time.time()

{funboost-44.4 → funboost-44.5}/funboost/consumers/redis_consumer_simple.py

@@ -17,7 +17,6 @@ class RedisConsumer(AbstractConsumer, RedisMixin):
         while True:
             result = self.redis_db_frame.blpop(self._queue_name,timeout=60)
             if result:
-
                 kw = {'body': result[1]}
                 self._submit_task(kw)
 

{funboost-44.4 → funboost-44.5}/funboost/contrib/api_publish_msg.py

@@ -1,7 +1,7 @@
 import traceback
 import typing
 
-from funboost import AioAsyncResult, AsyncResult
+from funboost import AioAsyncResult, AsyncResult,PriorityConsumingControlConfig
 
 from funboost.core.cli.discovery_boosters import BoosterDiscovery
 from funboost import BoostersManager
@@ -39,11 +39,12 @@ async def publish_msg(msg_item: MsgItem):
         if msg_item.need_result:
             if booster.boost_params.is_using_rpc_mode is False:
                 raise ValueError(f' need_result 为true,{booster.queue_name} 队列消费者 需要@boost设置支持rpc模式')
-            async_result = booster.publish(msg_item.msg_body)
+            async_result = await booster.aio_publish(msg_item.msg_body,priority_control_config=PriorityConsumingControlConfig(is_using_rpc_mode=True))
             status_and_result = await AioAsyncResult(async_result.task_id, timeout=msg_item.timeout).status_and_result
+            print(status_and_result)
             # status_and_result = AsyncResult(async_result.task_id, timeout=msg_item.timeout).status_and_result
         else:
-            booster.publish(msg_item.msg_body)
+            await booster.aio_publish(msg_item.msg_body)
         return PublishResponse(succ=True, msg=f'{msg_item.queue_name} 队列,消息发布成功', status_and_result=status_and_result)
     except Exception as e:
         return PublishResponse(succ=False, msg=f'{msg_item.queue_name} 队列,消息发布失败 {type(e)} {e} {traceback.format_exc()}',

{funboost-44.4 → funboost-44.5}/funboost/factories/broker_kind__publsiher_consumer_type_map.py

@@ -1,5 +1,6 @@
 import typing
 
+
 from funboost.publishers.http_publisher import HTTPPublisher
 from funboost.publishers.nats_publisher import NatsPublisher
 from funboost.publishers.peewee_publisher import PeeweePublisher
@@ -48,6 +49,7 @@ from funboost.consumers.udp_consumer import UDPConsumer
 from funboost.consumers.zeromq_consumer import ZeroMqConsumer
 from funboost.consumers.mqtt_consumer import MqttConsumer
 from funboost.consumers.httpsqs_consumer import HttpsqsConsumer
+from funboost.consumers.redis_consumer_ack_using_timeout import RedisConsumerAckUsingTimeout
 
 from funboost.publishers.base_publisher import AbstractPublisher
 from funboost.consumers.base_consumer import AbstractConsumer
@@ -77,6 +79,7 @@ broker_kind__publsiher_consumer_type_map = {
     BrokerEnum.TXT_FILE: (TxtFilePublisher, TxtFileConsumer),
     BrokerEnum.PEEWEE: (PeeweePublisher, PeeweeConsumer),
     BrokerEnum.REDIS_PUBSUB: (RedisPubSubPublisher, RedisPbSubConsumer),
+    BrokerEnum.REIDS_ACK_USING_TIMEOUT: (RedisPublisher, RedisConsumerAckUsingTimeout),
 
 }
 
@@ -163,8 +166,6 @@ def regist_to_funboost(broker_kind: str):
         register_custom_broker(broker_kind, NsqPublisher, NsqConsumer)
 
 
-
-
 if __name__ == '__main__':
     import sys
 

{funboost-44.4 → funboost-44.5}/funboost/utils/decorators.py

@@ -332,6 +332,7 @@ class RedisDistributedLockContextManager(LoggerMixin, LoggerLevelSetterMixin):
         self._expire_seconds = expire_seconds
         self.identifier = str(uuid.uuid4())
         self.has_aquire_lock = False
+        self.logger.setLevel(logging.INFO)
 
     def __enter__(self):
         self._line = sys._getframe().f_back.f_lineno  # 调用此方法的代码的函数

{funboost-44.4 → funboost-44.5}/funboost/utils/dependency_packages_in_pythonpath/aioredis/__init__.py

@@ -1,59 +1,59 @@
-from aioredis.client import Redis, StrictRedis
-from aioredis.connection import (
-    BlockingConnectionPool,
-    Connection,
-    ConnectionPool,
-    SSLConnection,
-    UnixDomainSocketConnection,
-)
-from aioredis.exceptions import (
-    AuthenticationError,
-    AuthenticationWrongNumberOfArgsError,
-    BusyLoadingError,
-    ChildDeadlockedError,
-    ConnectionError,
-    DataError,
-    InvalidResponse,
-    PubSubError,
-    ReadOnlyError,
-    RedisError,
-    ResponseError,
-    TimeoutError,
-    WatchError,
-)
-from aioredis.utils import from_url
-
-
-def int_or_str(value):
-    try:
-        return int(value)
-    except ValueError:
-        return value
-
-
-__version__ = "2.0.1"
-VERSION = tuple(map(int_or_str, __version__.split(".")))
-
-__all__ = [
-    "AuthenticationError",
-    "AuthenticationWrongNumberOfArgsError",
-    "BlockingConnectionPool",
-    "BusyLoadingError",
-    "ChildDeadlockedError",
-    "Connection",
-    "ConnectionError",
-    "ConnectionPool",
-    "DataError",
-    "from_url",
-    "InvalidResponse",
-    "PubSubError",
-    "ReadOnlyError",
-    "Redis",
-    "RedisError",
-    "ResponseError",
-    "SSLConnection",
-    "StrictRedis",
-    "TimeoutError",
-    "UnixDomainSocketConnection",
-    "WatchError",
-]
+from aioredis.client import Redis, StrictRedis
+from aioredis.connection import (
+    BlockingConnectionPool,
+    Connection,
+    ConnectionPool,
+    SSLConnection,
+    UnixDomainSocketConnection,
+)
+from aioredis.exceptions import (
+    AuthenticationError,
+    AuthenticationWrongNumberOfArgsError,
+    BusyLoadingError,
+    ChildDeadlockedError,
+    ConnectionError,
+    DataError,
+    InvalidResponse,
+    PubSubError,
+    ReadOnlyError,
+    RedisError,
+    ResponseError,
+    TimeoutError,
+    WatchError,
+)
+from aioredis.utils import from_url
+
+
+def int_or_str(value):
+    try:
+        return int(value)
+    except ValueError:
+        return value
+
+
+__version__ = "2.0.1"
+VERSION = tuple(map(int_or_str, __version__.split(".")))
+
+__all__ = [
+    "AuthenticationError",
+    "AuthenticationWrongNumberOfArgsError",
+    "BlockingConnectionPool",
+    "BusyLoadingError",
+    "ChildDeadlockedError",
+    "Connection",
+    "ConnectionError",
+    "ConnectionPool",
+    "DataError",
+    "from_url",
+    "InvalidResponse",
+    "PubSubError",
+    "ReadOnlyError",
+    "Redis",
+    "RedisError",
+    "ResponseError",
+    "SSLConnection",
+    "StrictRedis",
+    "TimeoutError",
+    "UnixDomainSocketConnection",
+    "WatchError",
+]