def _start_server_self(self, tid):
"""
自定义服务启动函数，实现类可重载该函数加入自己的处理逻辑
重载该函数，实现网络监听服务的启动，但不接收连接
@param {int} tid - 线程id
@returns {CResult} - 启动结果:
result.code ：'00000'-成功，其他值为失败
result.server_info ：启动成功后的服务对象，用于传递到后续的服务处理函数
"""
_result = CResult(code='00000') # 成功
_result.server_info = NullObj()
with ExceptionTool.ignored_cresult(_result):
# 可在该部分实现自定义逻辑
self._logger.log(
self._log_level,
'[%s-STARTING][NAME:%s]%s:\n%s' % (
self._server_log_prefix,
self._server_name,
_('net start parameter'),
StringTool.format_obj_property_str(self._server_opts, is_deal_subobj=True)
)
)
# 启动服务，但不接受连接
_result = self._start_server_without_accept(self._server_opts)
_result.server_info = _result.net_info
# 返回处理结果
return _result
def stream_closed_fun(stream_tag='', stream_obj=None, position=0, closed_status=None):
_logger.info(
'stream_closed_fun\nstream_tag: %s\nstream_obj: %s\nposition: %s\nclosed_status: %s' % (
stream_tag,
StringTool.format_obj_property_str(stream_obj, is_deal_subobj=True),
str(position),
closed_status.value
)
)
def cmp_dict(cls, src_data, dst_data, print_if_diff=True):
"""
比较两个字典是否一致
@param {string/dict} src_data - 第1个字典对象（或对象JSON字符串）
@param {string/dict} dst_data - 第2个字典对象（或对象JSON字符串）
@param {bool} print_if_diff=True - 当两个字典不一致时是否打印对象信息
@returns {bool} - True-两个字典一致，False-两个字典不一致
"""
is_same = False
if isinstance(src_data, str):
src_data = json.dumps(src_data, ensure_ascii=False)
if isinstance(dst_data, str):
dst_data = json.dumps(dst_data, ensure_ascii=False)
if len(src_data) != len(dst_data):
if print_if_diff:
print('cmp_dict: len difference!')
else:
src_key = list(src_data.keys())
src_key.sort()
dst_key = list(dst_data.keys())
dst_key.sort()
if operator.eq(src_key, dst_key):
is_break = False
for key in src_data.keys():
if src_data[key] != dst_data[key]:
# print(src_data1[key])
print('cmp_dict: value difference in key "%s"!' % (key))
is_break = True
break
if not is_break:
# 如果没有中断过，则代表比较成功
return True
else:
print('cmp_dict: key list difference!')
if print_if_diff:
print('src_data :' + StringTool.format_obj_property_str(src_data,
is_deal_subobj=True, c_level=2))
print('dst_data :' + StringTool.format_obj_property_str(dst_data,
is_deal_subobj=True, c_level=2))
return is_same
def dealer_exception_fun(stream_tag='', stream_obj=None, deal_obj=None, position=0,
dealer_handle=None, error_obj=None, trace_str=''):
_logger.info(
'dealer_exception_fun\nstream_tag: %s\nstream_obj: %s\ndeal_obj: %s\nposition: %s\ndealer_handle: %s\nerror_obj: %s\ntrace_str: %s' % (
stream_tag,
StringTool.format_obj_property_str(stream_obj, is_deal_subobj=True),
str(deal_obj),
str(position),
str(dealer_handle),
str(error_obj),
trace_str
)
)
def __get_print_str(var_obj):
"""
获取对象的打印字符串
@param {object} var_obj - 要打印的对象
@returns {string} - 打印的字符串
"""
_print_str = '[type=%s]%s%s' % (
str(type(var_obj)),
('' if not hasattr(var_obj, '__str__') else str(var_obj)),
('' if not hasattr(var_obj, '__dict__')
else StringTool.format_obj_property_str(var_obj, is_deal_subobj=True, c_level=2))
)
return _print_str
def server_connect_deal_fun(cls, thread_id, server_opts, net_info,
self_tag):
cls.logger.log(
simple_log.INFO, "[服务端" + self_tag + "][" + str(thread_id) +
"]收到客户端连接：" + StringTool.format_obj_property_str(
deal_obj=net_info, is_deal_subobj=True))
# 获取客户端发送的信息，先获取前4个字节
_read_result = TcpIpService.recv_data(net_info, {'recv_len': 4})
if _read_result.code != '00000':
# 获取失败
cls.logger.log(simple_log.INFO,
("[服务端]获取客户端数据报文头失败，关闭连接：" +
str(_read_result.code) + "-" + _read_result.msg))
TcpIpService.close_connect(net_info)
return
_next_read = int.from_bytes(_read_result.data,
byteorder='big',
signed=False)
cls.logger.log(simple_log.INFO,
"[服务端]获取到客户端4个字节的后续数据长度：" + str(_next_read))
# 获取后面的数据
_read_result = TcpIpService.recv_data(net_info,
{'recv_len': _next_read})
if _read_result.code != '00000':
# 获取失败
cls.logger.log(simple_log.INFO,
("[服务端]获取客户端数据报文体失败，关闭连接：" +
str(_read_result.code) + "-" + _read_result.msg))
TcpIpService.close_connect(net_info)
return
_read_str = str(_read_result.data, "utf-8")
cls.logger.log(simple_log.INFO, "[服务端]获取到客户端报文体数据：" + _read_str)
if _read_str == "servernoresponse":
# 隔30秒不响应
time.sleep(30)
# 返回内容，先组包
_ret_str = "处理成功"
_send_body = bytes(_ret_str, "utf-8")
_send_head = len(_send_body).to_bytes(4, byteorder='big', signed=False)
# 发送报文头
_send_result = TcpIpService.send_data(net_info, _send_head, {})
if _send_result.code != '00000':
cls.logger.log(simple_log.INFO,
("[服务端]返回客户端数据报文头失败，关闭连接：" +
str(_send_result.code) + "-" + _send_result.msg))
TcpIpService.close_connect(net_info)
return
cls.logger.log(simple_log.INFO,
"[服务端]返回客户端4个字节的后续数据长度：" + str(len(_send_body)))
_send_result = TcpIpService.send_data(net_info, _send_body, {})
if _send_result.code != '00000':
cls.logger.log(simple_log.INFO,
("[服务端]返回客户端数据报文体失败，关闭连接：" +
str(_send_result.code) + "-" + _send_result.msg))
TcpIpService.close_connect(net_info)
return
cls.logger.log(simple_log.INFO, "[服务端]返回客户端报文体数据：" + _ret_str)
# 处理完成，关闭连接
_close_result = TcpIpService.close_connect(net_info)
if _close_result.code != '00000':
cls.logger.log(simple_log.INFO,
("[服务端]关闭客户端连接失败：" + str(_close_result.code) + "-" +
_close_result.msg))
cls.logger.log(simple_log.INFO, "[服务端]关闭客户端连接")
