mm_os 4.3.6 → 5.0.0

package/adapter/custom_persistence.js

@@ -1,661 +0,0 @@
-const { Readable } = require('stream');
-
-/**
- * 自定义持久化类 - 为Aedes MQTT broker提供持久化存储支持
- */
-class Persist {
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} cache 缓存管理器
-   */
-  constructor(config, cache) {
-    // 配置参数
-    this.config = {
-      // 缓存配置
-      cache: true,
-      // 缓存前缀
-      prefix: 'mqtt:',
-      // 缓存过期时间（毫秒）
-      ttl: 3600000, 
-      ...config
-    };
-    
-    // 缓存管理器，提供set、get、del、keys功能
-    this._cache = cache;
-    
-    if (!this._cache) {
-      throw new Error('缓存管理器不能为空');
-    }
-    
-    // 验证缓存管理器是否实现了必要的方法
-    let req_methods = ['set', 'get', 'delete', 'keys'];
-    for (let method of req_methods) {
-      if (typeof this._cache[method] !== 'function') {
-        throw new Error(`缓存管理器必须实现${method}方法`);
-      }
-    }
-  }
-}
-
-/**
- * 生成带前缀的缓存键
- * @private
- * @param {string} key - 原始键
- * @returns {string} 带前缀的缓存键
- */
-Persist.prototype._getCacheKey = function(key) {
-  return this.config.prefix + key;
-};
-
-/**
- * 获取所有匹配模式的键
- * @private
- * @param {string} pattern - 键模式
- * @returns {Array} 匹配的键数组
- */
-Persist.prototype._getKeysByPattern = function(pattern) {
-  let prefix = this.config.prefix;
-  let regex = new RegExp('^' + prefix + pattern.replace(/\*/g, '.*') + '$');
-  return this._cache.keys().filter(key => regex.test(key)).map(key => key.slice(prefix.length));
-};
-
-// ------------------- 订阅管理 -------------------
-
-/**
- * 添加订阅
- * @param {object} client - 客户端对象
- * @param {object} sub - 订阅对象
- * @param {Function} cb - 回调函数
- */
-Persist.prototype.addSub = function(client, sub, cb) {
-  console.log('addSub', client.id);
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    if (!sub || !sub.topic) {
-      throw new Error('无效的订阅对象');
-    }
-    
-    let key = this._getCacheKey(`subscription:${client.id}:${sub.topic}`);
-    this._cache.set(key, sub, this.config.ttl);
-    
-    if (cb) cb(null);
-  } catch (error) {
-    if (cb) cb(error);
-  }
-};
-
-/**
- * 删除订阅
- * @param {object} client - 客户端对象
- * @param {object} sub - 订阅对象
- * @param {Function} cb - 回调函数
- */
-Persist.prototype.removeSub = function(client, sub, cb) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    if (!sub || !sub.topic) {
-      throw new Error('无效的订阅对象');
-    }
-    
-    let key = this._getCacheKey(`subscription:${client.id}:${sub.topic}`);
-    this._cache.delete(key);
-    
-    if (cb) cb(null);
-  } catch (error) {
-    if (cb) cb(error);
-  }
-};
-
-/**
- * 删除客户端的所有订阅
- * @param {object} client - 客户端对象
- * @param {Function} cb - 回调函数
- */
-Persist.prototype.removeSubs = function(client, cb) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    let pat = `subscription:${client.id}:*`;
-    let keys = this._getKeysByPattern(pat);
-    
-    // 同步执行所有删除操作
-    keys.forEach(key => {
-      this._cache.delete(this._getCacheKey(key));
-    });
-    
-    if (cb) cb(null);
-  } catch (error) {
-    if (cb) cb(error);
-  }
-};
-
-/**
- * 获取客户端的所有订阅
- * @param {object} client - 客户端对象
- * @param {Function} cb - 回调函数
- */
-Persist.prototype.getSubs = function(client, cb) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    let pattern = `subscription:${client.id}:*`;
-    let keys = this._getKeysByPattern(pattern);
-    
-    // 同步执行所有获取操作
-    let subs = keys.map(key => {
-      return this._cache.get(this._getCacheKey(key));
-    }).filter(Boolean);
-    
-    if (cb) cb(null, subs);
-  } catch (error) {
-    if (cb) cb(error);
-  }
-};
-
-/**
- * 获取订阅了指定主题的所有客户端
- * @param {string} topic - 主题
- * @param {Function} cb - 回调函数
- */
-Persist.prototype.subsByTopic = function(topic, cb) {
-  try {
-    if (!topic) {
-      throw new Error('主题不能为空');
-    }
-    
-    // 简单实现，实际可能需要支持通配符匹配
-    let pat = `subscription:*:${topic}`;
-    let keys = this._getKeysByPattern(pat);
-    
-    // 同步执行所有获取操作
-    let subs = keys.map(key => {
-      let parts = key.split(':');
-      if (parts.length >= 3) {
-        let cid = parts[1];
-        let sub = this._cache.get(this._getCacheKey(key));
-        if (sub) {
-          return {
-            clientId: cid,
-            sub: sub
-          };
-        }
-      }
-      return null;
-    }).filter(Boolean);
-    
-    if (cb) cb(null, subs);
-  } catch (error) {
-    if (cb) cb(error);
-  }
-};
-
-// ------------------- 保留消息 -------------------
-
-/**
- * 存储保留消息
- * @param {object} packet - MQTT消息包
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.storeRetained = function(packet, callback) {
-  try {
-    if (!packet || !packet.topic) {
-      throw new Error('无效的消息包');
-    }
-    
-    let key = this._getCacheKey(`retained:${packet.topic}`);
-    this._cache.set(key, packet, this.config.ttl);
-    
-    if (callback) callback(null);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 删除保留消息
- * @param {string} topic - 主题
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.cleanRetained = function(topic, callback) {
-  try {
-    if (!topic) {
-      throw new Error('主题不能为空');
-    }
-    
-    let key = this._getCacheKey(`retained:${topic}`);
-    this._cache.delete(key);
-    
-    if (callback) callback(null);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 获取保留消息
- * @param {string} topic - 主题
- * @param {Function} cb - 回调函数
- */
-Persist.prototype.getRetained = function(topic, cb) {
-  try {
-    if (!topic) {
-      throw new Error('主题不能为空');
-    }
-    
-    let key = this._getCacheKey(`retained:${topic}`);
-    let retained = this._cache.get(key);
-    
-    if (cb) cb(null, retained ? [retained] : []);
-  } catch (error) {
-    if (cb) cb(error);
-  }
-};
-
-// ------------------- 传输中消息 (QoS) -------------------
-
-/**
- * 存储传输中消息
- * @param {object} client - 客户端对象
- * @param {object} packet - MQTT消息包
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.storePacket = function(client, packet, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    if (!packet || !packet.msgId) {
-      throw new Error('无效的消息包');
-    }
-    
-    let key = this._getCacheKey(`packet:${client.id}:${packet.msgId}`);
-    this._cache.set(key, packet, this.config.ttl);
-    
-    if (callback) callback(null);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 删除传输中消息
- * @param {object} client - 客户端对象
- * @param {object} packet - MQTT消息包
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.removePacket = function(client, packet, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    if (!packet || !packet.msgId) {
-      throw new Error('无效的消息包');
-    }
-    
-    let key = this._getCacheKey(`packet:${client.id}:${packet.msgId}`);
-    this._cache.delete(key);
-    
-    if (callback) callback(null);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 获取传输中消息
- * @param {object} client - 客户端对象
- * @param {object} packet - MQTT消息包
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.getPacket = function(client, packet, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    if (!packet || !packet.msgId) {
-      throw new Error('无效的消息包');
-    }
-    
-    let key = this._getCacheKey(`packet:${client.id}:${packet.msgId}`);
-    
-    if (callback) callback(null, this._cache.get(key));
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 获取客户端的所有传输中消息
- * @param {object} client - 客户端对象
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.getPackets = function(client, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    let pattern = `packet:${client.id}:*`;
-    let keys = this._getKeysByPattern(pattern);
-    
-    // 同步执行所有获取操作
-    let packets = keys.map(key => {
-      let packet = this._cache.get(this._getCacheKey(key));
-      return packet;
-    }).filter(Boolean);
-    
-    if (callback) callback(null, packets);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 删除过期的传输中消息
- * @param {object} packet - MQTT消息包
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.delOutdatedPacket = function(packet, callback) {
-  try {
-    if (!packet || !packet.msgId) {
-      throw new Error('无效的消息包');
-    }
-    
-    // 注意：这个方法可能需要客户端信息，这里简单处理
-    let pattern = `packet:*:${packet.msgId}`;
-    let keys = this._getKeysByPattern(pattern);
-    
-    // 同步执行所有删除操作
-    keys.forEach(key => {
-      this._cache.delete(this._getCacheKey(key));
-    });
-    
-    if (callback) callback(null);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-// ------------------- 遗嘱消息 -------------------
-
-/**
- * 存储遗嘱消息
- * @param {object} client - 客户端对象
- * @param {object} packet - MQTT消息包
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.storeWill = function(client, packet, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    if (!packet) {
-      throw new Error('无效的消息包');
-    }
-    
-    let key = this._getCacheKey(`will:${client.id}`);
-    this._cache.set(key, packet, this.config.ttl);
-    
-    if (callback) callback(null);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 删除遗嘱消息
- * @param {object} client - 客户端对象
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.removeWill = function(client, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    let key = this._getCacheKey(`will:${client.id}`);
-    this._cache.delete(key);
-    
-    if (callback) callback(null);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 获取遗嘱消息
- * @param {object} client - 客户端对象
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.getWill = function(client, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    let key = this._getCacheKey(`will:${client.id}`);
-    let will = this._cache.get(key);
-    
-    if (callback) callback(null, will);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-// ------------------- 离线消息 -------------------
-
-/**
- * 存储离线消息
- * @param {object} client - 客户端对象
- * @param {object} packet - MQTT消息包
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.storeOfflinePacket = function(client, packet, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    if (!packet || !packet.msgId) {
-      throw new Error('无效的消息包');
-    }
-    
-    let key = this._getCacheKey(`offline:${client.id}:${packet.msgId}`);
-    this._cache.set(key, packet, this.config.ttl);
-    
-    if (callback) callback(null);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-/**
- * 获取客户端的所有离线消息
- * @param {object} client - 客户端对象
- * @param {Function} callback - 回调函数
- */
-Persist.prototype.getOfflinePackets = function(client, callback) {
-  try {
-    if (!client || !client.id) {
-      throw new Error('无效的客户端对象');
-    }
-    
-    let pattern = `offline:${client.id}:*`;
-    let keys = this._getKeysByPattern(pattern);
-    
-    // 同步执行所有获取操作
-    let packets = keys.map(key => {
-      let packet = this._cache.get(this._getCacheKey(key));
-      return packet;
-    }).filter(Boolean);
-    
-    if (callback) callback(null, packets);
-  } catch (error) {
-    if (callback) callback(error);
-  }
-};
-
-// ------------------- 流式恢复（重要！） -------------------
-
-/**
- * 处理保留消息
- * @private
- * @param {object} self 当前实例
- * @param {object} stream 可读流
- */
-Persist.prototype._procRetainMsgs = function(self, stream) {
-  let keys = self._getKeysByPattern('retained:*');
-  let msgs = keys.map(key => {
-    let packet = self._cache.get(self._getCacheKey(key));
-    if (packet) {
-      return {
-        type: 'retained',
-        topic: packet.topic,
-        payload: packet.payload,
-        qos: packet.qos,
-        retain: packet.retain
-      };
-    }
-    return null;
-  }).filter(Boolean);
-  msgs.forEach(msg => {
-    stream.push(msg);
-  });
-};
-
-/**
- * 处理订阅信息
- * @private
- * @param {object} self 当前实例
- * @param {object} stream 可读流
- */
-Persist.prototype._procSubs = function(self, stream) {
-  let keys = self._getKeysByPattern('subscription:*:*');
-  let subs = keys.map(key => {
-    let parts = key.split(':');
-    if (parts.length >= 3) {
-      let cid = parts[1];
-      let sub = self._cache.get(self._getCacheKey(key));
-      if (sub) {
-        return {
-          type: 'subscription',
-          clientId: cid,
-          sub: sub
-        };
-      }
-    }
-    return null;
-  }).filter(Boolean);
-  subs.forEach(sub => {
-    stream.push(sub);
-  });
-};
-
-/**
- * 处理遗嘱消息
- * @private
- * @param {object} self 当前实例
- * @param {object} stream 可读流
- */
-Persist.prototype._procWills = function(self, stream) {
-  let keys = self._getKeysByPattern('will:*');
-  let wills = keys.map(key => {
-    let parts = key.split(':');
-    if (parts.length >= 2) {
-      let cid = parts[1];
-      let will = self._cache.get(self._getCacheKey(key));
-      if (will) {
-        return {
-          type: 'will',
-          clientId: cid,
-          will: will
-        };
-      }
-    }
-    return null;
-  }).filter(Boolean);
-  wills.forEach(will => {
-    stream.push(will);
-  });
-};
-
-/**
- * 处理传输中消息
- * @private
- * @param {object} self 当前实例
- * @param {object} stream 可读流
- */
-Persist.prototype._procInflightMsgs = function(self, stream) {
-  let keys = self._getKeysByPattern('packet:*:*');
-  let packets = keys.map(key => {
-    let parts = key.split(':');
-    if (parts.length >= 3) {
-      let cid = parts[1];
-      let packet = self._cache.get(self._getCacheKey(key));
-      if (packet) {
-        return {
-          type: 'inflight',
-          clientId: cid,
-          packet: packet
-        };
-      }
-    }
-    return null;
-  }).filter(Boolean);
-  packets.forEach(packet => {
-    stream.push(packet);
-  });
-};
-
-/**
- * 创建可读流，用于恢复Aedes状态
- * @returns {Readable} 可读流
- */
-Persist.prototype.createStream = function() {
-  let self = this;
-  
-  return new Readable({
-    objectMode: true,
-    
-    read() {
-      try {
-        // 处理保留消息
-        self._procRetainMsgs(self, this);
-        
-        // 处理订阅信息
-        self._procSubs(self, this);
-        
-        // 处理遗嘱消息
-        self._procWills(self, this);
-        
-        // 处理传输中消息
-        self._procInflightMsgs(self, this);
-        
-        // 结束流
-        this.push(null);
-      } catch (error) {
-        self._cache.log && self._cache.log('error', '创建恢复流时出错:', error);
-        this.push(null);
-      }
-    }
-  });
-};
-
-module.exports = {
-  Persist
-};