import paho.mqtt.client as mqtt from paho.mqtt.enums import CallbackAPIVersion import logging import json import ssl import socket from typing import Callable, Optional, Dict, Any import threading import time from config import config_manager logger = logging.getLogger(__name__) class ConnectionState: DISCONNECTED = "disconnected" CONNECTING = "connecting" CONNECTED = "connected" class MqttClient: """MQTT客户端封装类""" def __init__(self): """初始化MQTT客户端""" self.client = None self.device_id = None # 状态机相关 self._state = ConnectionState.DISCONNECTED self._state_lock = threading.Lock() # 定时器相关 self._reconnect_timer = None self._reconnect_interval = 5 self._min_reconnect_interval = 5 self._max_reconnect_interval = 10 # 退避相关 self._backoff_factor = 2 self._current_backoff = 0 # 回调函数 self.on_connect_callback = None self.on_message_callback = None self.on_disconnect_callback = None # 订阅的主题列表 self.subscribed_topics = set() # MQTT配置缓存 self._broker = config_manager.get('mqtt.broker', '127.0.0.1') self._port = config_manager.get('mqtt.port', 1883) self._keepalive = config_manager.get('mqtt.keepalive', 60) # 初始化客户端 self._init_client() def _init_client(self): """初始化MQTT客户端""" try: username = config_manager.get('mqtt.username', '') password = config_manager.get('mqtt.password', '') use_ssl = config_manager.get('mqtt.use_ssl', True) use_ca = config_manager.get('mqtt.use_ca', False) logger.info(f"use_ssl {use_ssl}, use_ca {use_ca}") server_id = config_manager.get('server_id', '1') device_name = socket.gethostbyname(socket.gethostname()) self.client = mqtt.Client(client_id=f"cpy_gateway_{server_id}_{device_name}", \ callback_api_version=CallbackAPIVersion.VERSION2, clean_session=True) logger.info(f"cpy_gateway_{server_id}_{device_name}") if username and password: self.client.username_pw_set(username, password) if use_ca: ca_file = config_manager.get('mqtt.ca_file', '.ca.cert') self.client.tls_set(cert_reqs=ca_file) self.client.tls_insecure_set(False) elif use_ssl: logger.info(f"use mqtts without ca") self.client.tls_set(cert_reqs=ssl.CERT_NONE) self.client.tls_insecure_set(True) self.client.on_connect = self._on_connect self.client.on_message = self._on_message self.client.on_disconnect = self._on_disconnect logger.info(f"MQTT client initialized for broker {self._broker}:{self._port}") except Exception as e: logger.error(f"Failed to initialize MQTT client: {e}") raise def _set_state(self, new_state: str): """设置连接状态(线程安全)""" with self._state_lock: old_state = self._state self._state = new_state logger.debug(f"State changed: {old_state} -> {new_state}") def _get_state(self) -> str: """获取连接状态(线程安全)""" with self._state_lock: return self._state def _socket_check(self) -> bool: """Socket连通性预检 Returns: bool: 连通性检查是否通过 """ try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(3) s.connect((self._broker, self._port)) s.close() logger.debug(f"Socket check passed for {self._broker}:{self._port}") return True except socket.timeout: logger.debug(f"Socket check timeout for {self._broker}:{self._port}") return False except Exception as e: logger.debug(f"Socket check failed for {self._broker}:{self._port}: {e}") return False def _schedule_reconnect(self): """调度下一次重连尝试""" if self._current_backoff == 0: self._current_backoff = self._min_reconnect_interval else: self._current_backoff = min(self._current_backoff * self._backoff_factor, self._max_reconnect_interval) logger.debug(f"Scheduling reconnect in {self._current_backoff} seconds") self._reconnect_timer = threading.Timer(self._current_backoff, self._on_reconnect_timer) self._reconnect_timer.start() def _cancel_reconnect(self): """取消重连定时器""" if self._reconnect_timer: self._reconnect_timer.cancel() self._reconnect_timer = None def _reset_backoff(self): """重置退避间隔""" self._current_backoff = 0 def _on_reconnect_timer(self): """重连定时器回调""" state = self._get_state() if state != ConnectionState.DISCONNECTED: logger.debug(f"Ignoring reconnect timer, current state: {state}") return logger.info(f"Attempting to reconnect (attempt in {self._current_backoff}s)...") if not self._socket_check(): logger.warning(f"Socket check failed, will retry later") self._schedule_reconnect() return try: self._set_state(ConnectionState.CONNECTING) logger.info(f"Connecting to MQTT broker {self._broker}:{self._port}...") self.client.connect_async(self._broker, self._port, self._keepalive) if not hasattr(self, '_loop_started') or not self._loop_started: self.client.loop_start() self._loop_started = True except Exception as e: logger.error(f"Failed to initiate connection: {e}") self._set_state(ConnectionState.DISCONNECTED) self._schedule_reconnect() def connect(self) -> bool: """启动MQTT连接流程 非阻塞调用,启动重连定时器,实际连接在定时器回调中完成 Returns: bool: 定时器是否成功启动 """ try: state = self._get_state() if state == ConnectionState.CONNECTED: logger.warning("Already connected, ignoring connect request") return True if state == ConnectionState.CONNECTING: logger.warning("Already connecting, ignoring connect request") return True self._reset_backoff() self._schedule_reconnect() logger.info("MQTT connection process started") return True except Exception as e: logger.error(f"Failed to start connection process: {e}") return False def disconnect(self): """断开MQTT连接""" try: self._cancel_reconnect() if self.client: self.client.loop_stop() self.client.disconnect() self._set_state(ConnectionState.DISCONNECTED) logger.info("Disconnected from MQTT broker") except Exception as e: logger.error(f"Error disconnecting from MQTT broker: {e}") def publish(self, topic: str, payload: Any, qos: int = 0, retain: bool = False) -> bool: """发布消息到指定主题""" try: if self._get_state() != ConnectionState.CONNECTED: logger.warning("MQTT client not connected, cannot publish") return False if isinstance(payload, dict): payload = json.dumps(payload) result = self.client.publish(topic, payload, qos, retain) if result.rc == mqtt.MQTT_ERR_SUCCESS: logger.debug(f"Published to {topic}: {payload}") return True else: logger.error(f"Failed to publish to {topic}, rc={result.rc}") return False except Exception as e: logger.error(f"Error publishing to {topic}: {e}") return False def subscribe(self, topic: str, qos: int = 0) -> bool: """订阅主题""" try: if self._get_state() != ConnectionState.CONNECTED: logger.warning("MQTT client not connected, cannot subscribe") return False result = self.client.subscribe(topic, qos) if result[0] == mqtt.MQTT_ERR_SUCCESS: self.subscribed_topics.add(topic) logger.info(f"Subscribed to {topic}") return True else: logger.error(f"Failed to subscribe to {topic}, rc={result[0]}") return False except Exception as e: logger.error(f"Error subscribing to {topic}: {e}") return False def unsubscribe(self, topic: str) -> bool: """取消订阅主题""" try: if self._get_state() != ConnectionState.CONNECTED: logger.warning("MQTT client not connected, cannot unsubscribe") return False result = self.client.unsubscribe(topic) if result[0] == mqtt.MQTT_ERR_SUCCESS: self.subscribed_topics.discard(topic) logger.info(f"Unsubscribed from {topic}") return True else: logger.error(f"Failed to unsubscribe from {topic}, rc={result[0]}") return False except Exception as e: logger.error(f"Error unsubscribing from {topic}: {e}") return False def _on_connect(self, client, userdata, flags, rc, props): """连接回调函数""" if rc == 0: self._set_state(ConnectionState.CONNECTED) self._reset_backoff() logger.info(f"Connected to MQTT broker with result code {rc}") self._subscribe_default_topics() if self.on_connect_callback: self.on_connect_callback(client, userdata, flags, rc) else: self._set_state(ConnectionState.DISCONNECTED) logger.error(f"Failed to connect to MQTT broker, result code {rc}") self._schedule_reconnect() def _on_message(self, client, userdata, msg): """消息接收回调函数""" try: topic = msg.topic payload = msg.payload.decode() logger.debug(f"Received message on {topic}: {payload}") if self.on_message_callback: thread = threading.Thread(target=self.on_message_callback, args=(client, userdata, msg)) thread.start() except Exception as e: logger.error(f"Error processing message: {e}") def _on_disconnect(self, client, userdata, rc, props, flags): """断开连接回调函数""" current_state = self._get_state() if current_state == ConnectionState.CONNECTED or current_state == ConnectionState.CONNECTING: self._set_state(ConnectionState.DISCONNECTED) logger.info(f"Disconnected from MQTT broker with result code {rc}") if self.on_disconnect_callback: self.on_disconnect_callback(client, userdata, rc) self._schedule_reconnect() def _subscribe_default_topics(self): """订阅默认主题""" try: topic_prefix = config_manager.get('mqtt.topic_prefix', 'v1/cpycal/') server_id = config_manager.get('server_id', '1') control_topic = f"{topic_prefix}{server_id}" self.subscribe(control_topic) logger.info(f"Subscribed to default topics for device {server_id}") except Exception as e: logger.error(f"Error subscribing to default topics: {e}") def get_status_topic(self) -> str: """获取状态主题""" topic_prefix = config_manager.get('mqtt.topic_prefix', 'v1/cpycal/') server_id = config_manager.get('server_id', '1') return f"{topic_prefix}{server_id}/status" def get_control_topic(self) -> str: """获取控制主题""" topic_prefix = config_manager.get('mqtt.topic_prefix', 'v1/cpycal/') server_id = config_manager.get('server_id', '1') return f"{topic_prefix}{server_id}/control" def get_data_topic(self) -> str: """获取数据主题""" topic_prefix = config_manager.get('mqtt.topic_prefix', 'v1/cpycal/') server_id = config_manager.get('server_id', '1') return f"{topic_prefix}{server_id}/data" def publish_status(self, status: Dict[str, Any]) -> bool: """发布状态消息""" topic = self.get_status_topic() return self.publish(topic, status, qos=1, retain=True) def publish_data(self, data: Dict[str, Any]) -> bool: """发布数据消息""" topic = self.get_data_topic() return self.publish(topic, data, qos=0, retain=False) def set_callbacks(self, on_connect: Optional[Callable] = None, on_message: Optional[Callable] = None, on_disconnect: Optional[Callable] = None): """设置回调函数""" if on_connect: self.on_connect_callback = on_connect if on_message: self.on_message_callback = on_message if on_disconnect: self.on_disconnect_callback = on_disconnect def is_connected(self) -> bool: """检查是否已连接""" return self._get_state() == ConnectionState.CONNECTED