funboost 42.3__tar.gz → 42.6__tar.gz

{funboost-42.3/funboost.egg-info → funboost-42.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 42.3
+Version: 42.6
 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

{funboost-42.3 → funboost-42.6}/funboost/__init__.py

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

{funboost-42.3 → funboost-42.6}/funboost/consumers/base_consumer.py

@@ -44,7 +44,7 @@ from apscheduler.executors.pool import ThreadPoolExecutor as ApschedulerThreadPo
 from funboost.funboost_config_deafult import FunboostCommonConfig
 from funboost.concurrent_pool.single_thread_executor import SoloExecutor
 
-from funboost.core.function_result_status_saver import ResultPersistenceHelper, FunctionResultStatus
+from funboost.core.function_result_status_saver import ResultPersistenceHelper, FunctionResultStatus, RunStatus
 
 from funboost.core.helper_funs import delete_keys_and_return_new_dict, get_publish_time
 
@@ -524,10 +524,11 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             current_retry_times = 0
             function_only_params = delete_keys_and_return_new_dict(kw['body'])
             for current_retry_times in range(max_retry_times + 1):
+                current_function_result_status.run_times = current_retry_times + 1
+                current_function_result_status.run_status = RunStatus.running
+                self._result_persistence_helper.save_function_result_to_mongo(current_function_result_status)
                 current_function_result_status = self._run_consuming_function_with_confirm_and_retry(kw, current_retry_times=current_retry_times,
-                                                                                                     function_result_status=FunctionResultStatus(
-                                                                                                         self.queue_name, self.consuming_function.__name__,
-                                                                                                         kw['body']))
+                                                                                                     function_result_status=current_function_result_status)
                 if (current_function_result_status.success is True or current_retry_times == max_retry_times
                         or current_function_result_status._has_requeue
                         or current_function_result_status._has_to_dlx_queue
@@ -538,7 +539,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                         time.sleep(self.consumer_params.retry_interval)
             if not (current_function_result_status._has_requeue and self.BROKER_KIND in [BrokerEnum.RABBITMQ_AMQPSTORM, BrokerEnum.RABBITMQ_PIKA, BrokerEnum.RABBITMQ_RABBITPY]):  # 已经nack了，不能ack，否则rabbitmq delevar tag 报错
                 self._confirm_consume(kw)
-
+            current_function_result_status.run_status = RunStatus.finish
             self._result_persistence_helper.save_function_result_to_mongo(current_function_result_status)
             if self._get_priority_conf(kw, 'do_task_filtering'):
                 self._redis_filter.add_a_value(function_only_params)  # 函数执行成功后，添加函数的参数排序后的键值对字符串到set中。
@@ -597,7 +598,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         function_only_params = delete_keys_and_return_new_dict(kw['body']) if self._do_not_delete_extra_from_msg is False else kw['body']
         task_id = kw['body']['extra']['task_id']
         t_start = time.time()
-        function_result_status.run_times = current_retry_times + 1
+        # function_result_status.run_times = current_retry_times + 1
         try:
             function_run = self.consuming_function
             if self._consuming_function_is_asyncio:
@@ -679,20 +680,20 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             current_retry_times = 0
             function_only_params = delete_keys_and_return_new_dict(kw['body'])
             for current_retry_times in range(max_retry_times + 1):
+                current_function_result_status.run_times = current_retry_times + 1
+                current_function_result_status.run_status = RunStatus.running
+                self._result_persistence_helper.save_function_result_to_mongo(current_function_result_status)
                 current_function_result_status = await self._async_run_consuming_function_with_confirm_and_retry(kw, current_retry_times=current_retry_times,
-                                                                                                                 function_result_status=FunctionResultStatus(
-                                                                                                                     self.queue_name, self.consuming_function.__name__,
-                                                                                                                     kw['body'], ),
-                                                                                                                 )
+                                                                                                                 function_result_status=current_function_result_status )
                 if current_function_result_status.success is True or current_retry_times == max_retry_times or current_function_result_status._has_requeue:
                     break
                 else:
                     if self.consumer_params.retry_interval:
                         await asyncio.sleep(self.consumer_params.retry_interval)
 
-            # self._result_persistence_helper.save_function_result_to_mongo(function_result_status)
             if not (current_function_result_status._has_requeue and self.BROKER_KIND in [BrokerEnum.RABBITMQ_AMQPSTORM, BrokerEnum.RABBITMQ_PIKA, BrokerEnum.RABBITMQ_RABBITPY]):
                 await simple_run_in_executor(self._confirm_consume, kw)
