mm_os 4.2.4 → 4.2.7

package/README.md

@@ -426,7 +426,7 @@ MM_OS 支持多种配置选项，包括：
 
 ```json
 {
-  "name": "mos",
+  "name": "mm_os",
   "title": "服务端系统",
   "log": {
     "level": "debug",

package/README_EN.md

@@ -110,7 +110,7 @@ const server = new MM_os({
 async function startServer() {
   await server.init();
   await server.start();
-  console.log('Server started successfully');
+  console.log('服务启动成功');
 }
 
 startServer();
@@ -427,7 +427,7 @@ MM_OS supports multiple configuration options:
 
 ```json
 {
-  "name": "mos",
+  "name": "mm_os",
   "title": "Server System",
   "log": {
     "level": "debug",

package/adapter/adapter.js

@@ -2,10 +2,9 @@
  * 适配器基类
  * 定义了基础的网络通信接口
  */
-const { Mod } = require('mm_machine');
 const { idGen } = require('../ulits/id_gen.js');
 
-class Adapter extends Mod {
+class Adapter {
   static config = {
     name: 'adapter',
     host: '0.0.0.0',
@@ -18,17 +17,68 @@ class Adapter extends Mod {
    * @param {object} parent 父对象
    */
   constructor(config, parent) {
-    super({ ...Adapter.config, ...config }, parent);
-
+    if (parent) {
+      this.getParent = function () {
+        return parent;
+      };
+    }
     // 客户端连接列表
     this.clients = new Map();
     // 中间件数组
     this.mw_list = [];
     // 回调函数映射表，使用消息ID作为键
     this.callback = new Map();
+
+    this.setConfig(config);
   }
 }
 
+/**
+ * 设置配置参数
+ * @param {object} config 配置参数
+ */
+Adapter.prototype.setConfig = function (config) {
+  this.config = { ...Adapter.config, ...config };
+  this._preset();
+};
+
+Adapter.prototype._preset = function () {
+  // 默认预设，子类可以重写
+};
+
+Adapter.prototype.getParent = function () {
+  return null;
+};
+
+/**
+ * 初始化适配器
+ * @private
+ */
+Adapter.prototype._init = function (...args) {
+  return this;
+};
+
+/**
+ * 初始化适配器
+ * @param {...*} args 初始化参数
+ * @returns {object} this
+ */
+Adapter.prototype.init = function (...args) {
+  // 默认初始化，子类可以重写
+  return this._init(...args);
+};
+
+/**
+ * 记录日志
+ * @param {string} level 日志级别，如 'debug', 'info', 'warn', 'error'
+ * @param {string} message 日志消息
+ * @param {...*} args 可选，日志消息的参数
+ */
+Adapter.prototype.log = function (level, message, ...args) {
+  let logger = this.getParent().getLogger();
+  logger[level](`[${this.constructor.name}] ${message}`, ...args);
+};
+
 /**
  * 生成ID
  * @param {string} type ID类型，可选值：'client'（客户端ID）或'msg'（消息ID）
@@ -76,24 +126,24 @@ Adapter.prototype._setupMw = function () {
 
 /**
  * 发送消息（需要子类实现）
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {string} message 消息内容
  * @returns {void}
  */
-Adapter.prototype._send = function (client_id, message) {
-  this.log('debug', '发送消息', { client_id, message });
+Adapter.prototype._send = function (clientid, message) {
+  this.log('debug', '发送消息', { clientid, message });
   throw new Error('子类必须实现_send方法');
 };
 
 /**
  * 向指定客户端发送消息（JSON 2.0格式）
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {string} method 方法名
  * @param {object} params 参数对象
  * @param {Function} cb 可选，接收客户端回复的回调函数
  * @returns {void}
  */
-Adapter.prototype.send = function (client_id, method, params = {}, cb = null) {
+Adapter.prototype.send = function (clientid, method, params = {}, cb = null) {
   // 生成唯一消息ID
   let message_id = this.genMsgId();
 
@@ -112,20 +162,20 @@ Adapter.prototype.send = function (client_id, method, params = {}, cb = null) {
     this.callback.set(message_id, cb);
   }
 
-  return this._send(client_id, message);
+  return this._send(clientid, message);
 };
 
 /**
  * 异步发送消息
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {string} method 方法名
  * @param {object} params 参数对象
  * @returns {Promise} 异步操作的结果
  */
-Adapter.prototype.sendAsync = function (client_id, method, params = {}) {
+Adapter.prototype.sendAsync = function (clientid, method, params = {}) {
   return new Promise((resolve, reject) => {
     // 发送消息
-    this.send(client_id, method, params, (msg, error) => {
+    this.send(clientid, method, params, (msg, error) => {
       if (error) {
         reject(error);
       } else {
@@ -185,10 +235,10 @@ Adapter.prototype._autoReply = function (ctx) {
       result: ctx.body,
       error: null
     };
-    this._send(ctx.client_id, JSON.stringify(response));
+    this._send(ctx.clientid, JSON.stringify(response));
   } else {
     // 非JSON格式消息，直接发送
-    this._send(ctx.client_id, ctx.body.toString());
+    this._send(ctx.clientid, ctx.body.toString());
   }
 };
 
@@ -207,44 +257,42 @@ Adapter.prototype._runMwError = function (ctx, error) {
       result: null,
       error: { message: error.message }
     };
-    this._send(ctx.client_id, JSON.stringify(response));
+    this._send(ctx.clientid, JSON.stringify(response));
   }
 };
 
 /**
  * 消息接收处理
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {object} socket 客户端socket对象
  * @param {string} data 接收的消息
  */
-Adapter.prototype._onMsg = function (client_id, socket, data) {
+Adapter.prototype._onMsg = function (clientid, socket, data) {
   // 检查参数是否有效
-  if (!this._check(client_id, data)) return;
+  if (!this._check(clientid, data)) return;
 
   // 处理消息数据
-  let client_id_str = this._getClientIdStr(client_id);
+  let clientid_str = this._getClientIdStr(clientid);
   let message = this._parseStr(data);
 
-  this.log('debug', `客户端 ${client_id_str} 发送数据: ${message}`);
-
   // 解析消息并处理
-  let msg = this._parseMessage(client_id_str, message);
+  let msg = this._parseMessage(clientid_str, message);
 
   // 创建上下文对象并执行中间件
-  let ctx = this._createContext(client_id_str, socket, msg);
+  let ctx = this._createContext(clientid_str, socket, msg);
   this._composeMw(ctx);
 };
 
 /**
  * 验证参数有效性
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {string} data 消息数据
  * @returns {boolean} 参数是否有效
  * @private
  */
-Adapter.prototype._check = function (client_id, data) {
-  if (!client_id) {
-    this.log('error', '客户端ID无效:', client_id);
+Adapter.prototype._check = function (clientid, data) {
+  if (!clientid) {
+    this.log('error', '客户端ID无效:', clientid);
     return false;
   }
 
@@ -258,12 +306,12 @@ Adapter.prototype._check = function (client_id, data) {
 
 /**
  * 获取客户端ID字符串
- * @param {string|object} client_id 客户端ID
+ * @param {string|object} clientid 客户端ID
  * @returns {string} 客户端ID字符串
  * @private
  */
-Adapter.prototype._getClientIdStr = function (client_id) {
-  return typeof client_id === 'object' ? client_id.id || 'unknown' : client_id;
+Adapter.prototype._getClientIdStr = function (clientid) {
+  return typeof clientid === 'object' ? clientid.id || 'unknown' : clientid;
 };
 
 /**
@@ -284,21 +332,21 @@ Adapter.prototype._parseStr = function (data) {
 
 /**
  * 解析消息内容
- * @param {string} client_id_str 客户端ID字符串
+ * @param {string} clientid_str 客户端ID字符串
  * @param {string} message 消息内容
  * @returns {any} 解析后的消息
  * @private
  */
-Adapter.prototype._parseMessage = function (client_id_str, message) {
+Adapter.prototype._parseMessage = function (clientid_str, message) {
   try {
     let msg = JSON.parse(message);
     // 检查是否是回复消息（具有id属性）
     if (typeof msg === 'object' && msg.id) {
-      this._onMessage(client_id_str, msg);
+      this._onMessage(clientid_str, msg);
     }
     return msg;
   } catch (error) {
-    this.log('warn', `客户端 ${client_id_str} 发送的消息不是有效的JSON格式: ${message}`, error);
+    this.log('warn', `客户端 ${clientid_str} 发送的消息不是有效的JSON格式: ${message}`, error);
     // 如果不是JSON格式，仍传递给中间件处理
     return message;
   }
@@ -306,15 +354,15 @@ Adapter.prototype._parseMessage = function (client_id_str, message) {
 
 /**
  * 创建上下文对象
- * @param {string} client_id_str 客户端ID字符串
+ * @param {string} clientid_str 客户端ID字符串
  * @param {object} socket 客户端socket对象
  * @param {any} msg 消息内容
  * @returns {object} 上下文对象
  * @private
  */
-Adapter.prototype._createContext = function (client_id_str, socket, msg) {
+Adapter.prototype._createContext = function (clientid_str, socket, msg) {
   return {
-    client_id: client_id_str,
+    clientid: clientid_str,
     socket: socket,
     message: msg,
     adapter: this,
@@ -322,23 +370,23 @@ Adapter.prototype._createContext = function (client_id_str, socket, msg) {
     body: null,
     // 发送消息给当前客户端
     send: (method, params, cb) => {
-      this.send(client_id_str, method, params, cb);
+      this.send(clientid_str, method, params, cb);
     },
     // 异步发送消息
     sendAsync: (method, params = {}) => {
-      return this.sendAsync(client_id_str, method, params);
+      return this.sendAsync(clientid_str, method, params);
     }
   };
 };
 
 /**
  * 消息接收处理
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {object} msg 接收的消息
  */
-Adapter.prototype._onMessage = function (client_id, msg) {
+Adapter.prototype._onMessage = function (clientid, msg) {
   // 查找对应的回调函数
-  this.log('debug', '收到消息', { client_id });
+  this.log('debug', '收到消息', { clientid });
   let callback = this.callback.get(msg.id);
   if (callback) {
     // 执行回调函数并移除
@@ -352,26 +400,25 @@ Adapter.prototype._onMessage = function (client_id, msg) {
 
 /**
  * 连接关闭处理
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  */
-Adapter.prototype._onClose = function (client_id) {
+Adapter.prototype._onClose = function (clientid) {
   // 移除客户端连接
-  this.clients.delete(client_id);
-  this.log('info', `客户端断开连接: ${client_id}`);
+  this.clients.delete(clientid);
+  this.log('info', `客户端断开连接: ${clientid}`);
 };
 
 /**
  * 错误处理
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {Error} error 错误对象
  */
-Adapter.prototype._onError = function (client_id, error) {
-  this.log('error', `客户端 ${client_id} 发生错误:`, error);
+Adapter.prototype._onError = function (clientid, error) {
+  this.log('error', `客户端 ${clientid} 发生错误:`, error);
   // 移除客户端连接
-  this.clients.delete(client_id);
+  this.clients.delete(clientid);
 };
 
-
 /**
  * 停止Adapter服务器（子类可以重写以提供特定实现）
  */
@@ -428,4 +475,10 @@ Adapter.prototype.bcast = function (message, ids = null) {
   }
 };
 
+/**
+ * 启动Adapter服务器
+ */
+Adapter.prototype.start = function () {
+};
+
 exports.Adapter = Adapter;

package/adapter/custom_persistence.js

@@ -69,8 +69,9 @@ Persist.prototype._getKeysByPattern = function(pattern) {
  * @param {Function} cb - 回调函数
  */
 Persist.prototype.addSub = function(client, sub, cb) {
+  console.log('addSub', client.id);
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
@@ -78,7 +79,7 @@ Persist.prototype.addSub = function(client, sub, cb) {
       throw new Error('无效的订阅对象');
     }
     
-    let key = this._getCacheKey(`subscription:${client.clientId}:${sub.topic}`);
+    let key = this._getCacheKey(`subscription:${client.id}:${sub.topic}`);
     this._cache.set(key, sub, this.config.ttl);
     
     if (cb) cb(null);
@@ -95,7 +96,7 @@ Persist.prototype.addSub = function(client, sub, cb) {
  */
 Persist.prototype.removeSub = function(client, sub, cb) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
@@ -103,7 +104,7 @@ Persist.prototype.removeSub = function(client, sub, cb) {
       throw new Error('无效的订阅对象');
     }
     
-    let key = this._getCacheKey(`subscription:${client.clientId}:${sub.topic}`);
+    let key = this._getCacheKey(`subscription:${client.id}:${sub.topic}`);
     this._cache.delete(key);
     
     if (cb) cb(null);
@@ -119,11 +120,11 @@ Persist.prototype.removeSub = function(client, sub, cb) {
  */
 Persist.prototype.removeSubs = function(client, cb) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
-    let pat = `subscription:${client.clientId}:*`;
+    let pat = `subscription:${client.id}:*`;
     let keys = this._getKeysByPattern(pat);
     
     // 同步执行所有删除操作
@@ -144,11 +145,11 @@ Persist.prototype.removeSubs = function(client, cb) {
  */
 Persist.prototype.getSubs = function(client, cb) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
-    let pattern = `subscription:${client.clientId}:*`;
+    let pattern = `subscription:${client.id}:*`;
     let keys = this._getKeysByPattern(pattern);
     
     // 同步执行所有获取操作
@@ -185,7 +186,7 @@ Persist.prototype.subsByTopic = function(topic, cb) {
         let sub = this._cache.get(this._getCacheKey(key));
         if (sub) {
           return {
-            client_id: cid,
+            clientId: cid,
             sub: sub
           };
         }
@@ -271,7 +272,7 @@ Persist.prototype.getRetained = function(topic, cb) {
  */
 Persist.prototype.storePacket = function(client, packet, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
@@ -279,7 +280,7 @@ Persist.prototype.storePacket = function(client, packet, callback) {
       throw new Error('无效的消息包');
     }
     
-    let key = this._getCacheKey(`packet:${client.clientId}:${packet.msgId}`);
+    let key = this._getCacheKey(`packet:${client.id}:${packet.msgId}`);
     this._cache.set(key, packet, this.config.ttl);
     
     if (callback) callback(null);
@@ -296,7 +297,7 @@ Persist.prototype.storePacket = function(client, packet, callback) {
  */
 Persist.prototype.removePacket = function(client, packet, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
@@ -304,7 +305,7 @@ Persist.prototype.removePacket = function(client, packet, callback) {
       throw new Error('无效的消息包');
     }
     
-    let key = this._getCacheKey(`packet:${client.clientId}:${packet.msgId}`);
+    let key = this._getCacheKey(`packet:${client.id}:${packet.msgId}`);
     this._cache.delete(key);
     
     if (callback) callback(null);
@@ -321,7 +322,7 @@ Persist.prototype.removePacket = function(client, packet, callback) {
  */
 Persist.prototype.getPacket = function(client, packet, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
@@ -329,7 +330,7 @@ Persist.prototype.getPacket = function(client, packet, callback) {
       throw new Error('无效的消息包');
     }
     
-    let key = this._getCacheKey(`packet:${client.clientId}:${packet.msgId}`);
+    let key = this._getCacheKey(`packet:${client.id}:${packet.msgId}`);
     
     if (callback) callback(null, this._cache.get(key));
   } catch (error) {
@@ -344,11 +345,11 @@ Persist.prototype.getPacket = function(client, packet, callback) {
  */
 Persist.prototype.getPackets = function(client, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
-    let pattern = `packet:${client.clientId}:*`;
+    let pattern = `packet:${client.id}:*`;
     let keys = this._getKeysByPattern(pattern);
     
     // 同步执行所有获取操作
@@ -399,7 +400,7 @@ Persist.prototype.delOutdatedPacket = function(packet, callback) {
  */
 Persist.prototype.storeWill = function(client, packet, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
@@ -407,7 +408,7 @@ Persist.prototype.storeWill = function(client, packet, callback) {
       throw new Error('无效的消息包');
     }
     
-    let key = this._getCacheKey(`will:${client.clientId}`);
+    let key = this._getCacheKey(`will:${client.id}`);
     this._cache.set(key, packet, this.config.ttl);
     
     if (callback) callback(null);
@@ -423,11 +424,11 @@ Persist.prototype.storeWill = function(client, packet, callback) {
  */
 Persist.prototype.removeWill = function(client, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
-    let key = this._getCacheKey(`will:${client.clientId}`);
+    let key = this._getCacheKey(`will:${client.id}`);
     this._cache.delete(key);
     
     if (callback) callback(null);
@@ -443,11 +444,11 @@ Persist.prototype.removeWill = function(client, callback) {
  */
 Persist.prototype.getWill = function(client, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
-    let key = this._getCacheKey(`will:${client.clientId}`);
+    let key = this._getCacheKey(`will:${client.id}`);
     let will = this._cache.get(key);
     
     if (callback) callback(null, will);
@@ -466,7 +467,7 @@ Persist.prototype.getWill = function(client, callback) {
  */
 Persist.prototype.storeOfflinePacket = function(client, packet, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
@@ -474,7 +475,7 @@ Persist.prototype.storeOfflinePacket = function(client, packet, callback) {
       throw new Error('无效的消息包');
     }
     
-    let key = this._getCacheKey(`offline:${client.clientId}:${packet.msgId}`);
+    let key = this._getCacheKey(`offline:${client.id}:${packet.msgId}`);
     this._cache.set(key, packet, this.config.ttl);
     
     if (callback) callback(null);
@@ -490,11 +491,11 @@ Persist.prototype.storeOfflinePacket = function(client, packet, callback) {
  */
 Persist.prototype.getOfflinePackets = function(client, callback) {
   try {
-    if (!client || !client.clientId) {
+    if (!client || !client.id) {
       throw new Error('无效的客户端对象');
     }
     
-    let pattern = `offline:${client.clientId}:*`;
+    let pattern = `offline:${client.id}:*`;
     let keys = this._getKeysByPattern(pattern);
     
     // 同步执行所有获取操作
@@ -553,7 +554,7 @@ Persist.prototype._procSubs = function(self, stream) {
       if (sub) {
         return {
           type: 'subscription',
-          client_id: cid,
+          clientId: cid,
           sub: sub
         };
       }
@@ -581,7 +582,7 @@ Persist.prototype._procWills = function(self, stream) {
       if (will) {
         return {
           type: 'will',
-          client_id: cid,
+          clientId: cid,
           will: will
         };
       }
@@ -609,7 +610,7 @@ Persist.prototype._procInflightMsgs = function(self, stream) {
       if (packet) {
         return {
           type: 'inflight',
-          client_id: cid,
+          clientId: cid,
           packet: packet
         };
       }
@@ -629,7 +630,7 @@ Persist.prototype.createStream = function() {
   let self = this;
   
   return new Readable({
-    obj_mode: true,
+    objectMode: true,
     
     read() {
       try {