883 lines
30 KiB
Python
883 lines
30 KiB
Python
"""
|
||
协议处理器模块
|
||
负责处理各种网络协议和消息格式
|
||
"""
|
||
|
||
import time
|
||
import json
|
||
import struct
|
||
from typing import Dict, Any, List, Optional
|
||
import hashlib
|
||
import zlib
|
||
|
||
class ProtocolHandler:
|
||
"""
|
||
协议处理器
|
||
负责处理各种网络协议和消息格式
|
||
"""
|
||
|
||
def __init__(self, plugin):
|
||
"""
|
||
初始化协议处理器
|
||
|
||
Args:
|
||
plugin: 网络同步插件实例
|
||
"""
|
||
self.plugin = plugin
|
||
self.enabled = False
|
||
self.initialized = False
|
||
|
||
# 协议配置
|
||
self.protocol_config = {
|
||
'version': '1.0',
|
||
'enable_compression': True,
|
||
'compression_level': 6,
|
||
'enable_checksum': True,
|
||
'max_message_size': 65536, # 64KB
|
||
'enable_fragmentation': True,
|
||
'fragment_size': 1024,
|
||
'enable_encryption': False,
|
||
'supported_protocols': ['sync_v1', 'sync_v2']
|
||
}
|
||
|
||
# 消息类型定义
|
||
self.message_types = {
|
||
'CONNECT': 1,
|
||
'CONNECT_ACK': 2,
|
||
'DISCONNECT': 3,
|
||
'HEARTBEAT': 4,
|
||
'SYNC_DATA': 5,
|
||
'SYNC_REQUEST': 6,
|
||
'SYNC_RESPONSE': 7,
|
||
'RPC_CALL': 8,
|
||
'RPC_RESPONSE': 9,
|
||
'EVENT': 10,
|
||
'CHAT': 11,
|
||
'ERROR': 12
|
||
}
|
||
|
||
# 消息处理器
|
||
self.message_handlers = {}
|
||
|
||
# 协议状态
|
||
self.protocol_state = {
|
||
'current_protocol': 'sync_v1',
|
||
'bytes_processed': 0,
|
||
'messages_processed': 0,
|
||
'compression_savings': 0,
|
||
'fragmented_messages': 0
|
||
}
|
||
|
||
# 消息片段缓存
|
||
self.message_fragments = {}
|
||
|
||
# 协议统计
|
||
self.protocol_stats = {
|
||
'messages_sent': 0,
|
||
'messages_received': 0,
|
||
'bytes_sent': 0,
|
||
'bytes_received': 0,
|
||
'compressed_messages': 0,
|
||
'checksum_errors': 0,
|
||
'protocol_errors': 0,
|
||
'fragmented_packets': 0
|
||
}
|
||
|
||
# 回调函数
|
||
self.protocol_callbacks = {
|
||
'message_received': [],
|
||
'message_sent': [],
|
||
'protocol_error': [],
|
||
'message_fragmented': []
|
||
}
|
||
|
||
# 时间戳记录
|
||
self.last_protocol_update = 0.0
|
||
self.last_compression_savings = 0.0
|
||
|
||
print("✓ 协议处理器已创建")
|
||
|
||
def initialize(self) -> bool:
|
||
"""
|
||
初始化协议处理器
|
||
|
||
Returns:
|
||
是否初始化成功
|
||
"""
|
||
try:
|
||
# 注册默认消息处理器
|
||
self._register_default_handlers()
|
||
|
||
self.initialized = True
|
||
print("✓ 协议处理器初始化完成")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 协议处理器初始化失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def enable(self) -> bool:
|
||
"""
|
||
启用协议处理器
|
||
|
||
Returns:
|
||
是否启用成功
|
||
"""
|
||
try:
|
||
if not self.initialized:
|
||
print("✗ 协议处理器未初始化")
|
||
return False
|
||
|
||
self.enabled = True
|
||
print("✓ 协议处理器已启用")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 协议处理器启用失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def disable(self):
|
||
"""禁用协议处理器"""
|
||
try:
|
||
self.enabled = False
|
||
print("✓ 协议处理器已禁用")
|
||
|
||
except Exception as e:
|
||
print(f"✗ 协议处理器禁用失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def finalize(self):
|
||
"""清理协议处理器资源"""
|
||
try:
|
||
self.disable()
|
||
self.message_handlers.clear()
|
||
self.message_fragments.clear()
|
||
self.protocol_callbacks.clear()
|
||
self.initialized = False
|
||
print("✓ 协议处理器资源已清理")
|
||
|
||
except Exception as e:
|
||
print(f"✗ 协议处理器资源清理失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def update(self, dt: float):
|
||
"""
|
||
更新协议处理器状态
|
||
|
||
Args:
|
||
dt: 时间增量
|
||
"""
|
||
try:
|
||
if not self.enabled:
|
||
return
|
||
|
||
current_time = time.time()
|
||
self.last_protocol_update = current_time
|
||
|
||
# 清理过期的消息片段
|
||
self._cleanup_fragments(current_time)
|
||
|
||
except Exception as e:
|
||
print(f"✗ 协议处理器更新失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def _register_default_handlers(self):
|
||
"""注册默认消息处理器"""
|
||
try:
|
||
self.message_handlers = {
|
||
self.message_types['CONNECT']: self._handle_connect,
|
||
self.message_types['CONNECT_ACK']: self._handle_connect_ack,
|
||
self.message_types['DISCONNECT']: self._handle_disconnect,
|
||
self.message_types['HEARTBEAT']: self._handle_heartbeat,
|
||
self.message_types['SYNC_DATA']: self._handle_sync_data,
|
||
self.message_types['SYNC_REQUEST']: self._handle_sync_request,
|
||
self.message_types['SYNC_RESPONSE']: self._handle_sync_response,
|
||
self.message_types['RPC_CALL']: self._handle_rpc_call,
|
||
self.message_types['RPC_RESPONSE']: self._handle_rpc_response,
|
||
self.message_types['EVENT']: self._handle_event,
|
||
self.message_types['CHAT']: self._handle_chat,
|
||
self.message_types['ERROR']: self._handle_error
|
||
}
|
||
|
||
print("✓ 默认消息处理器已注册")
|
||
except Exception as e:
|
||
print(f"✗ 默认消息处理器注册失败: {e}")
|
||
|
||
def _cleanup_fragments(self, current_time: float):
|
||
"""
|
||
清理过期的消息片段
|
||
|
||
Args:
|
||
current_time: 当前时间
|
||
"""
|
||
try:
|
||
expired_fragments = [
|
||
msg_id for msg_id, fragment_data in self.message_fragments.items()
|
||
if current_time - fragment_data.get('timestamp', 0) > 30.0 # 30秒超时
|
||
]
|
||
|
||
for msg_id in expired_fragments:
|
||
del self.message_fragments[msg_id]
|
||
|
||
except Exception as e:
|
||
print(f"✗ 消息片段清理失败: {e}")
|
||
|
||
def encode_message(self, message_type: str, data: Dict[str, Any],
|
||
compress: bool = None, add_checksum: bool = None) -> Optional[bytes]:
|
||
"""
|
||
编码消息
|
||
|
||
Args:
|
||
message_type: 消息类型
|
||
data: 消息数据
|
||
compress: 是否压缩
|
||
add_checksum: 是否添加校验和
|
||
|
||
Returns:
|
||
编码后的消息数据或None
|
||
"""
|
||
try:
|
||
# 获取消息类型ID
|
||
type_id = self.message_types.get(message_type.upper())
|
||
if type_id is None:
|
||
print(f"✗ 未知的消息类型: {message_type}")
|
||
return None
|
||
|
||
# 序列化数据
|
||
data_json = json.dumps(data, ensure_ascii=False)
|
||
data_bytes = data_json.encode('utf-8')
|
||
original_size = len(data_bytes)
|
||
|
||
# 压缩数据
|
||
compressed = False
|
||
if compress is None:
|
||
compress = self.protocol_config['enable_compression']
|
||
|
||
if compress and original_size > 256: # 只压缩大于256字节的数据
|
||
compressed_data = zlib.compress(data_bytes, self.protocol_config['compression_level'])
|
||
if len(compressed_data) < original_size:
|
||
data_bytes = compressed_data
|
||
compressed = True
|
||
self.protocol_stats['compressed_messages'] += 1
|
||
self.protocol_state['compression_savings'] += original_size - len(compressed_data)
|
||
|
||
# 添加校验和
|
||
checksum = b''
|
||
if add_checksum is None:
|
||
add_checksum = self.protocol_config['enable_checksum']
|
||
|
||
if add_checksum:
|
||
checksum = hashlib.md5(data_bytes).digest()
|
||
|
||
# 构造消息头
|
||
timestamp = int(time.time() * 1000) & 0xFFFFFFFF # 32位时间戳
|
||
header = struct.pack('!BBI', type_id, compressed, timestamp)
|
||
|
||
# 构造完整消息
|
||
message = header + checksum + data_bytes
|
||
|
||
# 更新统计信息
|
||
self.protocol_stats['messages_sent'] += 1
|
||
self.protocol_stats['bytes_sent'] += len(message)
|
||
self.protocol_state['bytes_processed'] += len(message)
|
||
self.protocol_state['messages_processed'] += 1
|
||
|
||
return message
|
||
|
||
except Exception as e:
|
||
print(f"✗ 消息编码失败: {e}")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return None
|
||
|
||
def decode_message(self, message_data: bytes) -> Optional[Dict[str, Any]]:
|
||
"""
|
||
解码消息
|
||
|
||
Args:
|
||
message_data: 消息数据
|
||
|
||
Returns:
|
||
解码后的消息字典或None
|
||
"""
|
||
try:
|
||
if len(message_data) < 6: # 最小消息长度(1字节类型+1字节压缩标志+4字节时间戳)
|
||
print("✗ 消息数据太短")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return None
|
||
|
||
# 解析消息头
|
||
header_size = 6
|
||
type_id, compressed_flag, timestamp = struct.unpack('!BBI', message_data[:header_size])
|
||
|
||
# 获取消息类型名称
|
||
message_type = None
|
||
for name, id_val in self.message_types.items():
|
||
if id_val == type_id:
|
||
message_type = name
|
||
break
|
||
|
||
if message_type is None:
|
||
print(f"✗ 未知的消息类型ID: {type_id}")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return None
|
||
|
||
# 计算校验和偏移
|
||
checksum_offset = header_size
|
||
if self.protocol_config['enable_checksum']:
|
||
checksum_offset += 16 # MD5校验和长度
|
||
|
||
# 获取数据部分
|
||
data_bytes = message_data[checksum_offset:]
|
||
|
||
# 验证校验和
|
||
if self.protocol_config['enable_checksum'] and len(message_data) >= checksum_offset:
|
||
expected_checksum = message_data[header_size:checksum_offset]
|
||
actual_checksum = hashlib.md5(data_bytes).digest()
|
||
if expected_checksum != actual_checksum:
|
||
print("✗ 消息校验和错误")
|
||
self.protocol_stats['checksum_errors'] += 1
|
||
return None
|
||
|
||
# 解压缩数据
|
||
if compressed_flag:
|
||
try:
|
||
data_bytes = zlib.decompress(data_bytes)
|
||
except Exception as e:
|
||
print(f"✗ 消息解压缩失败: {e}")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return None
|
||
|
||
# 反序列化数据
|
||
data_json = data_bytes.decode('utf-8')
|
||
data = json.loads(data_json)
|
||
|
||
# 构造解码结果
|
||
result = {
|
||
'type': message_type,
|
||
'type_id': type_id,
|
||
'compressed': bool(compressed_flag),
|
||
'timestamp': timestamp,
|
||
'data': data
|
||
}
|
||
|
||
# 更新统计信息
|
||
self.protocol_stats['messages_received'] += 1
|
||
self.protocol_stats['bytes_received'] += len(message_data)
|
||
self.protocol_state['bytes_processed'] += len(message_data)
|
||
self.protocol_state['messages_processed'] += 1
|
||
|
||
# 触发消息接收回调
|
||
self._trigger_protocol_callback('message_received', result)
|
||
|
||
return result
|
||
|
||
except Exception as e:
|
||
print(f"✗ 消息解码失败: {e}")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return None
|
||
|
||
def fragment_message(self, message_data: bytes, fragment_size: int = None) -> List[bytes]:
|
||
"""
|
||
分片消息
|
||
|
||
Args:
|
||
message_data: 消息数据
|
||
fragment_size: 分片大小
|
||
|
||
Returns:
|
||
分片后的消息列表
|
||
"""
|
||
try:
|
||
if fragment_size is None:
|
||
fragment_size = self.protocol_config['fragment_size']
|
||
|
||
if len(message_data) <= fragment_size:
|
||
return [message_data]
|
||
|
||
fragments = []
|
||
message_id = hashlib.md5(message_data).hexdigest()[:8]
|
||
total_fragments = (len(message_data) + fragment_size - 1) // fragment_size
|
||
|
||
for i in range(total_fragments):
|
||
start_pos = i * fragment_size
|
||
end_pos = min((i + 1) * fragment_size, len(message_data))
|
||
fragment_data = message_data[start_pos:end_pos]
|
||
|
||
# 构造分片头
|
||
fragment_header = struct.pack('!8sHH',
|
||
message_id.encode('ascii'),
|
||
i,
|
||
total_fragments)
|
||
|
||
fragments.append(fragment_header + fragment_data)
|
||
|
||
self.protocol_stats['fragmented_packets'] += len(fragments)
|
||
self.protocol_state['fragmented_messages'] += 1
|
||
|
||
# 触发消息分片回调
|
||
self._trigger_protocol_callback('message_fragmented', {
|
||
'message_id': message_id,
|
||
'total_fragments': total_fragments,
|
||
'fragment_size': fragment_size
|
||
})
|
||
|
||
return fragments
|
||
|
||
except Exception as e:
|
||
print(f"✗ 消息分片失败: {e}")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return [message_data]
|
||
|
||
def reassemble_message(self, fragment_data: bytes) -> Optional[bytes]:
|
||
"""
|
||
重组消息
|
||
|
||
Args:
|
||
fragment_data: 分片数据
|
||
|
||
Returns:
|
||
重组后的消息数据或None
|
||
"""
|
||
try:
|
||
if len(fragment_data) < 12: # 分片头最小长度
|
||
return None
|
||
|
||
# 解析分片头
|
||
message_id_bytes, fragment_index, total_fragments = struct.unpack('!8sHH', fragment_data[:12])
|
||
message_id = message_id_bytes.decode('ascii').rstrip('\x00')
|
||
fragment_payload = fragment_data[12:]
|
||
|
||
# 初始化分片缓存
|
||
if message_id not in self.message_fragments:
|
||
self.message_fragments[message_id] = {
|
||
'fragments': {},
|
||
'total_fragments': total_fragments,
|
||
'timestamp': time.time()
|
||
}
|
||
|
||
# 存储分片
|
||
self.message_fragments[message_id]['fragments'][fragment_index] = fragment_payload
|
||
|
||
# 检查是否所有分片都已到达
|
||
fragment_cache = self.message_fragments[message_id]
|
||
if len(fragment_cache['fragments']) == fragment_cache['total_fragments']:
|
||
# 重组消息
|
||
message_parts = []
|
||
for i in range(fragment_cache['total_fragments']):
|
||
if i in fragment_cache['fragments']:
|
||
message_parts.append(fragment_cache['fragments'][i])
|
||
else:
|
||
# 缺少分片
|
||
return None
|
||
|
||
# 清理缓存
|
||
del self.message_fragments[message_id]
|
||
|
||
# 返回重组后的消息
|
||
return b''.join(message_parts)
|
||
|
||
return None
|
||
|
||
except Exception as e:
|
||
print(f"✗ 消息重组失败: {e}")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return None
|
||
|
||
def send_message(self, message_type: str, data: Dict[str, Any],
|
||
target_client_id: str = None) -> bool:
|
||
"""
|
||
发送消息
|
||
|
||
Args:
|
||
message_type: 消息类型
|
||
data: 消息数据
|
||
target_client_id: 目标客户端ID
|
||
|
||
Returns:
|
||
是否发送成功
|
||
"""
|
||
try:
|
||
if not self.enabled:
|
||
print("✗ 协议处理器未启用")
|
||
return False
|
||
|
||
# 编码消息
|
||
message_bytes = self.encode_message(message_type, data)
|
||
if message_bytes is None:
|
||
print("✗ 消息编码失败")
|
||
return False
|
||
|
||
# 检查是否需要分片
|
||
if (self.protocol_config['enable_fragmentation'] and
|
||
len(message_bytes) > self.protocol_config['fragment_size']):
|
||
fragments = self.fragment_message(message_bytes)
|
||
success = True
|
||
|
||
# 发送所有分片
|
||
for fragment in fragments:
|
||
if not self._send_raw_message(fragment, target_client_id):
|
||
success = False
|
||
|
||
if success:
|
||
# 触发消息发送回调
|
||
self._trigger_protocol_callback('message_sent', {
|
||
'type': message_type,
|
||
'data': data,
|
||
'fragmented': True,
|
||
'fragment_count': len(fragments)
|
||
})
|
||
|
||
return success
|
||
else:
|
||
# 发送完整消息
|
||
if self._send_raw_message(message_bytes, target_client_id):
|
||
# 触发消息发送回调
|
||
self._trigger_protocol_callback('message_sent', {
|
||
'type': message_type,
|
||
'data': data,
|
||
'fragmented': False
|
||
})
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
except Exception as e:
|
||
print(f"✗ 消息发送失败: {e}")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return False
|
||
|
||
def _send_raw_message(self, message_bytes: bytes, target_client_id: str = None) -> bool:
|
||
"""
|
||
发送原始消息数据
|
||
|
||
Args:
|
||
message_bytes: 消息字节数据
|
||
target_client_id: 目标客户端ID
|
||
|
||
Returns:
|
||
是否发送成功
|
||
"""
|
||
try:
|
||
# 通过网络管理器发送消息
|
||
if self.plugin.network_manager:
|
||
# 这里应该调用网络管理器的发送方法
|
||
# 由于是模拟实现，我们只返回True
|
||
return True
|
||
else:
|
||
print("✗ 网络管理器未初始化")
|
||
return False
|
||
|
||
except Exception as e:
|
||
print(f"✗ 原始消息发送失败: {e}")
|
||
return False
|
||
|
||
def receive_message(self, message_bytes: bytes) -> bool:
|
||
"""
|
||
接收消息
|
||
|
||
Args:
|
||
message_bytes: 消息字节数据
|
||
|
||
Returns:
|
||
是否处理成功
|
||
"""
|
||
try:
|
||
if not self.enabled:
|
||
print("✗ 协议处理器未启用")
|
||
return False
|
||
|
||
# 检查是否为分片消息
|
||
if len(message_bytes) >= 12:
|
||
# 尝试解析分片头
|
||
try:
|
||
message_id_bytes, fragment_index, total_fragments = struct.unpack('!8sHH', message_bytes[:12])
|
||
# 这是一个分片消息
|
||
reassembled_message = self.reassemble_message(message_bytes)
|
||
if reassembled_message is not None:
|
||
# 分片重组完成，处理完整消息
|
||
return self.receive_message(reassembled_message)
|
||
else:
|
||
# 等待更多分片
|
||
return True
|
||
except struct.error:
|
||
# 不是分片消息，继续处理
|
||
pass
|
||
|
||
# 解码消息
|
||
decoded_message = self.decode_message(message_bytes)
|
||
if decoded_message is None:
|
||
print("✗ 消息解码失败")
|
||
return False
|
||
|
||
# 处理消息
|
||
return self._process_message(decoded_message)
|
||
|
||
except Exception as e:
|
||
print(f"✗ 消息接收失败: {e}")
|
||
self.protocol_stats['protocol_errors'] += 1
|
||
return False
|
||
|
||
def _process_message(self, message: Dict[str, Any]) -> bool:
|
||
"""
|
||
处理消息
|
||
|
||
Args:
|
||
message: 解码后的消息
|
||
|
||
Returns:
|
||
是否处理成功
|
||
"""
|
||
try:
|
||
message_type_id = message.get('type_id')
|
||
message_data = message.get('data', {})
|
||
|
||
# 查找对应的消息处理器
|
||
if message_type_id in self.message_handlers:
|
||
handler = self.message_handlers[message_type_id]
|
||
return handler(message_data)
|
||
else:
|
||
print(f"✗ 未找到消息处理器: {message_type_id}")
|
||
return False
|
||
|
||
except Exception as e:
|
||
print(f"✗ 消息处理失败: {e}")
|
||
return False
|
||
|
||
# 默认消息处理器
|
||
def _handle_connect(self, data: Dict[str, Any]) -> bool:
|
||
"""处理连接消息"""
|
||
try:
|
||
print(f"✓ 处理连接消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 连接消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_connect_ack(self, data: Dict[str, Any]) -> bool:
|
||
"""处理连接确认消息"""
|
||
try:
|
||
print(f"✓ 处理连接确认消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 连接确认消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_disconnect(self, data: Dict[str, Any]) -> bool:
|
||
"""处理断开连接消息"""
|
||
try:
|
||
print(f"✓ 处理断开连接消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 断开连接消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_heartbeat(self, data: Dict[str, Any]) -> bool:
|
||
"""处理心跳消息"""
|
||
try:
|
||
print(f"✓ 处理心跳消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 心跳消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_sync_data(self, data: Dict[str, Any]) -> bool:
|
||
"""处理同步数据消息"""
|
||
try:
|
||
print(f"✓ 处理同步数据消息: {len(data)}个对象")
|
||
|
||
# 传递给对象同步模块
|
||
if self.plugin.object_sync:
|
||
for obj_id, obj_data in data.items():
|
||
self.plugin.object_sync.receive_sync_data(obj_id, obj_data)
|
||
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 同步数据消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_sync_request(self, data: Dict[str, Any]) -> bool:
|
||
"""处理同步请求消息"""
|
||
try:
|
||
print(f"✓ 处理同步请求消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 同步请求消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_sync_response(self, data: Dict[str, Any]) -> bool:
|
||
"""处理同步响应消息"""
|
||
try:
|
||
print(f"✓ 处理同步响应消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 同步响应消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_rpc_call(self, data: Dict[str, Any]) -> bool:
|
||
"""处理RPC调用消息"""
|
||
try:
|
||
print(f"✓ 处理RPC调用消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ RPC调用消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_rpc_response(self, data: Dict[str, Any]) -> bool:
|
||
"""处理RPC响应消息"""
|
||
try:
|
||
print(f"✓ 处理RPC响应消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ RPC响应消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_event(self, data: Dict[str, Any]) -> bool:
|
||
"""处理事件消息"""
|
||
try:
|
||
print(f"✓ 处理事件消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 事件消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_chat(self, data: Dict[str, Any]) -> bool:
|
||
"""处理聊天消息"""
|
||
try:
|
||
print(f"✓ 处理聊天消息: {data}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 聊天消息处理失败: {e}")
|
||
return False
|
||
|
||
def _handle_error(self, data: Dict[str, Any]) -> bool:
|
||
"""处理错误消息"""
|
||
try:
|
||
print(f"✗ 处理错误消息: {data}")
|
||
|
||
# 触发协议错误回调
|
||
self._trigger_protocol_callback('protocol_error', data)
|
||
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 错误消息处理失败: {e}")
|
||
return False
|
||
|
||
def get_protocol_config(self) -> Dict[str, Any]:
|
||
"""
|
||
获取协议配置
|
||
|
||
Returns:
|
||
协议配置字典
|
||
"""
|
||
return self.protocol_config.copy()
|
||
|
||
def set_protocol_config(self, config: Dict[str, Any]) -> bool:
|
||
"""
|
||
设置协议配置
|
||
|
||
Args:
|
||
config: 协议配置字典
|
||
|
||
Returns:
|
||
是否设置成功
|
||
"""
|
||
try:
|
||
self.protocol_config.update(config)
|
||
print(f"✓ 协议配置已更新: {self.protocol_config}")
|
||
return True
|
||
except Exception as e:
|
||
print(f"✗ 协议配置设置失败: {e}")
|
||
return False
|
||
|
||
def get_protocol_stats(self) -> Dict[str, Any]:
|
||
"""
|
||
获取协议统计信息
|
||
|
||
Returns:
|
||
协议统计字典
|
||
"""
|
||
return self.protocol_stats.copy()
|
||
|
||
def reset_protocol_stats(self):
|
||
"""重置协议统计信息"""
|
||
try:
|
||
self.protocol_stats = {
|
||
'messages_sent': 0,
|
||
'messages_received': 0,
|
||
'bytes_sent': 0,
|
||
'bytes_received': 0,
|
||
'compressed_messages': 0,
|
||
'checksum_errors': 0,
|
||
'protocol_errors': 0,
|
||
'fragmented_packets': 0
|
||
}
|
||
print("✓ 协议统计信息已重置")
|
||
except Exception as e:
|
||
print(f"✗ 协议统计信息重置失败: {e}")
|
||
|
||
def get_protocol_state(self) -> Dict[str, Any]:
|
||
"""
|
||
获取协议状态
|
||
|
||
Returns:
|
||
协议状态字典
|
||
"""
|
||
return self.protocol_state.copy()
|
||
|
||
def _trigger_protocol_callback(self, callback_type: str, data: Dict[str, Any]):
|
||
"""
|
||
触发协议回调
|
||
|
||
Args:
|
||
callback_type: 回调类型
|
||
data: 回调数据
|
||
"""
|
||
try:
|
||
if callback_type in self.protocol_callbacks:
|
||
for callback in self.protocol_callbacks[callback_type]:
|
||
try:
|
||
callback(data)
|
||
except Exception as e:
|
||
print(f"✗ 协议回调执行失败: {e}")
|
||
except Exception as e:
|
||
print(f"✗ 协议回调触发失败: {e}")
|
||
|
||
def register_protocol_callback(self, callback_type: str, callback: callable):
|
||
"""
|
||
注册协议回调
|
||
|
||
Args:
|
||
callback_type: 回调类型
|
||
callback: 回调函数
|
||
"""
|
||
try:
|
||
if callback_type in self.protocol_callbacks:
|
||
self.protocol_callbacks[callback_type].append(callback)
|
||
print(f"✓ 协议回调已注册: {callback_type}")
|
||
else:
|
||
print(f"✗ 无效的回调类型: {callback_type}")
|
||
except Exception as e:
|
||
print(f"✗ 协议回调注册失败: {e}")
|
||
|
||
def unregister_protocol_callback(self, callback_type: str, callback: callable):
|
||
"""
|
||
注销协议回调
|
||
|
||
Args:
|
||
callback_type: 回调类型
|
||
callback: 回调函数
|
||
"""
|
||
try:
|
||
if callback_type in self.protocol_callbacks:
|
||
if callback in self.protocol_callbacks[callback_type]:
|
||
self.protocol_callbacks[callback_type].remove(callback)
|
||
print(f"✓ 协议回调已注销: {callback_type}")
|
||
except Exception as e:
|
||
print(f"✗ 协议回调注销失败: {e}") |