+            current_function_result_status.run_status = RunStatus.finish
             await simple_run_in_executor(self._result_persistence_helper.save_function_result_to_mongo, current_function_result_status)
             if self._get_priority_conf(kw, 'do_task_filtering'):
                 # self._redis_filter.add_a_value(function_only_params)  # 函数执行成功后，添加函数的参数排序后的键值对字符串到set中。

{funboost-42.3 → funboost-42.6}/funboost/core/booster.py

@@ -4,7 +4,8 @@ import os
 import types
 import typing
 
-from funboost.core.loggers import flogger, develop_logger,logger_prompt
+from funboost.utils.ctrl_c_end import ctrl_c_recv
+from funboost.core.loggers import flogger, develop_logger, logger_prompt
 
 from functools import wraps
 
@@ -12,9 +13,11 @@ from funboost.core.exceptions import BoostDecoParamsIsOldVersion
 from funboost.core.func_params_model import BoosterParams, FunctionResultStatusPersistanceConfig, PriorityConsumingControlConfig
 
 from funboost.factories.consumer_factory import get_consumer
+
 if typing.TYPE_CHECKING:
     from funboost.core.msg_result_getter import AsyncResult
 
+
 class Booster:
     """
     funboost极其重视代码能在pycharm下自动补全。元编程经常造成在pycharm下代码无法自动补全提示，主要是实现代码补全难。
@@ -117,7 +120,7 @@ class Booster:
                       priority_control_config: PriorityConsumingControlConfig = None) -> AsyncResult:
         """ 多进程安全的,在fork多进程(非spawn多进程)情况下,很多包跨线程/进程不能共享中间件连接,"""
         consumer = BoostersManager.get_or_create_booster_by_queue_name(self.queue_name).consumer
-        return  consumer.publisher_of_same_queue.publish(msg=msg, task_id=task_id, priority_control_config=priority_control_config)
+        return consumer.publisher_of_same_queue.publish(msg=msg, task_id=task_id, priority_control_config=priority_control_config)
 
     # noinspection PyMethodMayBeStatic
     def multi_process_consume(self, process_num=1):
@@ -250,3 +253,64 @@ class BoostersManager:
             flogger.info(f'创建booster {boost_params} {boost_params.consuming_function}')
             booster = Booster(boost_params)(boost_params.consuming_function)
         return booster
+
+    @classmethod
+    def push(cls, queue_name, *args, **kwargs):
+        """push发布消息到消息队列 ;
+        """
+        cls.get_or_create_booster_by_queue_name(queue_name).push(*args, **kwargs)
+
+    @classmethod
+    def publish(cls, queue_name, msg):
+        """publish发布消息到消息队列;
+        """
+        cls.get_or_create_booster_by_queue_name(queue_name).publish(msg)
+
+    @classmethod
+    def consume_queues(cls, *queue_names):
+        """
+        启动多个消息队列名的消费,多个函数队列在当前同一个进程内启动消费.
+        这种方式节约总的内存,但无法利用多核cpu
+        """
+        for queue_name in queue_names:
+            cls.get_booster(queue_name).consume()
+        ctrl_c_recv()
+
+    consume = consume_queues
+
+    @classmethod
+    def consume_all_queues(cls):
+        """
+        启动所有消息队列名的消费,无需一个一个函数亲自 funxx.consume()来启动,多个函数队列在当前同一个进程内启动消费.
+        这种方式节约总的内存,但无法利用多核cpu
+        """
+        for queue_name in cls.get_all_queues():
+            cls.get_booster(queue_name).consume()
+        ctrl_c_recv()
+
+    consume_all = consume_all_queues
+
+    @classmethod
+    def multi_process_consume_queues(cls, **queue_name__process_num):
+        """
+        启动多个消息队列名的消费,传递队列名和进程数,每个队列启动n个单独的消费进程;
+        这种方式总的内存使用高,但充分利用多核cpu
+        例如 multi_process_consume_queues(queue1=2,queue2=3) 表示启动2个进程消费queue1,启动3个进程消费queue2
+        """
+        for queue_name, process_num in queue_name__process_num.items():
+            cls.get_booster(queue_name).multi_process_consume(process_num)
+        ctrl_c_recv()
+
+    m_consume = multi_process_consume_queues
+
+    @classmethod
+    def multi_process_consume_all_queues(cls, process_num=1):
+        """
+        启动所有消息队列名的消费,无需指定队列名,每个队列启动n个单独的消费进程;
+        这种方式总的内存使用高,但充分利用多核cpu
+        """
+        for queue_name in cls.get_all_queues():
+            cls.get_booster(queue_name).multi_process_consume(process_num)
+        ctrl_c_recv()
+
+    m_consume_all = multi_process_consume_all_queues

{funboost-42.3 → funboost-42.6}/funboost/core/cli/discovery_boosters.py

@@ -6,7 +6,10 @@ from pathlib import Path
 import importlib.util
 # import nb_log
 from funboost.core.loggers import FunboostFileLoggerMixin
+from funboost.utils.decorators import flyweight
 
+
+@flyweight
 class BoosterDiscovery(FunboostFileLoggerMixin):
     def __init__(self, project_root_path: typing.Union[PathLike, str],
                  booster_dirs: typing.List[typing.Union[PathLike, str]],
@@ -23,6 +26,7 @@ class BoosterDiscovery(FunboostFileLoggerMixin):
         self.py_file_re_str = py_file_re_str
 
         self.py_files = []
+        self._has_discovery_import = False
 
     def get_py_files_recursively(self, current_folder_path: Path, current_depth=0, ):
         """先找到所有py文件"""
@@ -34,15 +38,20 @@ class BoosterDiscovery(FunboostFileLoggerMixin):
             elif item.suffix == '.py':
                 if self.py_file_re_str:
                     if re.search(self.py_file_re_str, str(item), ):
-                        self.py_files.append(item)
+                        self.py_files.append(str(item))
                 else:
-                    self.py_files.append(item)
+                    self.py_files.append(str(item))
         self.py_files = list(set(self.py_files))
-        for f in self.py_files:
-            self.logger.debug(f)
 
     def auto_discovery(self, ):
-        """把所有py文件自动执行import,主要是把 所有的@boost函数装饰器注册到 pid_queue_name__booster_map 中"""
+        """把所有py文件自动执行import,主要是把 所有的@boost函数装饰器注册到 pid_queue_name__booster_map 中
+        这个auto_discovery方法最好放到main里面,如果要扫描自身文件夹,没写正则排除文件本身,会无限懵逼死循环导入,无无限懵逼死循环导入
+        """
+        if self._has_discovery_import is False:
+            self._has_discovery_import = True
+        else:
+            pass
+            return  # 这一个判断是避免用户执行BoosterDiscovery.auto_discovery没有放到 if __name__ == '__main__'中,导致无限懵逼死循环.
         self.logger.info(self.booster__full_path_dirs)
         for dir in self.booster__full_path_dirs:
             if not Path(dir).exists():
@@ -50,6 +59,10 @@ class BoosterDiscovery(FunboostFileLoggerMixin):
 
             self.get_py_files_recursively(Path(dir))
             for file_path in self.py_files:
+                self.logger.debug(f'导入模块 {file_path}')
+                if Path(file_path) == Path(sys._getframe(1).f_code.co_filename):
+                    self.logger.warning(f'排除导入调用auto_discovery的模块自身 {file_path}')  # 否则下面的import这个文件,会造成无限懵逼死循环
+                    continue
                 spec = importlib.util.spec_from_file_location('module', file_path)
                 module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(module)

{funboost-42.3 → funboost-42.6}/funboost/core/cli/funboost_cli_user_templ.py

@@ -30,12 +30,10 @@ from funboost.core.cli.discovery_boosters import BoosterDiscovery
 '''
 env_dict['project_root_path'] = project_root_path
 
-# booster_dirs 用户可以自己增加扫描的文件夹,这样可以命令行少传了 --booster_dirs_str
-# BoosterDiscovery 可以多吃调用
-BoosterDiscovery(project_root_path, booster_dirs=[], max_depth=1,py_file_re_str=None).auto_discovery()
-
-
 if __name__ == '__main__':
+    # booster_dirs 用户可以自己增加扫描的文件夹,这样可以命令行少传了 --booster_dirs_str
+    # BoosterDiscovery 可以多次调用
+    BoosterDiscovery(project_root_path, booster_dirs=[], max_depth=1, py_file_re_str=None).auto_discovery()  # 这个最好放到main里面,如果要扫描自身文件夹,没写正则排除文件本身,会无限懵逼死循环导入
     fire.Fire(BoosterFire, )
 
 '''

{funboost-42.3 → funboost-42.6}/funboost/core/cli/funboost_fire.py

@@ -49,87 +49,81 @@ class BoosterFire(object):
         清空多个queue ; 例子: clear test_cli1_queue1  test_cli1_queue2   # 清空2个消息队列消息队列
         """
 
