Files
CPY_AlgorithmGateway/mqtt_client.py
T

389 lines
14 KiB
Python

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