mm_os 4.2.6 → 4.2.8

package/com/mqtt/index.js

@@ -1,822 +1,1012 @@
-const Mqtt_client = require('mqtt');
-const Manager = require('mm_machine').Manager;
-const Drive = require('./drive');
-
-/**
- * Mqtt通讯类
- * @augments {Manager}
- * @class
- */
-class Mqtt extends Manager {
-  /**
-   * 配置参数
-   * @type {object}
-   */
-  static config = {
-    /**
-     * 名称
-     * @type {string}
-     */
-    name: '',
-    /**
-     * 标题
-     * @type {string}
-     */
-    title: 'Mqtt通讯类',
-    /**
-     * 描述
-     * @type {string}
-     */
-    description: '这是Mqtt通讯类管理器',
-    /**
-     * 检索文件名
-     * @type {string}
-     */
-    filename: 'mqtt.json',
-    /**
-     * 模板目录
-     * @type {string}
-     */
-    tpl_dir: __dirname,
-    /**
-     * 基础目录
-     * @type {string}
-     */
-    base_dir: '../common/mqtt'.fullname(__dirname),
-    /**
-     * 自定义目录，加载项目自定义资源
-     * @type {string}
-     */
-    dir: './app'.fullname(),
-    /**
-     * 搜索模式 dir按目录搜索 | file按文件名搜索
-     * @type {string}
-     */
-    search_way: 'file',
-    /**
-     * 是否懒加载
-     * @type {boolean}
-     */
-    lazy_load: true,
-    /**
-     * 模式
-     * 1.生产模式，改变文件不会重新加载
-     * 2.热更新模式，改变配置文件会重新加载配置，不重新加载脚本
-     * 3.热重载模式，改变配置文件都会加载配置和脚本
-     * 4.重载模式，执行完后重新加载脚本，避免变量污染
-     * 5.热更新+重载模式，改变配置文件重新加载配置和脚本，执行完后重新加载脚本
-     * @type {number}
-     */
-    mode: 3,
-    hostname: '127.0.0.1',
-    port: '1883',
-    protocol: 'mqtt',
-    client_id: 'server',
-    subscribe_qos: 2,
-    publish_qos: 2,
-    username: 'server',
-    password: 'asd123',
-    table: 'iot_device',
-    clean: false,
-    longtime: 15000,
-    request_timeout: 3000,
-    // 在线有效期时长判断 单位：毫秒，150000毫秒为2.5分钟
-    online_expires: 150000,
-    // 在线有效期检测间隔
-    online_interval: 10000,
-    // 连接超时 
-    connect_timeout: 30000,
-    // maxInflight: 20,
-    // 重连间隔
-    reco_period: 6000 // 重连间隔1秒
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} parent 父级模块
-   */
-  constructor(config, parent) {
-    super({ ...Mqtt.config, ...config }, parent);
-  }
-}
-
-/**
- * 预置
- */
-Mqtt.prototype._preset = function () {
-  this.dict = {};
-  // 定时器
-  this.timer = null;
-  // mqtt客户端服务器
-  this.client = null;
-  /**
-   * message queue
-   */
-  this.list_msg = [
-    /*
-    {
-      // information ID
-      id: "",
-      // request method
-      method: "",
-      // message parameters
-      params: {},
-      // Callback
-      func: function(res){}
-    }
-    */
-  ];
-
-  /**
-   * 订阅集合 (主题 => 函数列表)
-   */
-  this.dict_subscribe = {};
-
-  /**
-   * method collection
-   */
-  var _this = this;
-  this.methods = {
-    /**
-     * 获取所有方法
-     * @returns {Array} 函数列表
-     */
-    getMethod: function () {
-      return Object.keys(_this.methods);
-    }
-  };
-
-  this.retry_times = 0;
-  this.connecting = false;
-  this._createClient();
-}
-
-/**
- * mqtt驱动类
- * @type {Drive}
- */
-Mqtt.prototype.Drive = Drive;
-
-/**
- * 主题匹配
- * @param {string} topic 接收到的主题
- * @param {string} top 匹配用的主题
- * @returns {boolean} 返回匹配结果，正确返回true，错误返回false 
- */
-Mqtt.prototype.match = function (topic, top) {
-  if (topic === top) {
-    return true;
-  }
-  var str = '^' + top.replace('#', '.*').replace('+', '~~~').replace('~~~', '[a-zA-Z0-9_-]+').replace('$', '~~~')
-    .replace('~~~', '\\$');
-  var s = str.substring(str.length - 1, str.length);
-  if (s !== '#') {
-    str += '$';
-  }
-  var mh = new RegExp(str);
-  return mh.test(topic);
-};
-
-/**
- * 初始化
- */
-Mqtt.prototype.updateAfter = async function () {
-  var _this = this;
-  let infos = this.getInfos();
-  for (var i = 0; i < infos.length; i++) {
-    var info = infos[i];
-    if (info.state === 1) {
-      let mod = this.getMod(info.name);
-      if (mod) {
-        mod.send = function (topic, msg, qos = 0, retain = false) {
-          if (topic) {
-            _this.send(topic, msg, qos, retain);
-          }
-        };
-        await mod.do('init');
-        var topics = mod.config.topic;
-        if (topics) {
-          for (var n = 0; n < topics.length; n++) {
-            var tc = topics[n];
-            var retain = mod.config.retain || false;
-            var qos = mod.config.qos || 0;
-            if (tc.indexOf('heartbeat') !== -1) {
-              retain = false;
-              qos = 0;
-            }
-            this.subscribe(tc, null, qos, retain);
-          }
-        }
-      }
-    }
-  }
-};
-
-/**
- * 重新连接
- */
-Mqtt.prototype.reconnect = function () {
-  // $.sleep(this.config.interval);
-  // this.retryTimes += 1;
-  // if (this.retryTimes > 5) {
-  //   try {
-  //     this.client.end();
-  //     this.init();
-  //   } catch (error) {
-  //     this.$message.error(error.toString());
-  //   }
-  // }
-};
-
-/**
- * 初始化
- * @param {object} config 配置参数
- */
-Mqtt.prototype.init = function (config) {
-  this.config = Object.assign(this.config, config);
-  this.retry_times = 0;
-  this.connecting = false;
-};
-
-/**
- * 运行Mqtt
- * @returns {Promise} 连接结果
- */
-Mqtt.prototype.start = function () {
-  setTimeout(() => {
-    this.startTimer();
-  }, 2000);
-
-  this.connecting = true;
-
-  try {
-    this._createClient();
-
-    if (this.client && this.client.on) {
-      return this._setupClientEvents();
-    }
-  } catch (error) {
-    this.connecting = false;
-    return this._rejectPromise(error);
-  }
-
-  return this._rejectPromise();
-};
-
-/**
- * 创建客户端
- * @private
- */
-Mqtt.prototype._createClient = function () {
-  var cg = { ...this.config };
-  cg.clientId = cg.client_id;
-  if (cg.host) {
-    delete cg.hostname;
-    delete cg.port;
-    this.client = Mqtt_client.connect(cg.host, cg);
-  } else {
-    this.client = Mqtt_client.connect(cg);
-  }
-};
-
-/**
- * 设置客户端事件
- * @returns {Promise} 连接结果
- * @private
- */
-Mqtt.prototype._setupClientEvents = function () {
-  return new Promise((resolve, reject) => {
-    this.client.on('connect', (packet, err) => {
-      this.connecting = false;
-      if (err) {
-        resolve(null);
-        reject(err);
-      } else {
-        this.client.on('message', async (topic, message) => {
-          await this.receive(topic, message.toString());
-        });
-        resolve(packet);
-      }
-    });
-    this.client.on('reconnect', () => {
-      this.reconnect();
-    });
-    this.client.on('error', (error) => {
-      console.error('Connection failed', error);
-    });
-  });
-};
-
-/**
- * 创建被拒绝的Promise
- * @param {Error} error 错误对象
- * @returns {Promise} 被拒绝的Promise
- * @private
- */
-Mqtt.prototype._rejectPromise = function (error) {
-  return new Promise((resolve, reject) => {
-    resolve(null);
-    reject(error);
-  });
-};
-
-/**
- * 监听事件
- * @param {string} topic 事件名称
- * @param {Function} func 回调函数
- */
-Mqtt.prototype.on = function (topic, func) {
-  this.client.on(topic, func);
-};
-
-/**
- * 接收消息
- * @param {string} topic 订阅板块
- * @param {object} msg 消息主体
- */
-Mqtt.prototype.message = async function (topic, msg) {
-  if (this.dict_subscribe[topic]) {
-    var list = this.dict_subscribe[topic];
-    try {
-      for (var key in list) {
-        list[key](msg);
-      }
-    } catch (err) {
-      console.error(err);
-    }
-  }
-};
-
-/**
- * 接收消息
- * @param {string} push_topic 推送过来的主题
- * @param {object} message 消息主体
- * @returns {object} 解析后的消息主体
- */
-Mqtt.prototype.receive = async function (push_topic, message) {
-  var msg = this._parseMessage(message, push_topic);
-  if (msg === null) {
-    return;
-  }
-
-  // 处理消息回复
-  this._handleResponse(msg);
-
-  var ret = await this._processTopics(push_topic, msg);
-  try {
-    await this.message(ret.topic, msg);
-  } catch (error) {
-    this.log('error', 'mqtt处理程序错误', error);
-    return;
-  }
-  return ret.result;
-};
-
-/**
- * 解析消息
- * @param {object} message 消息主体
- * @param {string} push_topic 推送过来的主题
- * @returns {object|null} 解析后的消息
- * @private
- */
-Mqtt.prototype._parseMessage = function (message, push_topic) {
-  var msg = {};
-  if (message && (message.indexOf('[') === 0 || message.indexOf('{') === 0)) {
-    try {
-      msg = JSON.parse(message);
-    } catch (error) {
-      this.log('error', '消息结构体不对', push_topic, error);
-      return null;
-    }
-  }
-  return msg;
-};
-
-/**
- * 处理主题
- * @param {string} push_topic 推送过来的主题
- * @param {object} msg 消息主体
- * @returns {object} 处理结果和主题
- * @private
- */
-Mqtt.prototype._processTopics = async function (push_topic, msg) {
-  var ret;
-  var topic;
-  var mods = this.getMods();
-  for (var k in mods) {
-    var o = mods[k];
-    if (o.config.state !== 1) {
-      continue;
-    }
-    var topics = o.config.topic;
-    if (!topics) {
-      continue;
-    }
-    for (var n = 0; n < topics.length; n++) {
-      topic = topics[n];
-      if (this.match(push_topic, topic)) {
-        ret = await o.call('handle', push_topic, msg, topic, n);
-      }
-    }
-  }
-  return { result: ret, topic };
-};
-
-/**
- * 订阅主题
- * @param {string} topic 主题
- * @param {Function} func 回调函数
- * @param {number} qos 推送方式 0
- * @param {boolean} retain 保持
- * @returns {string} 主键
- */
-Mqtt.prototype.subscribe = function (topic, func, qos = null, retain = false) {
-  if (!this.client) {
-    return '';
-  }
-  this.client.subscribe(topic, {
-    // 订阅消息方式，0为保留 ， 1为确认收到1次
-    qos: qos || this.config.subscribe_qos || 0,
-    retain
-  });
-  if (func) {
-    if (!this.dict_subscribe[topic]) {
-      this.dict_subscribe[topic] = {};
-    }
-    var key = this.key_num + 1;
-    this.dict_subscribe[topic][key] = func;
-    return key;
-  }
-  return '';
-};
-
-/**
- * 取消订阅
- * @param {string} topic 主题
- * @param {string} key 主键
- */
-Mqtt.prototype.unsubscribe = function (topic, key) {
-  this.client.unsubscribe(topic);
-  if (this.dict_subscribe[topic]) {
-    delete this.dict_subscribe[topic][key];
-  }
-};
-
-/**
- * 结束客户端
- */
-Mqtt.prototype.end = function () {
-  if (this.client) {
-    this.client.end();
-  }
-  if (this.timer) {
-    clearInterval(this.timer);
-    this.timer = null;
-  }
-};
-
-/**
- * 发布主题
- * @param {string} topic 主题
- * @param {object} message 消息对象
- * @param {number} qos 推送方式 0
- * @param {boolean} retain 保持
- */
-Mqtt.prototype.publish = function (topic, message, qos = null, retain = false) {
-  this.client.publish(topic, message, {
-    qos: qos || this.config.publish_qos || 0,
-    retain
-  });
-};
-
-/**
- * 主题推送
- * @param {string} topic 主题
- * @param {string} msg_obj 消息主体
- * @param {number} qos 推送方式 0
- * @param {boolean} retain 保持
- */
-Mqtt.prototype.send = function (topic, msg_obj, qos = null, retain = false) {
-  this.publish(topic, JSON.stringify(msg_obj), qos, retain);
-};
-
-/**
- * 生成ID
- * @param {string} clientId 客户端ID
- * @returns {string} ID
- */
-Mqtt.prototype.genId = function (clientId) {
-  return clientId + '_' + Date.parse(new Date());
-};
-
-/**
- * 请求
- * @param {string} topic 主题
- * @param {string} method 请求方法
- * @param {object} params 请求参数
- * @param {Function} func 回调函数
- * @param {number} timeout 超时时间（毫秒）
- */
-Mqtt.prototype.req = function (topic, method, params, func, timeout = 0) {
-  var data = {
-    id: this.genId(this.client.options.clientId),
-    method,
-    params
-  };
-
-  if (func) {
-    data.func = func;
-    data.timestamp = Date.now();
-    data.timeout = timeout || this.config.request_timeout || 3000;
-    this.list_msg.push(data);
-
-    // 设置超时移除定时器
-    var _this = this;
-    data.timer = setTimeout(() => {
-      _this._delMsgById(data.id);
-    }, data.timeout);
-  }
-  this.send(topic, data);
-};
-
-/**
- * 同步请求 - 可及时取回消息
- * @param {string} topic 订阅板块
- * @param {string} method 请求方法
- * @param {object} params 传递参数
- * @param {number} timeout 超时时间 0为默认值 10000ms
- * @returns {object} 返回响应结果
- */
-Mqtt.prototype.reqAsync = function (topic, method, params, timeout = 0) {
-  var _this = this;
-  return new Promise((resolve, reject) => {
-    _this.req(topic, method, params, (res) => {
-      resolve(res);
-    }, timeout);
-  });
-};
-
-/**
- * 根据ID移除消息
- * @param {string} msg_id 消息ID
- * @private
- */
-Mqtt.prototype._delMsgById = function (msg_id) {
-  for (var i = 0; i < this.list_msg.length; i++) {
-    if (this.list_msg[i].id === msg_id) {
-      // 清除定时器
-      if (this.list_msg[i].timer) {
-        clearTimeout(this.list_msg[i].timer);
-      }
-      this.list_msg.splice(i, 1);
-      break;
-    }
-  }
-};
-
-/**
- * 处理消息回复
- * @param {object} msg 回复消息
- * @private
- */
-Mqtt.prototype._handleResponse = function (msg) {
-  if (!msg || !msg.id) {
-    return;
-  }
-
-  for (var i = 0; i < this.list_msg.length; i++) {
-    let o = this.list_msg[i];
-    if (o.id === msg.id && o.func) {
-      try {
-        // 执行回调函数
-        o.func(msg);
-      } catch (error) {
-        console.error('MQTT回调函数执行错误:', error);
-      }
-
-      // 从列表中移除已处理的消息
-      this._delMsgById(o.id);
-      break;
-    }
-  }
-};
-
-/**
- * 保存在线到数据库
- * @param {Array} arr 客户端ID数组
- * @param {number} online 在线情况 0为不在线，1为在线
- */
-Mqtt.prototype.saveOnline = async function (arr, online = 1) {
-  if (!arr || !arr.length) {
-    return;
-  }
-  var body = {
-    online
-  };
-  var db = $.admin.sql('sys').db();
-  db.table = this.config.table || 'iot_device';
-  db.size = 0;
-  var query = {};
-  query.clientid_has = arr.join(',');
-  await db.set(query, body);
-};
-
-/**
- * 获取所有设备
- * @returns {Array} 设备列表
- */
-Mqtt.prototype.getClients = async function () {
-  var db = $.admin.sql('sys').db();
-  db.table = this.config.table || 'iot_device';
-  db.size = 0;
-  return await db.get({}, '', 'clientid, online');
-};
-
-/**
- * 更新在线设备
- */
-Mqtt.prototype.updateOnline = async function () {
-  var now = new Date().getTime();
-  var online_expires = this.config.online_expires; // 180 
-
-  // 获取所有客户端
-  var drives = await this.getClients();
-  var { list_online, list_offline } = this._processDeviceStatus(drives, now, online_expires);
-
-  // 处理未出现的设备
-  // this._processUnseenDevices(drives, list_offline, list_has);
-
-  // 批量更新设备状态
-  await this._updateDeviceStatus(list_offline, list_online);
-};
-
-/**
- * 处理设备状态
- * @param {Array} drives 设备列表
- * @param {number} now 当前时间戳
- * @param {number} online_expires 在线过期时间
- * @returns {object} 在线和离线设备列表
- * @private
- */
-Mqtt.prototype._processDeviceStatus = function (drives, now, online_expires) {
-  var list_online = [];
-  var list_offline = [];
-  var list_has = [];
-
-  var mods = this.getMods();
-  for (var k in mods) {
-    var o = mods[k];
-    var dict = o.drives;
-    for (var clientid in dict) {
-      list_has.push(clientid);
-      var drive = drives.getObj({ clientid });
-      var o = dict[clientid];
-
-      if (o.online === 1) {
-        this._onlineDevice(
-          o, drive, clientid, now, online_expires,
-          list_online, list_offline, dict
-        );
-      } else {
-        this._offlineDevice(drive, clientid, list_offline);
-      }
-    }
-  }
-
-  return { list_online, list_offline, list_has };
-};
-
-/**
- * 处理在线设备
- * @param {object} device 设备对象
- * @param {object} drive 数据库中的设备信息
- * @param {string} clientid 设备ID
- * @param {number} now 当前时间戳
- * @param {number} online_expires 在线过期时间
- * @param {Array} list_online 在线设备列表
- * @param {Array} list_offline 离线设备列表
- * @param {object} dict 设备字典
- * @private
- */
-/* eslint-disable no-param-reassign */
-Mqtt.prototype._onlineDevice = function (
-  device, drive, clientid, now, online_expires,
-  list_online, list_offline, dict
-) {
-  if (device.time_last) {
-    var cha = now - device.time_last;
-    if (cha > online_expires) {
-      if (drive && drive.online) {
-        list_offline.push(clientid);
-      }
-      // 这里需要修改设备状态，但由于参数修改限制，我们直接修改字典
-      // 注意：这里仍然会修改外部对象，但这是业务逻辑需要
-      device.online = 0;
-      delete dict[clientid];
-    } else {
-      if (drive && !drive.online) {
-        list_online.push(clientid);
-      }
-    }
-  }
-};
-/* eslint-enable no-param-reassign */
-
-/**
- * 处理离线设备
- * @param {object} drive 数据库中的设备信息
- * @param {string} clientid 设备ID
- * @param {Array} list_offline 离线设备列表
- * @private
- */
-Mqtt.prototype._offlineDevice = function (drive, clientid, list_offline) {
-  if (drive && drive.online) {
-    list_offline.push(clientid);
-  }
-};
-
-/**
- * 处理未出现的设备
- * @param {Array} drives 设备列表
- * @param {Array} list_offline 离线设备列表
- * @param {Array} list_has 已处理的设备ID列表
- * @private
- */
-Mqtt.prototype._processUnseenDevices = function (drives, list_offline, list_has) {
-  // 处理未出现的设备
-  for (var i = 0; i < drives.length; i++) {
-    var { clientid, online } = drives[i];
-    if (online && list_has.indexOf(clientid) === -1) {
-      list_offline.push(clientid);
-    }
-  }
-};
-
-/**
- * 更新设备状态
- * @param {Array} list_offline 离线设备列表
- * @param {Array} list_online 在线设备列表
- * @private
- */
-Mqtt.prototype._updateDeviceStatus = async function (list_offline, list_online) {
-  // 先将设备离线
-  var list_off = list_offline.to2D(30);
-  for (var i = 0; i < list_off.length; i++) {
-    await this.saveOnline(list_off[i], 0);
-  }
-
-  // 再将设备在线
-  var list_on = list_online.to2D(30);
-  for (var i = 0; i < list_on.length; i++) {
-    await this.saveOnline(list_on[i], 1);
-  }
-};
-
-/**
- * 开始计时器
- */
-Mqtt.prototype.startTimer = function () {
-  if (!this.timer) {
-    this.timer = setInterval(() => {
-      try {
-        this.updateOnline();
-      } catch (err) {
-        console.error('更新在线设备失败', err);
-      }
-    }, this.config.online_interval);
-  }
-};
-
-exports.Mqtt = Mqtt;
-
-
-/**
- * 创建全局管理器
- */
-if (!$.pool.mqtt) {
-  $.pool.mqtt = {};
-}
-
-function mqttAdmin(scope, title) {
-  var sc = scope || $.val.scope + '';
-  var obj = $.pool.mqtt[sc];
-  if (!obj) {
-    $.pool.mqtt[sc] = new Mqtt({
-      name: sc,
-      title: title
-    });
-    obj = $.pool.mqtt[sc];
-  }
-  return obj;
-}
-
-/**
- * mqtt管理器, 用于管理插件
- * @param {string} scope 作用域
- * @param {string} title 标题
- * @returns {object} 返回一个缓存类
- */
-if ($.admin) {
-  $.admin.mqtt = mqttAdmin;
-}
+const Mqtt_client = require("mqtt");
+const Manager = require("mm_machine").Manager;
+const Drive = require("./drive");
+
+/**
+ * Mqtt通讯类
+ * @augments {Manager}
+ * @class
+ */
+class Mqtt extends Manager {
+  /**
+   * 配置参数
+   * @type {object}
+   */
+  static config = {
+    /**
+     * 名称
+     * @type {string}
+     */
+    name: "",
+    /**
+     * 标题
+     * @type {string}
+     */
+    title: "Mqtt通讯类",
+    /**
+     * 描述
+     * @type {string}
+     */
+    description: "这是Mqtt通讯类管理器",
+    /**
+     * 检索文件名
+     * @type {string}
+     */
+    filename: "mqtt.json",
+    /**
+     * 模板目录
+     * @type {string}
+     */
+    tpl_dir: __dirname,
+    /**
+     * 基础目录
+     * @type {string}
+     */
+    base_dir: "../common/mqtt".fullname(__dirname),
+    /**
+     * 自定义目录，加载项目自定义资源
+     * @type {string}
+     */
+    dir: "./app".fullname(),
+    /**
+     * 搜索模式 dir按目录搜索 | file按文件名搜索
+     * @type {string}
+     */
+    search_way: "file",
+    /**
+     * 是否懒加载
+     * @type {boolean}
+     */
+    lazy_load: false,
+    /**
+     * 模式
+     * 1.生产模式，改变文件不会重新加载
+     * 2.热更新模式，改变配置文件会重新加载配置，不重新加载脚本
+     * 3.热重载模式，改变配置文件都会加载配置和脚本
+     * 4.重载模式，执行完后重新加载脚本，避免变量污染
+     * 5.热更新+重载模式，改变配置文件重新加载配置和脚本，执行完后重新加载脚本
+     * @type {number}
+     */
+    mode: process.env.NODE_ENV === "production" ? 1 : 3,
+    host: "",
+    hostname: "127.0.0.1",
+    port: "1883",
+    protocol: "mqtt",
+    // MQTT协议版本: 4表示MQTT 3.1.1（兼容aedes v1.x）
+    protocol_version: 4,
+    clientid: "server",
+    subscribe_qos: 2,
+    publish_qos: 2,
+    username: "server",
+    password: process.env.MQTT_PASSWORD || "",
+    table: "iot_device",
+    clean: false,
+    longtime: 15000,
+    request_timeout: 3000,
+    // 在线有效期时长判断 单位：毫秒，150000毫秒为2.5分钟
+    online_expires: 150000,
+    // 在线有效期检测间隔
+    online_interval: 10000,
+    // 连接超时
+    connect_timeout: 30000,
+    // maxInflight: 20,
+    // 重连间隔
+    reconnet_period: 6000, // 重连间隔1秒
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父级模块
+   */
+  constructor(config, parent) {
+    super({ ...Mqtt.config, ...config }, parent);
+    this.retryTimes = 0;
+  }
+}
+
+/**
+ * 预置
+ */
+Mqtt.prototype._preset = function () {
+  this.dict = {};
+  // 缓存缺失记录, 用于宽容期判断幽灵在线
+  this.dict_lost = {};
+  // 定时器
+  this.timer = null;
+  // 关闭旧客户端
+  if (this.client && this.client.end) {
+    try {
+      this.client.end(true);
+    } catch {
+      // ignore close error
+    }
+  }
+  // mqtt客户端服务器
+  this.client = null;
+  /**
+   * message queue
+   */
+  this.list_msg = [
+    /*
+    {
+      // information ID
+      id: "",
+      // request method
+      method: "",
+      // message parameters
+      params: {},
+      // Callback
+      func: function(res){}
+    }
+    */
+  ];
+
+  /**
+   * 消息ID索引 (id => message对象), 用于O(1)查找
+   */
+  this.dict_msg = {};
+
+  /**
+   * 订阅集合 (主题 => 函数列表)
+   */
+  this.dict_subscribe = {};
+
+  /**
+   * 正则表达式缓存 (模式字符串 => RegExp对象)
+   */
+  this._regex_cache = {};
+
+  /**
+   * method collection
+   */
+  var _this = this;
+  this.methods = {
+    /**
+     * 获取所有方法
+     * @returns {Array} 函数列表
+     */
+    getMethod: function () {
+      return Object.keys(_this.methods);
+    },
+  };
+
+  this.retry_times = 0;
+  this.connecting = false;
+};
+
+/**
+ * mqtt驱动类
+ * @type {Drive}
+ */
+Mqtt.prototype.Drive = Drive;
+
+/**
+ * 主题匹配
+ * @param {string} topic 接收到的主题
+ * @param {string} top 匹配用的主题
+ * @returns {boolean} 返回匹配结果，正确返回true，错误返回false
+ */
+Mqtt.prototype.match = function (topic, top) {
+  if (topic === top) {
+    return true;
+  }
+  var regex = this._regex_cache[top];
+  if (!regex) {
+    // 限制正则缓存大小，避免无限增长
+    if (Object.keys(this._regex_cache).length > 500) {
+      this._regex_cache = {};
+    }
+    var str =
+      "^" +
+      top
+        .replace("#", ".*")
+        .replace("+", "~~~")
+        .replace("~~~", "[a-zA-Z0-9_-]+")
+        .replace("$", "~~~")
+        .replace("~~~", "\\$");
+    var s = str.substring(str.length - 1, str.length);
+    if (s !== "#") {
+      str += "$";
+    }
+    regex = new RegExp(str);
+    this._regex_cache[top] = regex;
+  }
+  return regex.test(topic);
+};
+
+/**
+ * 初始化
+ */
+Mqtt.prototype.updateAfter = async function () {
+  var _this = this;
+  var infos = this.getInfos();
+  var promises = [];
+
+  for (var i = 0; i < infos.length; i++) {
+    var info = infos[i];
+    if (info.state === 1) {
+      var mod = this.getMod(info.name);
+      if (mod) {
+        mod.send = function (topic, msg, qos = 0, retain = false) {
+          if (topic) {
+            _this.send(topic, msg, qos, retain);
+          }
+        };
+        promises.push(
+          mod.do("init").catch((err) => {
+            console.error("MQTT mod初始化失败:", mod.config.name, err);
+          }),
+        );
+      }
+    }
+  }
+
+  await Promise.allSettled(promises);
+};
+
+/**
+ * 订阅所有已启用mod的主题
+ * 需在客户端连接成功后调用
+ * @private
+ */
+Mqtt.prototype._subscribeTopics = function () {
+  var mods = this.getMods();
+  for (var k in mods) {
+    var o = mods[k];
+    if (o.config.state !== 1) {
+      continue;
+    }
+    var topics = o.config.topic;
+    if (!topics) {
+      continue;
+    }
+    for (var n = 0; n < topics.length; n++) {
+      var tc = topics[n];
+      var retain = o.config.retain || false;
+      var qos = o.config.qos || 0;
+      if (tc.indexOf("heartbeat") !== -1) {
+        retain = false;
+        qos = 0;
+      }
+      this.subscribe(tc, null, qos, retain);
+    }
+  }
+};
+
+/**
+ * 重新连接
+ */
+Mqtt.prototype.reconnect = async function () {
+  await $.sleep(this.config.reconnet_period);
+  this.retryTimes += 1;
+  if (this.retryTimes > 5) {
+    try {
+      // 保存当前订阅状态
+      var saved_subs = this.dict_subscribe;
+      this.dict_subscribe = {};
+      this.client.end();
+      this.client.removeAllListeners();
+      this.client = null;
+      // 重新初始化并启动
+      this.init();
+      await this.start();
+      // 恢复订阅
+      for (var k in saved_subs) {
+        var o = saved_subs[k];
+        var topics = o.topics || [];
+        for (var n = 0; n < topics.length; n++) {
+          var tc = topics[n];
+          this.subscribe(tc, null, o.config.qos || 0, o.config.retain || false);
+        }
+      }
+    } catch (error) {
+      this.log("error", error.toString());
+    }
+  }
+};
+
+/**
+ * 运行Mqtt
+ * @returns {Promise} 连接结果
+ */
+Mqtt.prototype.start = async function () {
+  this.connecting = true;
+
+  try {
+    await this._createClient();
+
+    if (this.client && this.client.on) {
+      return await this._setupClientEvents();
+    }
+  } catch (error) {
+    this.connecting = false;
+    return await this._rejectPromise(error);
+  }
+
+  return await this._rejectPromise();
+};
+
+/**
+ * 创建客户端
+ * @private
+ */
+Mqtt.prototype._createClient = async function () {
+  var cg = { ...this.config };
+  cg.clientId = cg.clientid;
+  if (cg.host) {
+    var broker_url = cg.host;
+    delete cg.hostname;
+    delete cg.port;
+    delete cg.host;
+    this.client = Mqtt_client.connect(broker_url, cg);
+  } else {
+    delete cg.host;
+    this.client = Mqtt_client.connect(cg);
+  }
+};
+
+/**
+ * 设置客户端事件
+ * @returns {Promise} 连接结果
+ * @private
+ */
+Mqtt.prototype._setupClientEvents = function () {
+  var _this = this;
+  var timeout_ms = _this.config.connect_timeout || 30000;
+  return new Promise((resolve, reject) => {
+    var timeout_timer = setTimeout(() => {
+      _this.connecting = false;
+      reject(new Error("MQTT连接超时"));
+    }, timeout_ms);
+
+    _this.client.on("connect", (connack) => {
+      clearTimeout(timeout_timer);
+      _this.connecting = false;
+      // 避免重连时重复绑定message事件
+      _this.client.removeAllListeners("message");
+      _this.client.on("message", (topic, message) => {
+        _this.receive(topic, message.toString()).catch((err) => {
+          console.error("MQTT消息处理错误:", err);
+        });
+      });
+      // 连接成功后订阅所有已启用mod的主题
+      _this._subscribeTopics();
+      // 启动在线状态定时器
+      _this.startTimer();
+      resolve(connack);
+    });
+    _this.client.on("error", (error) => {
+      clearTimeout(timeout_timer);
+      _this.connecting = false;
+      _this.log("error", "连接失败", error);
+      reject(error);
+    });
+  });
+};
+
+/**
+ * 创建被拒绝的Promise
+ * @param {Error} error 错误对象
+ * @returns {Promise} 被拒绝的Promise
+ * @private
+ */
+Mqtt.prototype._rejectPromise = function (error) {
+  return new Promise((resolve, reject) => {
+    if (error) {
+      reject(error);
+    } else {
+      reject(new Error("MQTT客户端连接失败"));
+    }
+  });
+};
+
+/**
+ * 监听事件
+ * @param {string} topic 事件名称
+ * @param {Function} func 回调函数
+ * @returns {object} 返回当前实例
+ */
+Mqtt.prototype.on = function (topic, func) {
+  if (!this.client) {
+    return this;
+  }
+  this.client.on(topic, func);
+  return this;
+};
+
+/**
+ * 接收消息
+ * @param {string} topic 订阅板块
+ * @param {object} msg 消息主体
+ */
+Mqtt.prototype.message = async function (topic, msg) {
+  if (this.dict_subscribe[topic]) {
+    var list = this.dict_subscribe[topic];
+    try {
+      for (var key in list) {
+        list[key](msg);
+      }
+    } catch (err) {
+      console.error(err);
+    }
+  }
+};
+
+/**
+ * 接收消息
+ * @param {string} push_topic 推送过来的主题
+ * @param {object} message 消息主体
+ * @returns {object} 解析后的消息主体
+ */
+Mqtt.prototype.receive = async function (push_topic, message) {
+  var msg = this._parseMessage(message, push_topic);
+  if (msg === null) {
+    return;
+  }
+
+  // 处理消息回复
+  this._handleResponse(msg);
+
+  var ret = await this._processTopics(push_topic, msg);
+  try {
+    await this.message(ret.topic, msg);
+  } catch (error) {
+    this.log("error", "mqtt处理程序错误", error);
+    return;
+  }
+  return ret.result;
+};
+
+/**
+ * 解析消息
+ * @param {object} message 消息主体
+ * @param {string} push_topic 推送过来的主题
+ * @returns {object|null} 解析后的消息
+ * @private
+ */
+Mqtt.prototype._parseMessage = function (message, push_topic) {
+  var msg = {};
+  if (message && (message.indexOf("[") === 0 || message.indexOf("{") === 0)) {
+    try {
+      msg = JSON.parse(message);
+    } catch (error) {
+      this.log("error", "消息结构体不对", push_topic, error);
+      return null;
+    }
+  }
+  return msg;
+};
+
+/**
+ * 处理主题
+ * @param {string} push_topic 推送过来的主题
+ * @param {object} msg 消息主体
+ * @returns {object} 处理结果和主题
+ * @private
+ */
+Mqtt.prototype._processTopics = async function (push_topic, msg) {
+  var ret;
+  var collected = this._collectTopicPromises(push_topic, msg);
+  var promises = collected.promises;
+  var topic = collected.topic;
+
+  if (promises.length > 0) {
+    var results = await Promise.allSettled(promises);
+    // 取最后一个成功的结果作为返回值 (保持向后兼容)
+    for (var i = results.length - 1; i >= 0; i--) {
+      if (
+        results[i].status === "fulfilled" &&
+        results[i].value !== undefined &&
+        results[i].value !== null
+      ) {
+        ret = results[i].value;
+        break;
+      }
+    }
+  }
+
+  return { result: ret, topic };
+};
+
+/**
+ * 收集匹配主题的handler Promise
+ * @param {string} push_topic 推送过来的主题
+ * @param {object} msg 消息主体
+ * @returns {object} {promises: Array, topic: string} Promise数组和最后匹配的主题
+ * @private
+ */
+Mqtt.prototype._collectTopicPromises = function (push_topic, msg) {
+  var promises = [];
+  var topic = "";
+  var mods = this.getMods();
+
+  for (var k in mods) {
+    var o = mods[k];
+    if (o.config.state !== 1) {
+      continue;
+    }
+    var topics = o.config.topic;
+    if (!topics) {
+      continue;
+    }
+    for (var n = 0; n < topics.length; n++) {
+      topic = topics[n];
+      if (this.match(push_topic, topic)) {
+        promises.push(
+          o.call("handle", push_topic, msg, topic, n).catch((err) => {
+            console.error("MQTT handler执行错误:", err);
+          }),
+        );
+      }
+    }
+  }
+
+  return { promises, topic };
+};
+
+/**
+ * 订阅主题
+ * @param {string} topic 主题
+ * @param {Function} func 回调函数
+ * @param {number} qos 推送方式 0
+ * @param {boolean} retain 保持
+ * @returns {string} 主键
+ */
+Mqtt.prototype.subscribe = function (topic, func, qos = null, retain = false) {
+  if (!this.client) {
+    return "";
+  }
+  this.client.subscribe(topic, {
+    // 订阅消息方式，0为保留 ， 1为确认收到1次
+    qos: qos || this.config.subscribe_qos || 0,
+    retain,
+  });
+  if (func) {
+    if (!this.dict_subscribe[topic]) {
+      this.dict_subscribe[topic] = {};
+    }
+    var key = this.key_num + 1;
+    this.dict_subscribe[topic][key] = func;
+    return key;
+  }
+  return "";
+};
+
+/**
+ * 取消订阅
+ * @param {string} topic 主题
+ * @param {string} key 主键
+ */
+Mqtt.prototype.unsubscribe = function (topic, key) {
+  this.client.unsubscribe(topic);
+  if (this.dict_subscribe[topic]) {
+    delete this.dict_subscribe[topic][key];
+  }
+};
+
+/**
+ * 结束客户端
+ */
+Mqtt.prototype.end = function () {
+  if (this.client) {
+    this.client.removeAllListeners();
+    this.client.end();
+    this.client = null;
+  }
+  if (this.timer) {
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+  // 清空运行时数据结构
+  this.list_msg = [];
+  this.dict_msg = {};
+  this.dict_subscribe = {};
+  this._regex_cache = {};
+};
+
+/**
+ * 发布主题
+ * @param {string} topic 主题
+ * @param {object} message 消息对象
+ * @param {number} qos 推送方式 0
+ * @param {boolean} retain 保持
+ */
+Mqtt.prototype.publish = function (topic, message, qos = null, retain = false) {
+  this.client.publish(topic, message, {
+    qos: qos || this.config.publish_qos || 0,
+    retain,
+  });
+};
+
+/**
+ * 主题推送
+ * @param {string} topic 主题
+ * @param {string} msg_obj 消息主体
+ * @param {number} qos 推送方式 0
+ * @param {boolean} retain 保持
+ */
+Mqtt.prototype.send = function (topic, msg_obj, qos = null, retain = false) {
+  this.publish(topic, JSON.stringify(msg_obj), qos, retain);
+};
+
+/**
+ * 生成ID
+ * @param {string} clientId 客户端ID
+ * @returns {string} ID
+ */
+Mqtt.prototype.genId = function (clientId) {
+  return clientId + "_" + Date.parse(new Date());
+};
+
+/**
+ * 请求
+ * @param {string} topic 主题
+ * @param {string} method 请求方法
+ * @param {object} params 请求参数
+ * @param {Function} func 回调函数
+ * @param {number} timeout 超时时间（毫秒）
+ */
+Mqtt.prototype.req = function (topic, method, params, func, timeout = 0) {
+  var data = {
+    id: this.genId(this.client.options.clientId),
+    method,
+    params,
+  };
+
+  if (func) {
+    data.func = func;
+    data.timestamp = Date.now();
+    data.timeout = timeout || this.config.request_timeout || 3000;
+    this.list_msg.push(data);
+    this.dict_msg[data.id] = data;
+
+    // 设置超时移除定时器
+    var _this = this;
+    data.timer = setTimeout(() => {
+      _this._delMsgById(data.id);
+    }, data.timeout);
+  }
+  this.send(topic, data);
+};
+
+/**
+ * 同步请求 - 可及时取回消息
+ * @param {string} topic 订阅板块
+ * @param {string} method 请求方法
+ * @param {object} params 传递参数
+ * @param {number} timeout 超时时间 0为默认值 10000ms
+ * @returns {object} 返回响应结果
+ */
+Mqtt.prototype.reqAsync = function (topic, method, params, timeout = 0) {
+  var _this = this;
+  return new Promise((resolve, reject) => {
+    _this.req(
+      topic,
+      method,
+      params,
+      (res) => {
+        resolve(res);
+      },
+      timeout,
+    );
+  });
+};
+
+/**
+ * 根据ID移除消息
+ * @param {string} msg_id 消息ID
+ * @private
+ */
+Mqtt.prototype._delMsgById = function (msg_id) {
+  var o = this.dict_msg[msg_id];
+  if (!o) {
+    return;
+  }
+  // 清除定时器
+  if (o.timer) {
+    clearTimeout(o.timer);
+  }
+  delete this.dict_msg[msg_id];
+
+  // 从数组中移除 (保持list_msg与dict_msg同步)
+  for (var i = 0; i < this.list_msg.length; i++) {
+    if (this.list_msg[i].id === msg_id) {
+      this.list_msg.splice(i, 1);
+      break;
+    }
+  }
+};
+
+/**
+ * 处理消息回复
+ * @param {object} msg 回复消息
+ * @private
+ */
+Mqtt.prototype._handleResponse = function (msg) {
+  if (!msg || !msg.id) {
+    return;
+  }
+
+  var o = this.dict_msg[msg.id];
+  if (o && o.func) {
+    try {
+      // 执行回调函数
+      o.func(msg);
+    } catch (error) {
+      console.error("MQTT回调函数执行错误:", error);
+    }
+
+    // 从列表中移除已处理的消息
+    this._delMsgById(o.id);
+  }
+};
+
+/**
+ * 保存在线到数据库
+ * @param {Array} arr 客户端ID数组
+ * @param {number} online 在线情况 0为不在线，1为在线
+ */
+Mqtt.prototype.saveOnline = async function (arr, online = 1) {
+  if (!arr || !arr.length) {
+    return;
+  }
+  var body = {
+    online,
+  };
+  var db = $.admin.sql("sys").db();
+  db.table = this.config.table || "iot_device";
+  db.size = 0;
+  var query = {};
+  query.clientid_has = arr.join(",");
+  await db.set(query, body);
+};
+
+/**
+ * 获取所有设备
+ * @returns {Array} 设备列表
+ */
+Mqtt.prototype.getClients = async function () {
+  var db = $.admin.sql("sys").db();
+  db.table = this.config.table || "iot_device";
+  db.size = 0;
+  return await db.get({}, "", "clientid, online");
+};
+
+/**
+ * 更新在线设备
+ */
+Mqtt.prototype.updateOnline = async function () {
+  var now = new Date().getTime();
+  var online_expires = this.config.online_expires; // 180
+
+  // 获取所有客户端
+  var drives = await this.getClients();
+  var result = this._processDeviceStatus(drives, now, online_expires);
+  var { list_online, list_offline, list_has } = result;
+
+  // 处理数据库在线但缓存缺失的设备
+  this._processUnseenDevices(
+    drives,
+    list_offline,
+    list_has,
+    now,
+    online_expires,
+  );
+
+  // 批量更新设备状态
+  await this._updateDeviceStatus(list_offline, list_online);
+};
+
+/**
+ * 处理设备状态
+ * @param {Array} drives 设备列表
+ * @param {number} now 当前时间戳
+ * @param {number} online_expires 在线过期时间
+ * @returns {object} 在线和离线设备列表
+ * @private
+ */
+Mqtt.prototype._processDeviceStatus = function (drives, now, online_expires) {
+  var list_online = [];
+  var list_offline = [];
+  var list_has = [];
+
+  var mods = this.getMods();
+  for (var k in mods) {
+    var o = mods[k];
+    var dict = o.drives || {};
+    for (var clientid in dict) {
+      list_has.push(clientid);
+      // 设备已出现, 清除缺失记录
+      delete this.dict_lost[clientid];
+      var drive = drives.getObj({ clientid });
+      var device = dict[clientid];
+
+      if (device.online === 1) {
+        this._onlineDevice(
+          device,
+          drive,
+          clientid,
+          now,
+          online_expires,
+          list_online,
+          list_offline,
+          dict,
+        );
+      } else {
+        this._offlineDevice(drive, clientid, list_offline, dict);
+      }
+    }
+  }
+
+  return { list_online, list_offline, list_has };
+};
+
+/**
+ * 处理在线设备
+ * @param {object} device 设备对象
+ * @param {object} drive 数据库中的设备信息
+ * @param {string} clientid 设备ID
+ * @param {number} now 当前时间戳
+ * @param {number} online_expires 在线过期时间
+ * @param {Array} list_online 在线设备列表
+ * @param {Array} list_offline 离线设备列表
+ * @param {object} dict 设备字典
+ * @private
+ */
+/* eslint-disable no-param-reassign */
+Mqtt.prototype._onlineDevice = function (
+  device,
+  drive,
+  clientid,
+  now,
+  online_expires,
+  list_online,
+  list_offline,
+  dict,
+) {
+  if (device.time_last) {
+    var cha = now - device.time_last;
+    if (cha > online_expires) {
+      if (drive && drive.online) {
+        list_offline.push(clientid);
+      }
+      // 这里需要修改设备状态，但由于参数修改限制，我们直接修改字典
+      // 注意：这里仍然会修改外部对象，但这是业务逻辑需要
+      device.online = 0;
+      delete dict[clientid];
+    } else {
+      if (drive && !drive.online) {
+        list_online.push(clientid);
+      }
+    }
+  }
+};
+/* eslint-enable no-param-reassign */
+
+/**
+ * 处理离线设备
+ * @param {object} drive 数据库中的设备信息
+ * @param {string} clientid 设备ID
+ * @param {Array} list_offline 离线设备列表
+ * @param {object} dict 设备字典
+ * @private
+ */
+/* eslint-disable no-param-reassign */
+Mqtt.prototype._offlineDevice = function (drive, clientid, list_offline, dict) {
+  if (drive && drive.online) {
+    list_offline.push(clientid);
+  }
+  // 从缓存中删除离线设备，避免下次再判断
+  delete dict[clientid];
+};
+/* eslint-enable no-param-reassign */
+
+/**
+ * 处理数据库在线但缓存中缺失的设备, 连续缺失超过在线有效期才判离线
+ * @param {Array} drives 设备列表
+ * @param {Array} list_offline 离线设备列表
+ * @param {Array} list_has 已出现的设备ID列表
+ * @param {number} now 当前时间戳
+ * @param {number} online_expires 在线过期时间
+ * @private
+ */
+Mqtt.prototype._processUnseenDevices = function (
+  drives,
+  list_offline,
+  list_has,
+  now,
+  online_expires,
+) {
+  // 处理未出现的设备
+  for (var i = 0; i < drives.length; i++) {
+    var { clientid, online } = drives[i];
+    if (!online || list_has.indexOf(clientid) !== -1) {
+      continue;
+    }
+    // 首次缺失, 记录时间, 等待下一个周期
+    if (!this.dict_lost[clientid]) {
+      this.dict_lost[clientid] = now;
+      continue;
+    }
+    // 连续缺失超过在线有效期, 判定离线
+    if (now - this.dict_lost[clientid] > online_expires) {
+      list_offline.push(clientid);
+      delete this.dict_lost[clientid];
+    }
+  }
+};
+
+/**
+ * 更新设备状态
+ * @param {Array} list_offline 离线设备列表
+ * @param {Array} list_online 在线设备列表
+ * @private
+ */
+Mqtt.prototype._updateDeviceStatus = async function (
+  list_offline,
+  list_online,
+) {
+  var promises = [];
+
+  // 先将设备离线
+  var list_off = list_offline.to2D(30);
+  for (var i = 0; i < list_off.length; i++) {
+    promises.push(this.saveOnline(list_off[i], 0));
+  }
+
+  // 再将设备在线
+  var list_on = list_online.to2D(30);
+  for (var i = 0; i < list_on.length; i++) {
+    promises.push(this.saveOnline(list_on[i], 1));
+  }
+
+  await Promise.allSettled(promises);
+};
+
+/**
+ * 开始计时器
+ */
+Mqtt.prototype.startTimer = function () {
+  if (!this.timer) {
+    this.timer = setInterval(() => {
+      try {
+        this.updateOnline();
+      } catch (err) {
+        console.error("更新在线设备失败", err);
+      }
+    }, this.config.online_interval);
+  }
+};
+
+exports.Mqtt = Mqtt;
+
+/**
+ * 创建全局管理器
+ */
+if (!$.pool.mqtt) {
+  $.pool.mqtt = {};
+}
+
+function mqttAdmin(scope, title) {
+  var sc = scope || $.val.scope + "";
+  var obj = $.pool.mqtt[sc];
+  if (!obj) {
+    $.pool.mqtt[sc] = new Mqtt({
+      name: sc,
+      title: title,
+    });
+    obj = $.pool.mqtt[sc];
+  }
+  return obj;
+}
+
+/**
+ * mqtt管理器, 用于管理插件
+ * @param {string} scope 作用域
+ * @param {string} title 标题
+ * @returns {object} 返回一个缓存类
+ */
+if ($.admin) {
+  $.admin.mqtt = mqttAdmin;
+}