def add_plugin(cls, class_obj):
"""
添加插件
@param {object} class_obj - 插件类
"""
# 获取插件字典
_plugins = RunTool.get_global_var(PIPELINE_PLUGINS_VAR_NAME)
if _plugins is None:
_plugins = {'processer': dict(), 'router': dict()}
RunTool.set_global_var(PIPELINE_PLUGINS_VAR_NAME, _plugins)
# 判断类型
_type_fun = getattr(class_obj, 'processer_name', None)
_plugin_type = 'processer'
if _type_fun is None or not callable(_type_fun):
_type_fun = getattr(class_obj, 'router_name', None)
_plugin_type = 'router'
if _type_fun is None or not callable(_type_fun):
# 不是标准插件类
return
# 执行初始化
class_obj.initialize()
# 放入插件配置
_plugins[_plugin_type][_type_fun()] = class_obj
def __bg_thread_fun(self):
"""
后台输出的线程执行函数
"""
self._is_bg_thread_running = True
while(True):
print('__bg_thread_fun')
try:
if self._bg_thread_stop:
# 收到停止标志，结束线程处理，注意如果wait_write_end_when_asyn参数为True，则需要写完
if not self._wait_write_end_when_asyn or self._buffer.empty():
break
# 尝试从队列获取要写的对象
if self._buffer.empty():
# 没有数据，下一次循环
RunTool.sleep(0.1)
else:
data = self._buffer.get(False)
self.__write(data)
except Exception:
# 执行出现异常时不退出处理
RunTool.sleep(0.1)
continue
# 线程自然消亡
self._is_bg_thread_running = False
def debug_print(*args, **kwargs):
"""
打印调试信息，可打印传入的多个对象
"""
DEBUG_TOOLS_SWITCH_ON = RunTool.get_global_var('DEBUG_TOOLS_SWITCH_ON')
if DEBUG_TOOLS_SWITCH_ON is None:
DEBUG_TOOLS_SWITCH_ON = False
DEBUG_TOOLS_LOGGER = RunTool.get_global_var('DEBUG_TOOLS_LOGGER')
if not DEBUG_TOOLS_SWITCH_ON:
# 未启动调试
return
# 输出打印信息，先准备整体信息
_print_info = u'[%s][%s][行:%s]DEBUG INFO:\n%s' % (
os.path.split(
os.path.realpath(
sys._getframe().f_back.f_code.co_filename)
)[1],
sys._getframe().f_back.f_code.co_name,
sys._getframe().f_back.f_lineno,
'\n'.join(DebugTool.__get_print_str_seq(args, kwargs))
)
DEBUG_TOOLS_LOGGER.debug(_print_info)
def func_case1_no_para_with_cresult():
RunTool.get_global_logger().log(simple_log.INFO,
'runing func_case1_no_para_with_cresult')
time.sleep(0.001)
_ret = CResult()
_ret.self_para = [3, 'str']
return _ret
def pause(self, run_id: str = None):
"""
暂停管道执行
@param {str} run_id=None - 要暂停的管道运行ID
注：如果不传入则获取最后执行的管道ID
"""
if not self.is_asyn:
# 非异步模式不支持
raise RuntimeError("Pipeline is not asynchronous!")
_run_id, _run_cache = self._get_run_cache(run_id)
if _run_cache is None:
raise RuntimeError("Run id not exists!")
if _run_cache['status'] != 'R':
_msg = 'Pipeline [%s] not running!' % self.name
self.log_error('Error: ' % _msg)
raise RuntimeError(_msg)
# 只要设置管道状态为 P 即可
self._set_status('P', run_id=_run_id)
if self.pipeline[_run_cache['node_id']].get('is_sub_pipeline', False):
# 正在执行子管道, 对子管道也添加暂停的指令
try:
self.running_sub_pipeline[_run_id].pause(run_id=_run_id)
except:
pass
while _run_cache['thread_running']:
# 等待运行线程结束
RunTool.sleep(0.01)
# 记录日志
self.log_info('Pipeline [%s] pause!' % self.name)
def test_JadeTypeDetect():
"""
测试翡翠类型处理器
"""
_execute_path = RunTool.get_global_var('EXECUTE_PATH')
_pipeline = RunTool.get_global_var('EMPTY_PIPELINE')
_processer_class: PipelineProcesser = Pipeline.get_plugin('processer', 'JadeTypeDetect')
_filelist = FileTool.get_filelist(
os.path.join(_execute_path, os.path.pardir, 'test_data/test_pic/'),
is_fullname=True
)
for _file in _filelist:
# 遍历执行
with open(_file, 'rb') as _fid:
_file_bytes = _fid.read()
_input = {
'type': '',
'sub_type': '',
'image': Image.open(_file_bytes),
'score': 0.0
}
_output = _processer_class.execute(_input, {}, _pipeline)
# 输出图片和对应文字
_image = _output['image']
_print_str = 'type: %s\nsub_type: %s\nscore: %s' % (
_output['type'], _output['sub_type'], str(_output['score']))
_draw = ImageDraw.Draw(_image) # PIL图片上打印汉字
# 参数1：字体文件路径，参数2：字体大小；Windows系统“simhei.ttf”默认存储在路径：C:\Windows\Fonts中
_font = ImageFont.truetype("simhei.ttf", 20, encoding="utf-8")
_draw.text((0, 0), _print_str, (255, 0, 0), font=_font)
plt.figure(_file)
plt.imshow(_image)
plt.show()
def stop_stream(self, stream_tag='default', is_wait=True):
"""
关闭指定标签的流处理
@param {string} stream_tag='default' - 需要关闭的流处理标签
@param {bool} is_wait=True - 是否等待流关闭后再返回
@throws {AttributeError} - 当keep_wait_data为False时，会自动关闭流，调用本方法应直接抛出异常
@throws {KeyError} - 当传入的流标识不存在时抛出该异常
"""
self._stream_list_lock.acquire()
try:
if not self._keep_wait_data:
# 自动关闭流，参数无效
raise AttributeError(u'流参数为自动关闭，不允许手工关闭')
if stream_tag not in self._stream_list.keys():
# 流标识不存在
raise KeyError(u'处理标识不存在')
# 设置停止标签
self._stream_list_tag[stream_tag] = (
True, self._stream_list_tag[stream_tag][1])
finally:
self._stream_list_lock.release()
# 是否等待关闭后才返回
if is_wait:
while True:
if stream_tag not in self._stream_list.keys():
break
RunTool.sleep(0.01)
def setUpModule():
# print("test module start >>>>>>>>>>>>>>")
_i18n_obj = SimpleI18N(lang='zh_cn',
trans_file_path=_I18N_File_DIR,
trans_file_prefix='message',
auto_loads=True)
set_global_i18n(_i18n_obj)
RunTool.set_global_var('CONSOLE_GLOBAL_PARA', dict())
def set_global_i18n(i18n_obj):
"""
设置通用的SimpleI18N实例对象
@param {object} i18n_obj - SimpleI18N实例对象
"""
RunTool.set_global_var('SIMPLE_I18N_GLOBAL_OBJECT', i18n_obj)
def index():
"""
主页执行函数
"""
global RANDOM_STR
RunTool.sleep(1) # 阻塞1秒
print('resp: ' + RANDOM_STR)
return RANDOM_STR
def func_case1_call_2(a, b, c, **kwargs):
RunTool.get_global_logger().log(
simple_log.INFO, 'runing func_case1_call_2 : a=%s, b=%s, c=%s: %s' %
(str(a), str(b), str(c), str(kwargs)))
time.sleep(0.001)
# 执行4
func_case1_call_4('4a', '4b', '4c', k1=kwargs['k1'])
return
def start_server(self, is_wait=False):
"""
启动服务
注意服务必须处于停止状态才能启动
@param {bool} is_wait=False - 是否等待服务启动完成后再退出
@returns {CResult} - 启动结果，result.code：'00000'-成功，'21401'-服务不属于停止状态，不能启动，其他-异常
"""
_result = CResult(code='00000') # 成功
with ExceptionTool.ignored_cresult(
_result,
logger=self._logger,
self_log_msg='[%s-STARTING][NAME:%s]%s: ' %
(self._server_log_prefix, self._server_name,
_('start service error')),
force_log_level=logging.ERROR):
# 先获取锁，拿到最准确的服务状态
self.__server_run_status_lock.acquire()
try:
if self.__server_run_status != EnumServerRunStatus.Stop:
# 不属于停止状态，不能启动
_temp_result = CResult(code='21401') # 服务启动失败-服务已启动
self._logger.log(
self._log_level, '[%s-STARTING][NAME:%s]%s' %
(self._server_log_prefix, self._server_name,
_temp_result.msg))
return _temp_result
# 执行启动服务的动作，通过线程方式启动，避免调用方等待
self.__server_begin_time = datetime.datetime.now()
self._logger.log(
self._log_level, '[%s-STARTING][NAME:%s]%s' %
(self._server_log_prefix, self._server_name,
_('service starting')))
self._server_status_change(EnumServerRunStatus.WaitStart,
_result)
_server_thread = threading.Thread(
target=self.__start_server_thread_fun,
args=(1, ),
name='Thread-Server-Main')
_server_thread.setDaemon(True)
_server_thread.start()
finally:
# 释放锁
self.__server_run_status_lock.release()
# 返回结果,循环等待
while is_wait and self.__server_run_status == EnumServerRunStatus.WaitStart:
RunTool.sleep(0.01)
# 如果是等待模式，检查一次结果，如果没有正常运行返回最后一次启动结果
if is_wait:
if self.__server_run_status != EnumServerRunStatus.Running:
_result = self.__last_start_result
return _result
def mask_processer_initialize(cls, graph_var_name: str,
processer_name: str):
"""
对象识别掩码处理器的公共初始化函数
@param {str} graph_var_name - 对象识别冻结图全局变量名
@param {str} processer_name - 处理器名
"""
_graph = RunTool.get_global_var(graph_var_name)
if _graph is None:
_graph = dict()
RunTool.set_global_var(graph_var_name, _graph)
else:
# 模型已装载，无需继续处理
return
_execute_path = RunTool.get_global_var('EXECUTE_PATH')
if _execute_path is None:
_execute_path = os.getcwd()
_config = RunTool.get_global_var(
'PIPELINE_PROCESSER_PARA')[processer_name]
_pb_file = os.path.join(_execute_path, _config['frozen_graph'])
_pb_labelmap = os.path.join(_execute_path, _config['labelmap'])
# 识别基础参数
_graph['min_score'] = _config.get('min_score', 0.8)
_graph['labelmap'], _graph['other_id'] = Tools.load_labelmap(
_pb_labelmap, encoding=_config.get('encoding', 'utf-8'))
_mask_graph = tf.Graph()
with _mask_graph.as_default():
_od_graph_def = tf.GraphDef()
with tf.gfile.GFile(_pb_file, 'rb') as _fid:
_serialized_graph = _fid.read()
_od_graph_def.ParseFromString(_serialized_graph)
tf.import_graph_def(_od_graph_def, name='')
_ops = _mask_graph.get_operations()
_all_tensor_names = {
output.name
for op in _ops for output in op.outputs
}
_tensor_dict = {}
for key in [
'num_detections', 'detection_boxes', 'detection_scores',
'detection_classes', 'detection_masks'
]:
_tensor_name = key + ':0'
if _tensor_name in _all_tensor_names:
_tensor_dict[key] = _mask_graph.get_tensor_by_name(
_tensor_name)
_graph['session'] = tf.Session(graph=_mask_graph)
_graph['tensor_dict'] = _tensor_dict
_graph['image_tensor'] = _mask_graph.get_tensor_by_name(
'image_tensor:0')
def __del__(self):
"""
析构函数，删除对象时处理全局变量的删除
"""
_ROBOT_SELF_ROUTERS = RunTool.get_global_var('ROBOT_SELF_ROUTERS')
_ROBOT_SELF_ROUTERS.pop(self.robot_id, None)
_ROBOT_INFOS = RunTool.get_global_var('ROBOT_INFOS')
_ROBOT_INFOS.pop(self.robot_id, None)
def detect_processer_initialize(cls, graph_var_name: str,
processer_name: str):
"""
物体识别处理器的公共初始化函数
@param {str} graph_var_name - 对象识别冻结图全局变量名
@param {str} processer_name - 处理器名
"""
_graph = RunTool.get_global_var(graph_var_name)
if _graph is None:
_graph = dict()
RunTool.set_global_var(graph_var_name, _graph)
else:
# 模型已装载，无需继续处理
return
_execute_path = RunTool.get_global_var('EXECUTE_PATH')
if _execute_path is None:
_execute_path = os.getcwd()
_config = RunTool.get_global_var(
'PIPELINE_PROCESSER_PARA')[processer_name]
_pb_file = os.path.join(_execute_path, _config['frozen_graph'])
_pb_labelmap = os.path.join(_execute_path, _config['labelmap'])
# 识别基础参数
_graph['min_score'] = _config.get('min_score', 0.8)
_graph['labelmap'], _graph['other_id'] = Tools.load_labelmap(
_pb_labelmap, encoding=_config.get('encoding', 'utf-8'))
_detection_graph = tf.Graph()
with _detection_graph.as_default():
_od_graph_def = tf.GraphDef()
with tf.gfile.GFile(_pb_file, 'rb') as _fid:
_serialized_graph = _fid.read()
_od_graph_def.ParseFromString(_serialized_graph)
tf.import_graph_def(_od_graph_def, name='')
_graph['session'] = tf.Session(graph=_detection_graph)
# Input tensor is the image
_graph['image_tensor'] = _detection_graph.get_tensor_by_name(
'image_tensor:0')
# Output tensors are the detection boxes, scores, and classes
# Each box represents a part of the image where a particular object was detected
_graph['detection_boxes'] = _detection_graph.get_tensor_by_name(
'detection_boxes:0')
# Each score represents level of confidence for each of the objects.
# The score is shown on the result image, together with the class label.
_graph['detection_scores'] = _detection_graph.get_tensor_by_name(
'detection_scores:0')
_graph['detection_classes'] = _detection_graph.get_tensor_by_name(
'detection_classes:0')
# Number of objects detected
_graph['num_detections'] = _detection_graph.get_tensor_by_name(
'num_detections:0')
def start_server(**kwargs):
"""
启动聊天服务端应用
"""
SERVER_CONFIG = RunTool.get_global_var('SERVER_CONFIG')
_loader = QAServerLoader(SERVER_CONFIG, app=app)
RunTool.set_global_var('QA_LOADER', _loader)
# 启动服务
_loader.start_restful_server()
def func_case1_call_1(a, b, **kwargs):
RunTool.get_global_logger().log(
simple_log.INFO, 'runing func_case1_call_1 : a=%s, b=%s : %s' %
(str(a), str(b), str(kwargs)))
time.sleep(0.001)
# 执行2
func_case1_call_2('2a', '2b', '2c', k1=kwargs['k1'])
# 执行3
func_case1_call_3(k1=kwargs['k1'])
return
def _accept_one(self, server_opts, net_info):
"""
监听接受一个请求并返回
提供监听并获取到请求连接返回的方法；注意该该函数必须捕获并处理异常
@param {objcet} server_opts - 网络服务启动参数
@param {objcet} net_info - 网络连接信息对象，_start_server_without_accept中获取到的结果
@returns {CResult} - 获取网络连接结果:
result.code ：'00000'-成功，'20407'-获取客户端连接请求超时
result.net_info ：客户端连接信息对象，该对象将传给后续单个连接处理的线程
"""
# 子类必须定义该功能
_result = CResult('00000')
_result.net_info = None
with ExceptionTool.ignored_cresult(
_result,
logger=self._logger,
expect=(BlockingIOError),
expect_no_log=True, # 超时不记录日志
error_map={BlockingIOError: ('20407', None)},
self_log_msg='[LIS][NAME:%s]%s error: ' % (
self._server_name, _('accept client connect')),
force_log_level=None
):
# _sys_str = platform.system()
_csocket, _addr = net_info.csocket.accept() # 接收客户端连接，返回客户端和地址
_csocket.setblocking(False) # 将socket设置为非阻塞. 在创建socket对象后就进行该操作.
_result.net_info = NullObj()
_result.net_info.csocket = _csocket
_result.net_info.raddr = _addr
_result.net_info.laddr = _csocket.getsockname()
_result.net_info.send_timeout = server_opts.send_timeout
_result.net_info.recv_timeout = server_opts.recv_timeout
# 采用非阻塞模式处理数据，超时自行实现
"""
if (_sys_str == 'Windows'):
_csocket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, server_opts.recv_timeout)
_csocket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDTIMEO, server_opts.send_timeout)
else:
# linux 设置超时时间不同，需重新测试
_csocket.settimeout(server_opts.recv_timeout / 1000)
"""
self._logger.log(
self._log_level,
'[LIS][NAME:%s]%s: %s - %s' % (
self._server_name, _('accept one client connection'), str(_addr), str(_csocket)
)
)
if not _result.is_success():
# 出现异常，睡眠一段时间
RunTool.sleep(0.01)
return _result
def set_global_time_wait(cls, robot_info: dict, action_name: str,
run_id: str, interval: float, **kwargs):
"""
设置全局统一等待时长
@param {dict} robot_info - 通用参数，调用时默认传入的机器人信息
@param {str} action_name - 通用参数，调用时默认传入的动作名
@param {str} run_id - 运行id
@param {float} interval - 要设置的等待时长
"""
RunTool.set_global_var('COMMON_ACTION_TIME_WAIT', interval)
def chrome_para_set_find_step_tag(cls, robot_info: dict, action_name: str,
run_id: str, value: float,
**kwargs) -> float:
"""
获取参数值 - 控件查找类型标志
@param {dict} robot_info - 通用参数，调用时默认传入的机器人信息
@param {str} action_name - 通用参数，调用时默认传入的动作名
@param {str} run_id - 运行id
@param {float} value - 要设置的参数
"""
RunTool.set_global_var('CHROME_ACTION_PARA_FIND_STEPS_TAG', value)
def chrome_para_set_wait_less_timeout(cls, robot_info: dict,
action_name: str, run_id: str,
value: float, **kwargs) -> float:
"""
获取参数值 - 最小等待超时时间
@param {dict} robot_info - 通用参数，调用时默认传入的机器人信息
@param {str} action_name - 通用参数，调用时默认传入的动作名
@param {str} run_id - 运行id
@param {float} value - 要设置的参数，单位秒2秒
"""
RunTool.set_global_var('CHROME_ACTION_PARA_WAIT_LESS_TIMEOUT', value)
def recv_data(cls, net_info, recv_para={}):
"""
从指定的网络连接中读取数据
@param {object} net_info - 要读取数据的网络信息对象（例如socket对象）
@param {dict} recv_para - 读取数据的参数, 包括：
recv_len {int} - 要获取的数据长度, 必要参数
overtime {int} - 获取超时时间，单位为毫秒，非必要参数
@returns {CResult} - 数据获取结果:
result.code ：'00000'-成功，'20403'-获取数据超时，其他为获取失败
result.data ：获取到的数据对象（具体类型和定义，由实现类自定义）
result.recv_time : datetime 实际开始接受数据时间
result.overtime : int 超时时间（毫秒），当返回结果为超时，可获取超时时间信息
"""
# 子类必须定义该功能
if type(recv_para) != dict:
recv_para = {}
_result = CResult('00000')
_result.data = b''
_result.recv_time = datetime.datetime.now()
_overtime = 10000
if 'overtime' in recv_para.keys():
# 外部有传入，优先使用该超时时间
_overtime = recv_para['overtime']
elif hasattr(net_info, 'recv_timeout'):
# 如果net_info有超时的设置
_overtime = net_info.recv_timeout
_result.overtime = _overtime
with ExceptionTool.ignored_cresult(
_result
):
_rest_bytes = recv_para['recv_len']
while _rest_bytes > 0:
# 检查是否超时
if (datetime.datetime.now() - _result.recv_time).total_seconds() * 1000 > _overtime:
# 已超时
_result.change_code(code='20403')
break
_buffer = b''
with ExceptionTool.ignored(expect=(BlockingIOError)):
# 获取数据
_buffer = net_info.csocket.recv(_rest_bytes)
if len(_buffer) > 0:
_result.data = _result.data + _buffer
_rest_bytes = _rest_bytes - len(_buffer)
else:
# 休眠一下
RunTool.sleep(0.001)
return _result
def tap_continuity(self,
pos_seed: list,
times: float,
thread_count: int = 2,
random_sleep: bool = False,
sleep_min: float = 0.0,
sleep_max: float = 0.5):
"""
在指定范围随机连续点击
@param {list} pos_seed - 允许点击的位置坐标清单[(x,y), ...], 随机获取
@param {float} times - 要点击的时长, 单位为秒
@param {int} thread_count=2 - 生产点击线程，数量越多点击频率越密集
@param {bool} random_sleep=False - 每个线程点击期间是否自动休眠指定时长
@param {float} sleep_min=0.0 - 每个线程点击期间自动休眠最小时长, 单位为秒
@param {float} sleep_max=0.5 - 每个线程点击期间自动休眠最大时长, 单位为秒
"""
# 参数准备
_cmd_mode = 'shell input tap'
_seed_len = len(pos_seed)
# 定义点击线程函数
def tap_thread_fun():
while True:
# 循环处理，自身不结束
_pos = pos_seed[random.randint(0, _seed_len - 1)]
_cmd = '%s %d %d' % (_cmd_mode, _pos[0], _pos[1])
# 不检查结果
self.adb_run_inner(_cmd, ignore_error=True)
# 看是否休眠
if random_sleep:
time.sleep(random.uniform(sleep_min, sleep_max))
# 启动执行动作
_start = datetime.datetime.now()
_thread_list = list()
for i in range(thread_count):
_running_thread = threading.Thread(target=tap_thread_fun,
name='Thread-Tap-Running %s' %
str(i))
_running_thread.setDaemon(True)
_running_thread.start()
# 添加到列表，用于停止线程
_thread_list.append(_running_thread)
# 监控时长
while (datetime.datetime.now() - _start).total_seconds() < times:
time.sleep(0.01)
# 停止线程
for _thread in _thread_list:
RunTool.stop_thread(_thread)
def get_token_auth(cls) -> HTTPTokenAuth:
"""
获取HTTPTokenAuth对象
@returns {HTTPTokenAuth} - 返回唯一的HTTPTokenAuth对象
"""
_auth = RunTool.get_global_var('HTTP_TOKEN_AUTH')
if _auth is None:
_auth = HTTPTokenAuth(scheme='JWT')
RunTool.set_global_var('HTTP_TOKEN_AUTH', _auth)
return _auth
def __get_map_error_code(self):
"""
获取全局的错误码映射表
"""
_map_error_code = RunTool.get_global_var('HIVENET_ERROR_CODE_MAP')
if _map_error_code is None:
_map_file = os.path.realpath(os.path.abspath(os.path.dirname(__file__) + '/') +
'/hivenet_error_code/map_error_code.json')
_map_error_code = {}
with open(_map_file, 'rt', encoding='utf-8') as f:
_map_error_code = json.load(f)
RunTool.set_global_var('HIVENET_ERROR_CODE_MAP', _map_error_code)
return _map_error_code
def stop_stream_force(self, is_wait=True):
"""
强制关闭当前所有正在处理的流
@param {bool} is_wait=True - 是否等待所有流关闭后再返回
"""
self._force_stop_tag = True
if is_wait:
# 检查是否都已停止
while True:
if len(self._stream_list_tag.keys()) == 0:
break
RunTool.sleep(0.01)
def init_pipeline_plugins():
"""
装载管道插件
"""
# 装载配置
_execute_path = os.path.realpath(os.path.join(
os.path.dirname(__file__), os.path.pardir, 'search_by_image'
))
RunTool.set_global_var('EXECUTE_PATH', _execute_path)
_config = os.path.join(_execute_path, 'conf/server_jade.xml')
_config_xml = SimpleXml(_config, encoding='utf-8')
_server_config = _config_xml.to_dict()['server']
RunTool.set_global_var(
'PIPELINE_PROCESSER_PARA', _server_config['pipeline']['processer_para']
)
RunTool.set_global_var('PIPELINE_ROUTER_PARA', _server_config['pipeline']['router_para'])
_plugins_path_list = _server_config['pipeline']['plugins_path'].split(',')
for _plugins_path in _plugins_path_list:
Pipeline.load_plugins_by_path(
os.path.join(_execute_path, _plugins_path.strip())
)
_logger: Logger = None
if 'logger' in _server_config.keys():
_logger_config = _server_config['logger']
if len(_logger_config['conf_file_name']) > 0 and _logger_config['conf_file_name'][0] == '.':
# 相对路径
_logger_config['conf_file_name'] = os.path.join(
_execute_path, _logger_config['conf_file_name']
)
if len(_logger_config['logfile_path']) > 0 and _logger_config['logfile_path'][0] == '.':
# 相对路径
_logger_config['logfile_path'] = os.path.join(
_execute_path, _logger_config['logfile_path']
)
_logger = Logger.create_logger_by_dict(_logger_config)
# 创建空管道用于测试
_empty_pipeline = Pipeline('empty', '{}', logger=_logger)
RunTool.set_global_var('EMPTY_PIPELINE', _empty_pipeline)
# 创建测试管道
_jade_pipeline = Pipeline(
'jade_search',
_server_config['pipeline']['pipeline_config']['JadeSearch'],
logger=_logger
)
RunTool.set_global_var('JADE_PIPELINE', _jade_pipeline)
def inception_v4_processer_initialize(cls, graph_var_name: str,
processer_name: str):
"""
inception_v4图像分类模型的公共初始化函数
@param {str} graph_var_name - 对象识别冻结图全局变量名
@param {str} processer_name - 处理器名
"""
_graph = RunTool.get_global_var(graph_var_name)
if _graph is None:
_graph = dict()
RunTool.set_global_var(graph_var_name, _graph)
else:
# 模型已装载，无需继续处理
return
_execute_path = RunTool.get_global_var('EXECUTE_PATH')
if _execute_path is None:
_execute_path = os.getcwd()
_config = RunTool.get_global_var(
'PIPELINE_PROCESSER_PARA')[processer_name]
_pb_file = os.path.join(_execute_path, _config['frozen_graph'])
_pb_labelmap = os.path.join(_execute_path, _config['labelmap'])
# 识别基础参数
_graph['min_score'] = _config.get('min_score', 0.8)
_graph['image_size'] = _config.get('image_size', 299)
_graph['labelmap'] = Tools.load_label(_pb_labelmap,
encoding=_config.get(
'encoding', 'utf-8'))
_detection_graph = tf.Graph()
with _detection_graph.as_default():
_od_graph_def = tf.GraphDef()
with tf.gfile.GFile(_pb_file, 'rb') as _fid:
_serialized_graph = _fid.read()
_od_graph_def.ParseFromString(_serialized_graph)
tf.import_graph_def(_od_graph_def, name='')
_graph['session'] = tf.Session(graph=_detection_graph)
# 图像分类出口
_graph['softmax_tensor'] = _detection_graph.get_tensor_by_name(
'InceptionV4/Logits/Predictions:0')
# 特征变量出口
_graph['vertor_tensor'] = _detection_graph.get_tensor_by_name(
'InceptionV4/Logits/AvgPool_1a/AvgPool:0')
def _running_thread_fun(self, run_id: str):
"""
启动管道运行线程
@param {str} run_id - 运行id
"""
_run_id, _run_cache = self._get_run_cache(run_id)
if _run_cache is None:
_msg = '[Pipeline:%s] run_id [%s] not exists!' % (self.name,
run_id)
self.log_error('Error: ' % _msg)
raise RuntimeError(_msg)
_run_cache['thread_running'] = True
try:
while _run_cache['status'] == 'R':
if _run_cache['node_status'] == 'R':
# 当前节点正在执行，未返回执行结果
break
# 执行当前节点
_next_id = self._run_node(_run_id, _run_cache['node_id'])
if _next_id is None:
# 已经是最后一个节点
break
else:
# 判断是否要逐步执行
if _run_cache['is_step_by_step']:
# 执行一步就设置状态为暂停
self._set_status('P', _run_id)
if _next_id == '':
# 异步模式，直接退出线程处理
break
else:
# 设置上下文，执行下一个节点
_run_cache['node_id'] = _next_id
_run_cache['node_status'] = 'I'
_run_cache['node_status_msg'] = ''
RunTool.sleep(0.0001)
except:
# 如果在线程中出了异常，结束掉执行
_run_cache['node_status'] = 'E'
self._set_status('E', _run_id)
_run_cache['output'] = None
raise
finally:
_run_cache['thread_running'] = False
def client_simple_call_para_server_tsl(a,
b,
*args,
c=10,
d={'d1': 'd1value'},
**kwargs):
"""
测试简单调用，进行单向认证（客户端验证服务端证书）
"""
# 转换参数
_para_values = RunTool.get_current_function_parameter_values(
is_simple_mode=True)
_para_obj = SimpleGRpcTools.parameters_to_json(_para_values)
_req_obj = SimpleGRpcTools.generate_request_obj(
service_name='service_simple_call_para',
para_json=_para_obj.para_json,
has_para_bytes=_para_obj.has_para_bytes,
para_bytes=_para_obj.para_bytes)
# 发送请求
with open(_TEMP_DIR + '/../../simple_grpc/server.crt', 'rb') as f:
_root_certificates = f.read()
_connect_para = SimpleGRpcTools.generate_connect_para(
ip='localhost',
port=50053,
is_use_ssl=True,
root_certificates=_root_certificates)
_cresult = SimpleGRpcTools.grpc_call(_connect_para, _req_obj)
_cresult.return_obj = SimpleGRpcTools.json_to_object_by_para_mapping(
_cresult.return_json, 'client_simple_call_para')
return _cresult