-        for queue_anme in queue_names:
-            BoostersManager.get_booster(queue_anme).clear()
+        for queue_name in queue_names:
+            BoostersManager.get_booster(queue_name).clear()
         return self
 
-    def push(self, queue_anme, *args, **kwargs):
+    def push(self, queue_name, *args, **kwargs):
         """push发布消息到消息队列 ;
         例子: 假设函数是 def  add(x,y)  队列名是 add_queue , 发布 1 + 2求和;
         push add_queue 1 2;
         或者 push add_queue --x=1 --y=2;
         或者 push add_queue -x 1 -y 2;
         """
-        BoostersManager.get_booster(queue_anme).push(*args, **kwargs)
+        BoostersManager.push(queue_name,*args, **kwargs)
         return self
 
     def __str__(self):
         # print('over')  # 这行重要,否则命令行链式调用无法自动结束
         return ''
 
-    def publish(self, queue_anme, msg):
+    def publish(self, queue_name, msg):
         """publish发布消息到消息队列;
            假设函数是 def  add(x,y)  队列名是 add_queue , 发布 1 + 2求和;
            publish add_queue "{'x':1,'y':2}"
         """
 
-        BoostersManager.get_booster(queue_anme).publish(msg)
+        BoostersManager.publish(queue_name,msg)
         return self
 
