mm_os 3.3.1 → 4.0.1

package/com/mqtt/index.js

@@ -0,0 +1,822 @@
+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(function () {
+      _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++) {
+    var msg_item = this.list_msg[i];
+    if (msg_item.id === msg.id && msg_item.func) {
+      try {
+        // 执行回调函数
+        msg_item.func(msg);
+      } catch (error) {
+        console.error('MQTT回调函数执行错误:', error);
+      }
+
+      // 从列表中移除已处理的消息
+      this._delMsgById(msg.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, list_has } = 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;
+}