""" 事件处理器模块 负责处理网络同步相关的事件 """ import time from typing import Dict, Any, List, Optional, Callable import threading import queue class NetworkEvent: """网络事件类""" def __init__(self, event_type: str, data: Dict[str, Any], timestamp: float = None): self.event_type = event_type self.data = data self.timestamp = timestamp or time.time() self.handled = False self.processed = False class EventHandler: """ 事件处理器 负责处理网络同步相关的事件 """ def __init__(self, plugin): """ 初始化事件处理器 Args: plugin: 网络同步插件实例 """ self.plugin = plugin self.enabled = False self.initialized = False # 事件配置 self.event_config = { "enable_event_queue": True, "max_queue_size": 1000, "enable_async_processing": True, "max_processing_threads": 4, "event_timeout": 30.0, "enable_event_filtering": True, "enable_event_prioritization": True, "enable_event_coalescing": True, "coalesce_time_window": 0.1, # 100ms "enable_event_logging": True, "log_level": "INFO" } # 事件队列 self.event_queue = queue.Queue(maxsize=self.event_config["max_queue_size"]) self.priority_queue = queue.PriorityQueue() # 事件处理器映射 self.event_handlers = {} # 事件监听器 self.event_listeners = {} # 事件统计 self.event_stats = { "events_received": 0, "events_processed": 0, "events_dropped": 0, "events_timed_out": 0, "handler_errors": 0, "async_tasks": 0, "coalesced_events": 0 } # 事件合并缓存 self.coalesce_cache = {} # 异步处理线程 self.processing_threads = [] self.running = False # 回调函数 self.event_callbacks = { "event_received": [], "event_processed": [], "event_dropped": [], "event_error": [] } # 时间戳记录 self.last_event_time = 0.0 self.last_processing_time = 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 self.running = True # 启动事件处理线程 if self.event_config["enable_async_processing"]: thread_count = self.event_config["max_processing_threads"] for i in range(thread_count): thread = threading.Thread(target=self._event_processing_loop, daemon=True, name=f"EventProcessor-{i}") self.processing_threads.append(thread) thread.start() print("✓ 事件处理器已启用") return True except Exception as e: print(f"✗ 事件处理器启用失败: {e}") import traceback traceback.print_exc() return False def disable(self): """禁用事件处理器""" try: self.enabled = False self.running = False # 等待处理线程结束 for thread in self.processing_threads: if thread.is_alive(): thread.join(timeout=2.0) self.processing_threads.clear() print("✓ 事件处理器已禁用") except Exception as e: print(f"✗ 事件处理器禁用失败: {e}") import traceback traceback.print_exc() def finalize(self): """清理事件处理器资源""" try: self.disable() self.event_handlers.clear() self.event_listeners.clear() self.event_callbacks.clear() self.coalesce_cache.clear() # 清空队列 while not self.event_queue.empty(): try: self.event_queue.get_nowait() except queue.Empty: break while not self.priority_queue.empty(): try: self.priority_queue.get_nowait() except queue.Empty: break 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_processing_time = current_time # 清理过期的合并缓存 self._cleanup_coalesce_cache(current_time) except Exception as e: print(f"✗ 事件处理器更新失败: {e}") import traceback traceback.print_exc() def _register_default_handlers(self): """注册默认事件处理器""" try: # 网络相关事件 self.register_event_handler("network_connected", self._handle_network_connected) self.register_event_handler("network_disconnected", self._handle_network_disconnected) self.register_event_handler("network_error", self._handle_network_error) self.register_event_handler("network_data_received", self._handle_network_data_received) self.register_event_handler("network_data_sent", self._handle_network_data_sent) # 同步相关事件 self.register_event_handler("object_synced", self._handle_object_synced) self.register_event_handler("sync_error", self._handle_sync_error) self.register_event_handler("interpolation_updated", self._handle_interpolation_updated) self.register_event_handler("extrapolation_updated", self._handle_extrapolation_updated) # 连接相关事件 self.register_event_handler("client_connected", self._handle_client_connected) self.register_event_handler("client_disconnected", self._handle_client_disconnected) self.register_event_handler("connection_timeout", self._handle_connection_timeout) # 协议相关事件 self.register_event_handler("message_received", self._handle_message_received) self.register_event_handler("message_sent", self._handle_message_sent) self.register_event_handler("protocol_error", self._handle_protocol_error) # 时钟相关事件 self.register_event_handler("sync_started", self._handle_sync_started) self.register_event_handler("sync_completed", self._handle_sync_completed) self.register_event_handler("sync_failed", self._handle_sync_failed) self.register_event_handler("time_updated", self._handle_time_updated) self.register_event_handler("sync_quality_changed", self._handle_sync_quality_changed) # 配置相关事件 self.register_event_handler("config_loaded", self._handle_config_loaded) self.register_event_handler("config_saved", self._handle_config_saved) self.register_event_handler("config_changed", self._handle_config_changed) self.register_event_handler("config_error", self._handle_config_error) # 序列化相关事件 self.register_event_handler("data_serialized", self._handle_data_serialized) self.register_event_handler("data_deserialized", self._handle_data_deserialized) self.register_event_handler("serialization_error", self._handle_serialization_error) self.register_event_handler("deserialization_error", self._handle_deserialization_error) # 预测相关事件 self.register_event_handler("prediction_updated", self._handle_prediction_updated) self.register_event_handler("correction_applied", self._handle_correction_applied) self.register_event_handler("snap_correction", self._handle_snap_correction) self.register_event_handler("prediction_error", self._handle_prediction_error) print("✓ 默认事件处理器已注册") except Exception as e: print(f"✗ 默认事件处理器注册失败: {e}") def _event_processing_loop(self): """事件处理循环""" try: while self.running: try: # 优先处理优先级队列中的事件 try: priority, event = self.priority_queue.get(timeout=0.01) self._process_event(event) self.priority_queue.task_done() except queue.Empty: # 处理普通队列中的事件 try: event = self.event_queue.get(timeout=0.01) self._process_event(event) self.event_queue.task_done() except queue.Empty: # 没有事件，短暂休眠 time.sleep(0.001) except Exception as e: print(f"✗ 事件处理循环错误: {e}") time.sleep(0.1) except Exception as e: print(f"✗ 事件处理循环失败: {e}") def _process_event(self, event: NetworkEvent): """ 处理事件 Args: event: 网络事件 """ try: current_time = time.time() # 检查事件是否超时 if current_time - event.timestamp > self.event_config["event_timeout"]: self.event_stats["events_timed_out"] += 1 self._trigger_event_callback("event_dropped", { "event": event, "reason": "timeout" }) return # 查找事件处理器 handler = self.event_handlers.get(event.event_type) if handler: try: # 调用事件处理器 result = handler(event.data) event.processed = True # 更新统计信息 self.event_stats["events_processed"] += 1 # 触发事件处理完成回调 self._trigger_event_callback("event_processed", { "event": event, "result": result, "processing_time": time.time() - event.timestamp }) except Exception as e: print(f"✗ 事件处理器执行失败: {event.event_type} - {e}") self.event_stats["handler_errors"] += 1 # 触发事件错误回调 self._trigger_event_callback("event_error", { "event": event, "error": str(e) }) else: # 没有找到处理器，但仍标记为已处理 event.processed = True self.event_stats["events_processed"] += 1 # 触发事件处理完成回调 self._trigger_event_callback("event_processed", { "event": event, "result": None, "processing_time": time.time() - event.timestamp }) except Exception as e: print(f"✗ 事件处理失败: {e}") def post_event(self, event_type: str, data: Dict[str, Any] = None, priority: int = 0, timestamp: float = None) -> bool: """ 发布事件 Args: event_type: 事件类型 data: 事件数据 priority: 事件优先级（数字越小优先级越高） timestamp: 事件时间戳 Returns: 是否发布成功 """ try: if not self.enabled: print("✗ 事件处理器未启用") return False # 创建事件对象 event = NetworkEvent(event_type, data or {}, timestamp) # 触发事件接收回调 self._trigger_event_callback("event_received", { "event": event }) # 检查事件合并 if self.event_config["enable_event_coalescing"]: if self._coalesce_event(event): # 事件已合并，不需要添加到队列 return True # 添加到相应队列 if priority > 0 and self.event_config["enable_event_prioritization"]: # 添加到优先级队列 try: self.priority_queue.put((priority, event), timeout=0.1) except queue.Full: self.event_stats["events_dropped"] += 1 self._trigger_event_callback("event_dropped", { "event": event, "reason": "priority_queue_full" }) return False else: # 添加到普通队列 try: self.event_queue.put(event, timeout=0.1) except queue.Full: self.event_stats["events_dropped"] += 1 self._trigger_event_callback("event_dropped", { "event": event, "reason": "queue_full" }) return False self.event_stats["events_received"] += 1 self.last_event_time = event.timestamp return True except Exception as e: print(f"✗ 事件发布失败: {e}") return False def _coalesce_event(self, event: NetworkEvent) -> bool: """ 合并事件 Args: event: 网络事件 Returns: 是否合并成功 """ try: if not self.event_config["enable_event_coalescing"]: return False current_time = time.time() coalesce_key = f"{event.event_type}_{hash(str(event.data))}" # 检查是否在合并时间窗口内 if coalesce_key in self.coalesce_cache: cached_event, cache_time = self.coalesce_cache[coalesce_key] if current_time - cache_time < self.event_config["coalesce_time_window"]: # 合并事件 self.event_stats["coalesced_events"] += 1 return True # 缓存事件 self.coalesce_cache[coalesce_key] = (event, current_time) return False except Exception as e: print(f"✗ 事件合并失败: {e}") return False def _cleanup_coalesce_cache(self, current_time: float): """ 清理合并缓存 Args: current_time: 当前时间 """ try: expired_keys = [ key for key, (_, cache_time) in self.coalesce_cache.items() if current_time - cache_time > self.event_config["coalesce_time_window"] * 2 ] for key in expired_keys: del self.coalesce_cache[key] except Exception as e: print(f"✗ 合并缓存清理失败: {e}") def register_event_handler(self, event_type: str, handler: Callable) -> bool: """ 注册事件处理器 Args: event_type: 事件类型 handler: 处理器函数 Returns: 是否注册成功 """ try: self.event_handlers[event_type] = handler print(f"✓ 事件处理器已注册: {event_type}") return True except Exception as e: print(f"✗ 事件处理器注册失败: {e}") return False def unregister_event_handler(self, event_type: str) -> bool: """ 注销事件处理器 Args: event_type: 事件类型 Returns: 是否注销成功 """ try: if event_type in self.event_handlers: del self.event_handlers[event_type] print(f"✓ 事件处理器已注销: {event_type}") return True else: print(f"✗ 事件处理器不存在: {event_type}") return False except Exception as e: print(f"✗ 事件处理器注销失败: {e}") return False def register_event_listener(self, event_type: str, listener: Callable) -> bool: """ 注册事件监听器 Args: event_type: 事件类型 listener: 监听器函数 Returns: 是否注册成功 """ try: if event_type not in self.event_listeners: self.event_listeners[event_type] = [] self.event_listeners[event_type].append(listener) print(f"✓ 事件监听器已注册: {event_type}") return True except Exception as e: print(f"✗ 事件监听器注册失败: {e}") return False def unregister_event_listener(self, event_type: str, listener: Callable) -> bool: """ 注销事件监听器 Args: event_type: 事件类型 listener: 监听器函数 Returns: 是否注销成功 """ try: if event_type in self.event_listeners: if listener in self.event_listeners[event_type]: self.event_listeners[event_type].remove(listener) print(f"✓ 事件监听器已注销: {event_type}") return True print(f"✗ 事件监听器不存在: {event_type}") return False except Exception as e: print(f"✗ 事件监听器注销失败: {e}") return False # 默认事件处理器 def _handle_network_connected(self, data: Dict[str, Any]) -> bool: """处理网络连接事件""" try: print(f"✓ 网络已连接: {data}") # 更新连接状态 if self.plugin.connection_manager: self.plugin.connection_manager.client_state["is_connected"] = True self.plugin.connection_manager.client_state["connection_time"] = time.time() return True except Exception as e: print(f"✗ 网络连接事件处理失败: {e}") return False def _handle_network_disconnected(self, data: Dict[str, Any]) -> bool: """处理网络断开事件""" try: print(f"✓ 网络已断开: {data}") # 更新连接状态 if self.plugin.connection_manager: self.plugin.connection_manager.client_state["is_connected"] = False self.plugin.connection_manager.client_state["connection_time"] = 0.0 return True except Exception as e: print(f"✗ 网络断开事件处理失败: {e}") return False def _handle_network_error(self, data: Dict[str, Any]) -> bool: """处理网络错误事件""" try: print(f"✗ 网络错误: {data}") # 记录错误统计 self.event_stats["handler_errors"] += 1 return True except Exception as e: print(f"✗ 网络错误事件处理失败: {e}") return False def _handle_network_data_received(self, data: Dict[str, Any]) -> bool: """处理网络数据接收事件""" try: # 将数据传递给协议处理器 if self.plugin.protocol_handler: self.plugin.protocol_handler.receive_message(data.get("message_data", b"")) return True except Exception as e: print(f"✗ 网络数据接收事件处理失败: {e}") return False def _handle_network_data_sent(self, data: Dict[str, Any]) -> bool: """处理网络数据发送事件""" try: # 可以在这里添加发送确认逻辑 return True except Exception as e: print(f"✗ 网络数据发送事件处理失败: {e}") return False def _handle_object_synced(self, data: Dict[str, Any]) -> bool: """处理对象同步事件""" try: object_id = data.get("object_id") object_data = data.get("object_data") # 更新对象状态 if self.plugin.object_sync and object_id and object_data: self.plugin.object_sync.update_object(object_id, object_data) return True except Exception as e: print(f"✗ 对象同步事件处理失败: {e}") return False def _handle_sync_error(self, data: Dict[str, Any]) -> bool: """处理同步错误事件""" try: print(f"✗ 同步错误: {data}") # 记录错误统计 self.event_stats["handler_errors"] += 1 return True except Exception as e: print(f"✗ 同步错误事件处理失败: {e}") return False def _handle_interpolation_updated(self, data: Dict[str, Any]) -> bool: """处理插值更新事件""" try: # 可以在这里添加插值更新后的处理逻辑 return True except Exception as e: print(f"✗ 插值更新事件处理失败: {e}") return False def _handle_extrapolation_updated(self, data: Dict[str, Any]) -> bool: """处理外推更新事件""" try: # 可以在这里添加外推更新后的处理逻辑 return True except Exception as e: print(f"✗ 外推更新事件处理失败: {e}") return False def _handle_client_connected(self, data: Dict[str, Any]) -> bool: """处理客户端连接事件""" try: client_id = data.get("client_id") address = data.get("address") print(f"✓ 客户端已连接: {client_id} ({address})") # 添加到连接管理器 if self.plugin.connection_manager and client_id and address: # 这里需要访问socket对象，简化处理 pass return True except Exception as e: print(f"✗ 客户端连接事件处理失败: {e}") return False def _handle_client_disconnected(self, data: Dict[str, Any]) -> bool: """处理客户端断开事件""" try: client_id = data.get("client_id") reason = data.get("reason", "unknown") print(f"✓ 客户端已断开: {client_id} (原因: {reason})") # 从连接管理器移除 if self.plugin.connection_manager and client_id: self.plugin.connection_manager.remove_client(client_id, reason) return True except Exception as e: print(f"✗ 客户端断开事件处理失败: {e}") return False def _handle_connection_timeout(self, data: Dict[str, Any]) -> bool: """处理连接超时事件""" try: client_id = data.get("client_id") print(f"✓ 连接超时: {client_id}") # 断开超时连接 if self.plugin.connection_manager and client_id: self.plugin.connection_manager.remove_client(client_id, "timeout") return True except Exception as e: print(f"✗ 连接超时事件处理失败: {e}") return False def _handle_message_received(self, data: Dict[str, Any]) -> bool: """处理消息接收事件""" try: message_type = data.get("type") message_data = data.get("data") print(f"✓ 消息已接收: {message_type}") # 根据消息类型处理 if message_type == "sync_data": # 处理同步数据 if self.plugin.object_sync and message_data: for obj_id, obj_data in message_data.items(): self.plugin.object_sync.receive_sync_data(obj_id, obj_data) elif message_type == "heartbeat": # 处理心跳包 if self.plugin.connection_manager: # 需要client_id来处理心跳 pass return True except Exception as e: print(f"✗ 消息接收事件处理失败: {e}") return False def _handle_message_sent(self, data: Dict[str, Any]) -> bool: """处理消息发送事件""" try: message_type = data.get("type") fragmented = data.get("fragmented", False) print(f"✓ 消息已发送: {message_type} ({'分片' if fragmented else '完整'})") return True except Exception as e: print(f"✗ 消息发送事件处理失败: {e}") return False def _handle_protocol_error(self, data: Dict[str, Any]) -> bool: """处理协议错误事件""" try: error = data.get("error", "Unknown protocol error") print(f"✗ 协议错误: {error}") # 记录错误统计 self.event_stats["handler_errors"] += 1 return True except Exception as e: print(f"✗ 协议错误事件处理失败: {e}") return False def _handle_sync_started(self, data: Dict[str, Any]) -> bool: """处理同步开始事件""" try: print("✓ 时钟同步已开始") return True except Exception as e: print(f"✗ 同步开始事件处理失败: {e}") return False def _handle_sync_completed(self, data: Dict[str, Any]) -> bool: """处理同步完成事件""" try: offset = data.get("offset", 0.0) rtt = data.get("rtt", 0.0) quality = data.get("quality", 0.0) print(f"✓ 时钟同步已完成 - 偏移: {offset:.3f}s, RTT: {rtt:.3f}s, 质量: {quality:.2f}") return True except Exception as e: print(f"✗ 同步完成事件处理失败: {e}") return False def _handle_sync_failed(self, data: Dict[str, Any]) -> bool: """处理同步失败事件""" try: reason = data.get("reason", "unknown") error = data.get("error", "") print(f"✗ 时钟同步失败 - 原因: {reason}, 错误: {error}") # 记录错误统计 self.event_stats["handler_errors"] += 1 return True except Exception as e: print(f"✗ 同步失败事件处理失败: {e}") return False def _handle_time_updated(self, data: Dict[str, Any]) -> bool: """处理时间更新事件""" try: server_time = data.get("server_time", 0.0) interpolated_time = data.get("interpolated_time", 0.0) # 可以在这里添加时间更新后的处理逻辑 return True except Exception as e: print(f"✗ 时间更新事件处理失败: {e}") return False def _handle_sync_quality_changed(self, data: Dict[str, Any]) -> bool: """处理同步质量变化事件""" try: quality = data.get("quality", 0.0) offset = data.get("offset", 0.0) rtt = data.get("rtt", 0.0) print(f"✓ 同步质量变化 - 质量: {quality:.2f}, 偏移: {offset:.3f}s, RTT: {rtt:.3f}s") return True except Exception as e: print(f"✗ 同步质量变化事件处理失败: {e}") return False def _handle_config_loaded(self, data: Dict[str, Any]) -> bool: """处理配置加载事件""" try: config = data.get("config", {}) timestamp = data.get("timestamp", 0.0) print(f"✓ 配置已加载 - 时间: {timestamp}") # 应用配置到各个模块 if self.plugin.config_manager: self.plugin.config_manager.apply_config_to_modules() return True except Exception as e: print(f"✗ 配置加载事件处理失败: {e}") return False def _handle_config_saved(self, data: Dict[str, Any]) -> bool: """处理配置保存事件""" try: config = data.get("config", {}) timestamp = data.get("timestamp", 0.0) print(f"✓ 配置已保存 - 时间: {timestamp}") return True except Exception as e: print(f"✗ 配置保存事件处理失败: {e}") return False def _handle_config_changed(self, data: Dict[str, Any]) -> bool: """处理配置变更事件""" try: section = data.get("section") key = data.get("key") old_value = data.get("old_value") new_value = data.get("new_value") print(f"✓ 配置已变更 - {section}.{key}: {old_value} -> {new_value}") # 应用配置变更到相应模块 if self.plugin.config_manager: self.plugin.config_manager.apply_config_to_modules() return True except Exception as e: print(f"✗ 配置变更事件处理失败: {e}") return False def _handle_config_error(self, data: Dict[str, Any]) -> bool: """处理配置错误事件""" try: error = data.get("error", "Unknown config error") operation = data.get("operation", "unknown") print(f"✗ 配置错误 - 操作: {operation}, 错误: {error}") # 记录错误统计 self.event_stats["handler_errors"] += 1 return True except Exception as e: print(f"✗ 配置错误事件处理失败: {e}") return False def _handle_data_serialized(self, data: Dict[str, Any]) -> bool: """处理数据序列化事件""" try: format = data.get("format", "unknown") size = data.get("size", 0) cached = data.get("cached", False) print(f"✓ 数据已序列化 - 格式: {format}, 大小: {size}字节 ({'缓存' if cached else '新'})") return True except Exception as e: print(f"✗ 数据序列化事件处理失败: {e}") return False def _handle_data_deserialized(self, data: Dict[str, Any]) -> bool: """处理数据反序列化事件""" try: format = data.get("format", "unknown") size = data.get("size", 0) print(f"✓ 数据已反序列化 - 格式: {format}, 大小: {size}字节") return True except Exception as e: print(f"✗ 数据反序列化事件处理失败: {e}") return False def _handle_serialization_error(self, data: Dict[str, Any]) -> bool: """处理序列化错误事件""" try: error = data.get("error", "Unknown serialization error") print(f"✗ 序列化错误: {error}") # 记录错误统计 self.event_stats["handler_errors"] += 1 return True except Exception as e: print(f"✗ 序列化错误事件处理失败: {e}") return False def _handle_deserialization_error(self, data: Dict[str, Any]) -> bool: """处理反序列化错误事件""" try: error = data.get("error", "Unknown deserialization error") print(f"✗ 反序列化错误: {error}") # 记录错误统计 self.event_stats["handler_errors"] += 1 return True except Exception as e: print(f"✗ 反序列化错误事件处理失败: {e}") return False def _handle_prediction_updated(self, data: Dict[str, Any]) -> bool: """处理预测更新事件""" try: object_id = data.get("object_id") prediction_time = data.get("prediction_time", 0.0) print(f"✓ 预测已更新 - 对象: {object_id}, 时间: {prediction_time:.3f}") return True except Exception as e: print(f"✗ 预测更新事件处理失败: {e}") return False def _handle_correction_applied(self, data: Dict[str, Any]) -> bool: """处理校正应用事件""" try: object_id = data.get("object_id") error = data.get("error", 0.0) print(f"✓ 校正已应用 - 对象: {object_id}, 误差: {error:.3f}") return True except Exception as e: print(f"✗ 校正应用事件处理失败: {e}") return False def _handle_snap_correction(self, data: Dict[str, Any]) -> bool: """处理快照校正事件""" try: object_id = data.get("object_id") error = data.get("error", 0.0) print(f"✓ 快照校正 - 对象: {object_id}, 误差: {error:.3f}") return True except Exception as e: print(f"✗ 快照校正事件处理失败: {e}") return False def _handle_prediction_error(self, data: Dict[str, Any]) -> bool: """处理预测错误事件""" try: object_id = data.get("object_id") error = data.get("error", "") print(f"✗ 预测错误 - 对象: {object_id}, 错误: {error}") # 记录错误统计 self.event_stats["handler_errors"] += 1 return True except Exception as e: print(f"✗ 预测错误事件处理失败: {e}") return False def get_event_stats(self) -> Dict[str, int]: """ 获取事件统计信息 Returns: 事件统计字典 """ return self.event_stats.copy() def reset_event_stats(self): """重置事件统计信息""" try: self.event_stats = { "events_received": 0, "events_processed": 0, "events_dropped": 0, "events_timed_out": 0, "handler_errors": 0, "async_tasks": 0, "coalesced_events": 0 } print("✓ 事件统计信息已重置") except Exception as e: print(f"✗ 事件统计信息重置失败: {e}") def set_event_config(self, config: Dict[str, Any]) -> bool: """ 设置事件配置 Args: config: 事件配置字典 Returns: 是否设置成功 """ try: self.event_config.update(config) print(f"✓ 事件配置已更新: {self.event_config}") return True except Exception as e: print(f"✗ 事件配置设置失败: {e}") return False def get_event_config(self) -> Dict[str, Any]: """ 获取事件配置 Returns: 事件配置字典 """ return self.event_config.copy() def _trigger_event_callback(self, callback_type: str, data: Dict[str, Any]): """ 触发事件回调 Args: callback_type: 回调类型 data: 回调数据 """ try: if callback_type in self.event_callbacks: for callback in self.event_callbacks[callback_type]: try: callback(data) except Exception as e: print(f"✗ 事件回调执行失败: {e}") except Exception as e: print(f"✗ 事件回调触发失败: {e}") def register_event_callback(self, callback_type: str, callback: Callable): """ 注册事件回调 Args: callback_type: 回调类型 callback: 回调函数 """ try: if callback_type in self.event_callbacks: self.event_callbacks[callback_type].append(callback) print(f"✓ 事件回调已注册: {callback_type}") else: print(f"✗ 无效的回调类型: {callback_type}") except Exception as e: print(f"✗ 事件回调注册失败: {e}") def unregister_event_callback(self, callback_type: str, callback: Callable): """ 注销事件回调 Args: callback_type: 回调类型 callback: 回调函数 """ try: if callback_type in self.event_callbacks: if callback in self.event_callbacks[callback_type]: self.event_callbacks[callback_type].remove(callback) print(f"✓ 事件回调已注销: {callback_type}") except Exception as e: print(f"✗ 事件回调注销失败: {e}") def clear_event_queue(self): """清空事件队列""" try: # 清空普通队列 while not self.event_queue.empty(): try: self.event_queue.get_nowait() except queue.Empty: break # 清空优先级队列 while not self.priority_queue.empty(): try: self.priority_queue.get_nowait() except queue.Empty: break print("✓ 事件队列已清空") except Exception as e: print(f"✗ 事件队列清空失败: {e}") def get_queue_size(self) -> Dict[str, int]: """ 获取队列大小 Returns: 队列大小字典 """ return { "event_queue": self.event_queue.qsize(), "priority_queue": self.priority_queue.qsize() }