-    def consume(self, *queue_names: str):
+    def consume_queues(self, *queue_names: str):
         """
         启动多个消息队列名的消费;
         例子: consume queue1 queue2
         """
-        for queue_anme in queue_names:
-            BoostersManager.get_booster(queue_anme).consume()
-        ctrl_c_recv()
+        BoostersManager.consume_queues(*queue_names)
 
-    def consume_all_queues(self,):
+    consume = consume_queues
+
+    def consume_all_queues(self, ):
         """
         启动所有消息队列名的消费,无需指定队列名;
         例子: consume_all_queues
         """
-        for queue_anme in BoostersManager.get_all_queues():
-            BoostersManager.get_booster(queue_anme).consume()
-        ctrl_c_recv()
+        BoostersManager.consume_all_queues()
 
     consume_all = consume_all_queues
 
-    def multi_process_consume_all_queues(self,process_num=1):
+    def multi_process_consume_queues(self, **queue_name__process_num):
         """
-        启动所有消息队列名的消费,无需指定队列名,每个队列启动n个单独的消费进程;
-        例子: multi_process_consume_all_queues 2
+        使用多进程启动消费,每个队列开启多个单独的进程消费;
+        例子:  m_consume --queue1=2 --queue2=3    # queue1启动两个单独进程消费  queue2 启动3个单独进程消费
         """
-        for queue_anme in BoostersManager.get_all_queues():
-            BoostersManager.get_booster(queue_anme).multi_process_consume(process_num)
-        ctrl_c_recv()
+        BoostersManager.multi_process_consume_queues(**queue_name__process_num)
 
-    m_consume_all = multi_process_consume_all_queues
+    m_consume = multi_process_consume_queues
 
-    def multi_process_consume(self, **queue_name__process_num):
+    def multi_process_consume_all_queues(self, process_num=1):
         """
-        使用多进程启动消费,每个队列开启多个单独的进程消费;
-        例子:  m_consume --queue1=2 --queue2=3    # queue1启动两个单独进程消费  queue2 启动3个单独进程消费
+        启动所有消息队列名的消费,无需指定队列名,每个队列启动n个单独的消费进程;
+        例子: multi_process_consume_all_queues 2
         """
-        for queue_anme, process_num in queue_name__process_num.items():
-            BoostersManager.get_booster(queue_anme).multi_process_consume(process_num)
-        ctrl_c_recv()
+        BoostersManager.multi_process_consume_all_queues(process_num)
 
-    m_consume = multi_process_consume
+    m_consume_all = multi_process_consume_all_queues
 
     def pause(self, *queue_names: str):
         """
         暂停多个消息队列名的消费;
         例子: pause queue1 queue2
         """
-        for queue_anme in queue_names:
-            BoostersManager.get_booster(queue_anme).pause()
+        for queue_name in queue_names:
+            BoostersManager.get_booster(queue_name).pause()
 
     def continue_consume(self, *queue_names: str):
         """
         继续多个消息队列名的消费;
         例子: continue_consume queue1 queue2
         """
