mm_os 4.2.6 → 4.2.8

package/adapter/mqtt.js

@@ -13,10 +13,8 @@ class Mqtt extends Adapter {
     cache: true,
     prefix: 'mqtt_',
     ttl: 3600000,
-    push_topic: 'client/iot/${client_id}',
-    receive_topic: 'client/iot/${client_id}',
     auth_enabled: false,
-    auth_users: [], // 用户名密码列表，格式: {username: 'user', password: 'pass'}
+    auth_users: [], // 用户名密码列表，格式: { clientid: 'server', username: 'user', password: 'pass'}
   };
   /**
    * 构造函数
@@ -34,17 +32,23 @@ class Mqtt extends Adapter {
  * @returns {object} 适配器实例
  * @private
  */
-Mqtt.prototype._init = function (cache) {
+Mqtt.prototype._init = async function (cache) {
   // 创建自定义持久化实例
   let persist = null;
-  if (this.server && cache) {
+  if (this.web && cache) {
     persist = new Persist(this.config, cache);
     this.log('info', 'MQTT使用自定义持久化');
   }
-  // 创建aedes实例，传入自定义持久化
+  // 创建aedes实例
+  // 注意: aedes v1构造函数不初始化persistence，需要调用listen()
   this.broker = new Aedes({
-    persist: persist
+    persistence: persist,
+    preConnect: function (client, packet, callback) {
+      callback(null, true);
+    }
   });
+  // 必须调用listen()初始化persistence，否则客户端连接时会崩溃
+  await this.broker.listen();
   // 创建TCP服务器
   this.web = net.createServer(this.broker.handle);
 
@@ -64,18 +68,18 @@ Mqtt.prototype._init = function (cache) {
 
 /**
  * 检查用户是否存在
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {string} username 用户名
  * @param {string} password 密码
  * @returns {Promise<boolean>} 是否存在
  */
-Mqtt.prototype.checkUser = async function (client_id, username, password) {
-  this.log('debug', '检查用户', { client_id });
+Mqtt.prototype.checkUser = async function (clientid, username, password) {
+  this.log('debug', '检查用户', clientid, username);
   let pass = password ? password.toString() : '';
   // 查找匹配的用户
   // 在实际应用中，这里可以改为异步数据库查询
   // 例如: return await db.query('SELECT * FROM users WHERE username = ? AND password = ?', [username, password_str]);
-  return this.config.auth_users.find(u => u.username === username && u.password === pass);
+  return this.config.auth_users.find(u => u.clientid === clientid && u.username === username && u.password === pass);
 };
 
 /**
@@ -98,21 +102,21 @@ Mqtt.prototype._setupAuth = function () {
   // 如果启用了身份验证
   if (this.config.auth_enabled) {
     // 监听认证事件
-    this.broker.auth = async (client, username, password, callback) => {
+    this.broker.authenticate = async (client, username, password, callback) => {
       try {
         // 转换密码格式为字符串
         let password_str = password ? password.toString() : '';
 
-        // 记录认证尝试
-        this.log('debug', `MQTT认证尝试: clientId=${client.id}, username=${username}, password=${password_str ? '[存在]' : '[不存在]'}`);
+        // // 记录认证尝试
+        // this.log('debug', `MQTT认证尝试: clientId=${client.id}, username=${username}, password=${password_str ? '[存在]' : '[不存在]'}`);
 
         // 如果提供了自定义验证函数，则使用自定义验证
         let user = await this.auth(client, username, password_str);
         if (user) {
-          this.log('info', `MQTT认证成功: clientId=${client.id}, username=${username}`);
+          // this.log('info', `MQTT认证成功: clientId=${client.id}, username=${username}`);
           return callback(null, true);
         } else {
-          this.log('warn', `MQTT认证失败: clientId=${client.id}, username=${username}, 用户名或密码错误`);
+          // this.log('warn', `MQTT认证失败: clientId=${client.id}, username=${username}, 用户名或密码错误`);
           return callback(new Error('用户名或密码错误'));
         }
       } catch (error) {
@@ -120,75 +124,34 @@ Mqtt.prototype._setupAuth = function () {
         return callback(new Error('认证服务内部错误'));
       }
     };
-
-    this.log('info', 'MQTT身份验证已启用');
   }
 };
 
 /**
  * 启动MQTT服务器
+ * @returns {Promise} 返回Promise，等待服务端启动完成
  */
 Mqtt.prototype.start = function () {
-  let {
-    host,
-    port
-  } = this.config;
-
-  this.web.listen(port, host, () => {
-    this.log('info', `MQTT启动成功！访问地址：mqtt://${host}:${port}`);
-    if (this.config.auth_enabled) {
-      this.log('info', 'MQTT身份验证已启用');
-    }
-  });
+  var _this = this;
+  return new Promise((resolve, reject) => {
+    let {
+      host,
+      port
+    } = _this.config;
+
+    _this.web.listen(port, host, () => {
+      _this.log('info', `MQTT服务端启动！访问地址：mqtt://${host}:${port}`);
+      resolve();
+    });
 
-  // 监听服务器错误
-  this.web.on('error', (error) => {
-    this.log('error', 'MQTT服务器启动失败:', error);
+    // 监听服务器错误
+    _this.web.on('error', (error) => {
+      _this.log('error', 'MQTT服务器启动失败:', error);
+      reject(error);
+    });
   });
 };
 
-/**
- * 发送消息
- * @private
- * @param {string} client_id 客户端ID
- * @param {string} message 消息内容
- * @param {object} [options] 发送选项
- * @param {number} [options.qos=0] QoS级别(0, 1, 2)
- * @param {boolean} [options.retain=false] 是否为retain消息
- * @returns {boolean} 发送是否成功
- */
-Mqtt.prototype._send = function (client_id, message, options) {
-  let client = this.clients.get(client_id);
-  if (client) {
-    try {
-      // 默认选项
-      const OPTS = {
-        qos: 0,
-        retain: false,
-        push_topic: null, ...options || {}};
-
-      // MQTT通常需要发布到特定主题，这里简单处理
-      // 实际应用中可能需要根据协议规范处理
-      let topic = OPTS.push_topic || this.config.push_topic.replace('${client_id}', client_id);
-      this.broker.publish({
-        topic: topic,
-        payload: message,
-        qos: OPTS.qos,
-        retain: OPTS.retain
-      });
-
-      this.log('debug', `MQTT服务器向 ${client_id} 发送消息: ${message}, qos: ${OPTS.qos}, retain: ${OPTS.retain}`);
-      return true;
-    } catch (error) {
-      this.log('error', 'MQTT发送消息失败:', error);
-      return false;
-    }
-  } else {
-    this.log('warn', `MQTT客户端 ${client_id} 不存在或已关闭`);
-    return false;
-  }
-};
-
 /**
  * 发布消息到指定主题
  * @param {string} topic 主题
@@ -202,8 +165,7 @@ Mqtt.prototype.publish = function (topic, message, options) {
   try {
     // 默认选项
     const OPTS = {qos: 0,
-      retain: false,
-      push_topic: null, ...options || {}};
+      retain: false, ...options || {}};
 
     this.broker.publish({
       topic: topic,
@@ -246,7 +208,7 @@ Mqtt.prototype.stop = function () {
   this._stop();
 
   // 关闭服务器
-  this.web.close(() => {
+  this.broker.close(() => {
     // 清空客户端集合
     this.clients.clear();
     this.log('info', 'MQTT服务器已停止');
@@ -259,16 +221,34 @@ Mqtt.prototype.stop = function () {
  */
 Mqtt.prototype._stop = function () {
   // 关闭所有客户端连接
-  for (let [client_id, client] of this.clients) {
+  for (let [clientid, client] of this.clients) {
     try {
       // 使用MQTT客户端的断开连接方法
       if (client && client.close) {
         client.close();
       }
     } catch (error) {
-      this.log('error', `关闭MQTT客户端 ${client_id} 失败:`, error);
+      this.log('error', `关闭MQTT客户端 ${clientid} 失败:`, error);
     }
   }
 };
 
+/**
+ * 监听MQTT事件
+ * @param {string} event 事件名称
+ * @param {...*} args 事件参数
+ */
+Mqtt.prototype.on = function (event, ...args) {
+  this.broker.on(event, ...args);
+};
+
+/**
+ * 取消监听MQTT事件
+ * @param {string} event 事件名称
+ * @param {...*} args 事件参数
+ */
+Mqtt.prototype.off = function (event, ...args) {
+  this.broker.off(event, ...args);
+};
+
 exports.Mqtt = Mqtt;

package/adapter/socket.js

@@ -9,106 +9,236 @@ class Socket extends Adapter {
     host: '0.0.0.0',
     port: 8200
   };
-  /**
-   * 构造函数
-   * @param {object} config 配置对象
-   * @param {object} parent 父对象
-   */
   constructor(config, parent) {
     super({ ...Socket.config, ...config }, parent);
   }
 }
 
 /**
- * 初始化适配器
+ * 初始化 - 供外部调用
+ * @param {object} server 服务器实例
  * @returns {object} 适配器实例
- * @private
  */
-Socket.prototype._init = function () {
-  // 创建TCP服务器
-  this.web = net.createServer(this._onConn.bind(this));
-
+Socket.prototype.init = function (server) {
+  if (server) {
+    this.getServer = function () { return server; };
+  }
+  this._middleware = [];
   return this;
 };
 
+/**
+ * 注册中间件
+ * @param {Function} middleware async (ctx, next) => {}
+ */
+Socket.prototype.use = function (middleware) {
+  this._middleware.push(middleware);
+};
+
+/**
+ * 启动适配器
+ */
+Socket.prototype.start = function () {
+  var self = this;
+  var { host, port } = this.config;
+
+  this.web = net.createServer(function (socket) {
+    self._onConn(socket);
+  });
+
+  this.web.listen(port, host, function () {
+    self.log('info', 'Socket服务已启动！监听地址：' + host + ':' + port);
+  });
+
+  this.web.on('error', function (error) {
+    self.log('error', 'Socket启动失败:', error);
+  });
+};
 /**
  * 客户端连接处理
- * @param {Socket} socket 客户端socket
- * @private
+ * @param {net.Socket} socket TCP socket
  */
 Socket.prototype._onConn = function (socket) {
-  // 生成唯一客户端ID
-  let client_id = `client_${this.genClientId()}`;
-  // 存储客户端连接
-  this.clients.set(client_id, socket);
-
-  // 记录连接日志
-  this.log('info', `客户端连接成功: ${client_id} (${socket.remoteAddress}:${socket.remotePort})`);
-
-  // 监听数据接收
-  socket.on('data', (data) => {
-    this.log('debug', `服务器接收 ${client_id} 消息: ${data.toString()}`);
-    this._onMessage(client_id, data.toString());
+  var self = this;
+  var client_ip = socket.remoteAddress || '127.0.0.1';
+  var clientid = 'tcp_' + this.genClientId();
+
+  this.clients.set(clientid, socket);
+  this.log('info', 'Socket客户端连接成功:', client_ip, clientid);
+
+  // 缓存未处理完的数据（TCP 粘包处理）
+  var buffer = '';
+
+  socket.on('data', function (data) {
+    buffer += data.toString();
+
+    // 尝试按换行符分割完整消息
+    var lines = buffer.split('\n');
+    // 最后一段可能是未完成的消息，保留到 buffer
+    buffer = lines.pop() || '';
+
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      if (!line) continue;
+      self._onData(line, socket, clientid);
+    }
   });
 
-  // 监听连接关闭
-  socket.on('close', () => {
-    this._onClose(client_id);
+  socket.on('close', function () {
+    self._onClose(clientid);
+    self.clients.delete(clientid);
   });
 
-  // 监听错误事件
-  socket.on('error', (error) => {
-    this._onError(client_id, error);
+  socket.on('error', function (err) {
+    self.log('error', 'Socket客户端错误:', clientid, err);
+    self.clients.delete(clientid);
   });
 };
 
 /**
- * 启动适配器
+ * 收到一行完整数据
+ * @param {string} body_str 消息内容
+ * @param {net.Socket} socket TCP socket
+ * @param {string} clientid 客户端ID
  */
-Socket.prototype.start = function () {
-  let { host, port } = this.config;
-  this.web.listen(port, host, () => {
-    this.log('info', `启动成功！监听地址：${host}:${port}`);
-  });
+Socket.prototype._onData = function (body_str, socket, clientid) {
+  var self = this;
+
+  // 尝试解析 JSON
+  var json;
+  if (body_str.indexOf('{') === 0 || body_str.indexOf('[') === 0) {
+    try {
+      json = JSON.parse(body_str);
+    } catch (e) {
+      // 非 JSON 格式，按原始消息处理
+    }
+  }
+
+  // 创建最小上下文
+  var ctx = {
+    clientid: clientid,
+    socket: socket,
+    message: json || body_str,
+    ip: socket.remoteAddress || '127.0.0.1',
+    send: function (data) {
+      var str = typeof data === 'object' ? JSON.stringify(data) : data;
+      if (socket.writable) {
+        socket.write(str + '\n');
+      }
+    },
+    close: function () {
+      socket.end();
+    }
+  };
+
+  if (json && json.method) {
+    // 有 method 字段，走 methods 分发
+    this._dispatchMethod(json, ctx);
+  } else {
+    // 走中间件链
+    this._runMiddleware(ctx);
+  }
+};
+
+/**
+ * 分发方法调用
+ * @param {object} json {id, method, params}
+ * @param {object} ctx 上下文
+ */
+Socket.prototype._dispatchMethod = function (json, ctx) {
+  var self = this;
+  var { id, method, params } = json;
+
+  // 如果有 result 字段且是回复消息，触发回调
+  if (json.result && id) {
+    // 交由中间件处理（未来可扩展回调）
+    this._runMiddleware(ctx);
+    return;
+  }
+
+  // 查找方法
+  // 先从 adapter 自身的 methods 找，再从全局 $.methods 找
+  var handler = this.methods && this.methods[method];
+  if (!handler) {
+    handler = $.methods && $.methods[method];
+  }
 
-  // 监听服务器错误
-  this.web.on('error', (error) => {
-    this.log('error', '启动失败:', error);
+  if (handler) {
+    // 异步执行方法
+    Promise.resolve().then(function () {
+      return handler(params, ctx);
+    }).then(function (result) {
+      if (result !== undefined && result !== null && id) {
+        var ret = { id: id };
+        if (typeof result === 'object' && !Array.isArray(result)) {
+          Object.assign(ret, result);
+        } else {
+          ret.result = result;
+        }
+        ctx.send(ret);
+      }
+    }).catch(function (err) {
+      self.log('error', 'Socket方法执行错误:', err);
+      if (id) {
+        var err_ret = { id: id, error: { message: err.message || '执行失败' } };
+        ctx.send(err_ret);
+      }
+    });
+  } else {
+    // 未找到方法，走中间件链
+    this._runMiddleware(ctx);
+  }
+};
+
+/**
+ * 运行中间件链
+ * @param {object} ctx 上下文
+ */
+Socket.prototype._runMiddleware = function (ctx) {
+  var mw = this._middleware;
+  if (mw.length === 0) return;
+
+  var idx = 0;
+  var self = this;
+  function next() {
+    var fn = mw[idx++];
+    if (fn) {
+      return Promise.resolve(fn(ctx, next));
+    }
+    return Promise.resolve();
+  }
+  next().catch(function (err) {
+    self.log('error', 'Socket中间件错误:', err);
   });
 };
 
 /**
  * 发送消息
- * @param {string} client_id 客户端ID
+ * @param {string} clientid 客户端ID
  * @param {string} message 消息内容
  * @returns {boolean} 发送是否成功
- * @private
  */
-Socket.prototype._send = function (client_id, message) {
-  let socket = this.clients.get(client_id);
+Socket.prototype._send = function (clientid, message) {
+  let socket = this.clients.get(clientid);
   if (socket && !socket.destroyed) {
-    socket.write(message);
-    this.log('debug', `服务器向 ${client_id} 发送消息: ${message}`);
+    var str = typeof message === 'object' ? JSON.stringify(message) : message;
+    socket.write(str + '\n');
     return true;
-  } else {
-    this.log('warn', `客户端 ${client_id} 不存在或已关闭`);
-    return false;
   }
+  return false;
 };
 
 /**
  * 停止适配器
  */
 Socket.prototype.stop = function () {
-  // 调用父类的_stop方法
   this._stop();
-
-  // 关闭服务器
-  this.web.close(() => {
-    // 清空客户端集合
-    this.clients.clear();
-    this.log('info', '服务器已停止');
-  });
+  if (this.web) {
+    this.web.close(function () {
+      this.clients.clear();
+      this.log('info', 'Socket服务已停止');
+    }.bind(this));
+  }
 };
 
-exports.Socket = Socket;
+exports.Socket = Socket;

package/adapter/web.js

@@ -1,68 +1,92 @@
-const Koa = require('koa');
-const { Adapter } = require('./adapter');
-
-/**
- * Web适配器类
- * 基于Koa框架的HTTP服务器适配器
- */
-class Web extends Adapter {
-  static config = {
-    host: '0.0.0.0',
-    port: 8000
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} parent 父对象
-   */
-  constructor(config, parent) {
-    super({ ...Web.config, ...config }, parent);
-  }
-}
-
-/**
- * 预置
- */
-Web.prototype._preset = function () {
-  this.web = new Koa(this.config);
-  // 设置cookie签名密钥
-  this.web.keys = ['mos-secret-key-2024', 'mos-backup-key-2024'];
-};
-
-/**
- * 使用中间件
- * @param {Function} middleware 中间件函数
- */
-Web.prototype.use = function (middleware) {
-  this.web.use(middleware);
-};
-
-/**
- * 初始化
- * @param {object} server 服务器实例
- * @returns {object} 适配器实例
- */
-Web.prototype.init = function (server) {
-  if (server) {
-    this.getServer = function () {
-      return server;
-    };
-  }
-  return this;
-};
-
-/**
- * 启动
- */
-Web.prototype.start = function () {
-  var {
-    host,
-    port
-  } = this.config;
-  this.web.listen(port, host, () => {
-    this.log('info', `web启动成功！访问网址：http://${host}:${port}`);
-  });
-};
-
-exports.Web = Web;
+const Koa = require('koa');
+const { Adapter } = require('./adapter');
+
+/**
+ * Web适配器类
+ * 基于Koa框架的HTTP服务器适配器
+ */
+class Web extends Adapter {
+  static config = {
+    host: '0.0.0.0',
+    port: 8000,
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父对象
+   */
+  constructor(config, parent) {
+    super({ ...Web.config, ...config }, parent);
+  }
+}
+
+/**
+ * 预置
+ */
+Web.prototype._preset = function () {
+  this.web = new Koa(this.config);
+  // 设置cookie签名密钥
+  this.web.keys = ['mos-secret-key-2024', 'mos-backup-key-2024'];
+
+  // 添加客户端断开处理中间件（必须在最前面）
+  this.web.use(async (ctx, next) => {
+    try {
+      await next();
+    } catch (err) {
+      if (err.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+        // 客户端断开连接，无需处理
+        return;
+      }
+      throw err;
+    }
+  });
+};
+
+/**
+ * 使用中间件
+ * @param {Function} middleware 中间件函数
+ */
+Web.prototype.use = function (middleware) {
+  this.web.use(middleware);
+};
+
+/**
+ * 获取当前中间件处理函数
+ * @returns {Function} 组合后的中间件函数
+ */
+Web.prototype._getFn = function () {
+  return this.web.callback();
+};
+
+/**
+ * 初始化
+ * @param {object} server 服务器实例
+ * @returns {object} 适配器实例
+ */
+Web.prototype.init = function (server) {
+  if (server) {
+    this.getServer = function () {
+      return server;
+    };
+  }
+  return this;
+};
+
+/**
+ * 启动
+ */
+Web.prototype.start = function () {
+  var { host, port } = this.config;
+  this.server = this.web.listen(port, host, () => {
+    this.log('info', `web服务端已启动！访问网址：http://${host}:${port}`);
+  });
+
+  // 配置服务器超时参数
+  this.server.timeout = 60000; // 请求超时 60s（默认120s）
+  this.server.headersTimeout = 65000; // 请求头超时（需大于timeout）
+  this.server.keepAliveTimeout = 65000; // Keep-Alive 超时
+  this.server.requestTimeout = 60000; // Node.js 14+ 请求超时
+};
+
+exports.Web = Web;