mm_os 4.3.6 → 5.0.0

package/com/mqtt/index.js

@@ -1,1017 +0,0 @@
-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秒
-    /**
-     * 最大深度
-     * @type {number}
-     */
-    max_depth: 6
-  };
-
-  /**
-   * 构造函数
-   * @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;
-}