-        for queue_anme in queue_names:
-            BoostersManager.get_booster(queue_anme).continue_consume()
+        for queue_name in queue_names:
+            BoostersManager.get_booster(queue_name).continue_consume()

{funboost-42.3 → funboost-42.6}/funboost/core/function_result_status_saver.py

@@ -20,6 +20,9 @@ from funboost.utils.mongo_util import MongoMixin
 # from nb_log import LoggerMixin
 from funboost.core.loggers import FunboostFileLoggerMixin
 
+class RunStatus:
+    running = 'running'
+    finish = 'finish'
 
 class FunctionResultStatus():
     host_name = socket.gethostname()
@@ -51,6 +54,7 @@ class FunctionResultStatus():
         self.time_cost = None
         self.time_end = None
         self.success = False
+        self.run_status = ''
         self.total_thread = threading.active_count()
         self._has_requeue = False
         self._has_to_dlx_queue = False
@@ -59,11 +63,14 @@ class FunctionResultStatus():
 
     def get_status_dict(self, without_datetime_obj=False):
         self.time_end = time.time()
-        self.time_cost = round(self.time_end - self.time_start, 3)
-        item ={}
-        for k,v in self.__dict__.items():
+        if self.run_status == RunStatus.running:
+            self.time_cost = None
+        else:
+            self.time_cost = round(self.time_end - self.time_start, 3)
+        item = {}
+        for k, v in self.__dict__.items():
             if not k.startswith('_'):
-                item[k] =v
+                item[k] = v
         item['host_name'] = self.host_name
         item['host_process'] = self.host_process
         item['script_name'] = self.script_name

{funboost-42.3 → funboost-42.6}/funboost/function_result_web/app.py

@@ -119,7 +119,7 @@ def query_cols_view():
 @app.route('/query_result')
 @login_required
 def query_result_view():
-    nb_print(request.values.to_dict())
+
     return jsonify(query_result(**request.values.to_dict()))
 
 
@@ -142,7 +142,7 @@ if __name__ == '__main__':
     # with app.test_request_context():
     #     print(url_for('query_cols_view'))
 
-    app.run(debug=False, threaded=True, host='0.0.0.0', port=27018)
+    app.run(debug=False, threaded=True, host='0.0.0.0', port=27019)
 
     '''
     linux 是export , win是 set

{funboost-42.3 → funboost-42.6}/funboost/function_result_web/functions.py

@@ -6,7 +6,7 @@ import json
 from pprint import pprint
 import time
 from flask import jsonify
-
+import copy
 from funboost import nb_print
 from funboost.utils import time_util, decorators, LoggerMixin
 from funboost.utils.mongo_util import MongoMixin
@@ -36,6 +36,10 @@ def get_cols(col_name_search: str):
 
 
 def query_result(col_name, start_time, end_time, is_success, function_params: str, page, ):
+    query_kw = copy.copy(locals())
+    t0 = time.time()
+    if not col_name:
+        return []
     db = MongoMixin().mongo_db_task_status
     condition = {
         'insert_time': {'$gt': time_util.DatetimeConverter(start_time).datetime_obj,
@@ -56,7 +60,8 @@ def query_result(col_name, start_time, end_time, is_success, function_params: st
     # results = list(db.get_collection(col_name).find(condition, ).sort([('insert_time', -1)]).skip(int(page) * 100).limit(100))
     # with decorators.TimerContextManager():
     results = list(db.get_collection(col_name).find(condition, {'insert_time': 0, 'utime': 0}).skip(int(page) * 100).limit(100))
-    # nb_print(result)
+    # nb_print(results)
+    nb_print(time.time() -t0, query_kw)
     return results
 
 
@@ -73,8 +78,8 @@ def get_speed(col_name, start_time, end_time):
     with decorators.TimerContextManager():
         # success_num = db.get_collection(col_name).count({**{'success': True}, **condition})
         # fail_num = db.get_collection(col_name).count({**{'success': False}, **condition})
-        success_num = db.get_collection(col_name).count_documents({**{'success': True}, **condition})
-        fail_num = db.get_collection(col_name).count_documents({**{'success': False}, **condition})
+        success_num = db.get_collection(col_name).count_documents({**{'success': True,'run_status':'finish'}, **condition})
+        fail_num = db.get_collection(col_name).count_documents({**{'success': False,'run_status':'finish'}, **condition})
         qps = (success_num + fail_num) / (time_util.DatetimeConverter(end_time).timestamp - time_util.DatetimeConverter(start_time).timestamp)
         return {'success_num': success_num, 'fail_num': fail_num, 'qps': round(qps, 1)}
 

{funboost-42.3 → funboost-42.6}/funboost/function_result_web/templates/index.html

@@ -123,7 +123,8 @@
 
 
     </main><!-- page-content" --></div><!-- page-wrapper -->
-<script src="{{ url_for('static',filename='js/jquery-1.11.0.min.js') }}" type="text/javascript"></script>
+<!--<script src="{{ url_for('static',filename='js/jquery-1.11.0.min.js') }}" type="text/javascript"></script>-->
+<script src="https://cdn.bootcdn.net/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
 <script src="http://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
 
 
@@ -163,6 +164,7 @@
         return year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second;
     }
 
+
     //昨天的时间
     var day1 = new Date();
     day1.setDate(day1.getDate() - 2);
@@ -220,16 +222,19 @@
                 var html = '  <thead>\n' +
                     '                    <tr>\n' +
                     '                        <th>执行机器-进程-脚本</th>\n' +
-                    '                        <th>函数执行完成时间</th>\n' +
+
                     '                        <th>函数名称</th>\n' +
                     '                        <th>函数入参</th>\n' +
                     '                        <th>函数结果</th>\n' +
-                    '                        <th>消耗时间</th>\n' +
-                    '                        <th>执行次数</th>\n' +
+                    '                        <th>消息发布时间</th>\n' +
+                    '                        <th>开始执行时间</th>\n' +
+                    '                        <th>消耗时间(秒)</th>\n' +
+                    '                        <th>执行次数(重试)</th>\n' +
+                    '                        <th>运行状态</th>\n' +
                     '                        <th>是否成功</th>\n' +
                     '                        <th>错误原因</th>\n' +
 
-                    '                        <th>消息发布时间</th>\n' +
+
                     '                        <th>线程(协程)数</th>\n' +
                     '                    </tr>\n' +
                     '                    </thead>' +
@@ -257,11 +262,25 @@
                         '                        <td>{9}</td>\n' +
                         '                        <td>{10}</td>\n' +
                         '                        <td>{11}</td>\n' +
+                        '                        <td>{12}</td>\n' +
 
                         '                    </tr>';
                     var successText = item.success === true ? "成功" : "失败";
-                    tr = tr.format(displayLevel, item.host_process + ' - ' + item.script_name, item.insert_time_str, item.function, item.params_str, item.result,
-                        item.time_cost, item.run_times, successText, item.exception, item.publish_time_str, item.total_thread);
+<!--                    console.info(item.run_status);-->
+                    var run_status_text = item.run_status;
+                    if (item.run_status==="running"){
+                        successText = "未完成";
+                        displayLevel = "info";
+                        if ( Date.now() /1000 - item.time_start > 600) {
+                            run_status_text = "running?";
+                        }
+                    }
+
+                    var time_start_obj = new Date(item.time_start * 1000);
+                    var time_start_str = dateToString(time_start_obj);
+
+                    tr = tr.format(displayLevel, item.host_process + ' - ' + item.script_name,  item.function, item.params_str, item.result,item.publish_time_str,
+                        time_start_str,item.time_cost, item.run_times, run_status_text,successText, item.exception, item.total_thread);
                     html += tr;
                 }
                 html += '</tbody>';

{funboost-42.3 → funboost-42.6}/funboost/publishers/base_publisher.py

@@ -223,6 +223,13 @@ class AbstractPublisher(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                 self._init_count()
         return AsyncResult(task_id)
 
+    def send_msg(self,msg:typing.Union[dict,str]):
+        """直接发送任意消息内容到消息队列,不生成辅助参数,无视函数入参名字,不校验入参个数和键名"""
+        if isinstance(msg,dict):
+            msg = json.dumps(msg, ensure_ascii=False)
+        decorators.handle_exception(retry_times=10, is_throw_error=True, time_sleep=0.1)(
+            self.concrete_realization_of_publish)(msg)
+
     def push(self, *func_args, **func_kwargs):
         """
         简写，只支持传递消费函数的本身参数，不支持priority_control_config参数。

{funboost-42.3 → funboost-42.6/funboost.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 42.3
+Version: 42.6
 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