mm_os 3.3.1 → 4.0.1

package/adapter/mqtt.js

@@ -0,0 +1,273 @@
+const { Aedes } = require('aedes');
+const net = require('net');
+const { Adapter } = require('./adapter');
+const { Persist } = require('./custom_persistence.js');
+
+/**
+ * MQTT适配器
+ */
+class Mqtt extends Adapter {
+  static config = {
+    host: '127.0.0.1',
+    port: 1883,
+    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'}
+  };
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父对象
+   */
+  constructor(config, parent) {
+    super({ ...Mqtt.config, ...config }, parent);
+  }
+}
+
+/**
+ * 初始化适配器
+ * @param {object} cache 缓存管理器
+ * @private
+ */
+Mqtt.prototype._init = function (cache) {
+  // 创建自定义持久化实例
+  let persist = null;
+  if (this.server && cache) {
+    persist = new Persist(this.config, cache);
+    this.log('info', 'MQTT使用自定义持久化');
+  }
+  // 创建aedes实例，传入自定义持久化
+  this.broker = new Aedes({
+    persist: persist
+  });
+  // 创建TCP服务器
+  this.web = net.createServer(this.broker.handle);
+
+  // 配置身份验证
+  this._setupAuth();
+
+  // 监听客户端连接
+  this.broker.on('client', (client) => {
+    // 存储客户端连接
+    this.clients.set(client.id, client);
+
+    // 记录连接日志
+    this.log('info', `MQTT客户端连接成功: ${client.id}`);
+  });
+  return this;
+};
+
+/**
+ * 检查用户是否存在
+ * @param {string} client_id 客户端ID
+ * @param {string} username 用户名
+ * @param {string} password 密码
+ * @returns {Promise<boolean>} 是否存在
+ */
+Mqtt.prototype.checkUser = async function (client_id, username, password) {
+  this.log('debug', '检查用户', { client_id });
+  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);
+};
+
+/**
+ * 验证客户端身份
+ * @param {object} client 客户端对象
+ * @param {string} username 用户名
+ * @param {object} password 密码
+ * @returns {Promise<boolean>} 是否验证通过
+ */
+Mqtt.prototype.auth = async function (client, username, password) {
+  // 查找匹配的用户
+  return await this.checkUser(client.id, username, password);
+};
+
+/**
+ * 配置身份验证
+ * @private
+ */
+Mqtt.prototype._setupAuth = function () {
+  // 如果启用了身份验证
+  if (this.config.auth_enabled) {
+    // 监听认证事件
+    this.broker.auth = async (client, username, password, callback) => {
+      try {
+        // 转换密码格式为字符串
+        let password_str = password ? password.toString() : '';
+
+        // 记录认证尝试
+        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}`);
+          return callback(null, true);
+        } else {
+          this.log('warn', `MQTT认证失败: clientId=${client.id}, username=${username}, 用户名或密码错误`);
+          return callback(new Error('用户名或密码错误'));
+        }
+      } catch (error) {
+        this.log('error', `MQTT认证错误: clientId=${client.id}`, error);
+        return callback(new Error('认证服务内部错误'));
+      }
+    };
+
+    this.log('info', 'MQTT身份验证已启用');
+  }
+};
+
+/**
+ * 启动MQTT服务器
+ */
+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身份验证已启用');
+    }
+  });
+
+  // 监听服务器错误
+  this.web.on('error', (error) => {
+    this.log('error', 'MQTT服务器启动失败:', 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 主题
+ * @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.publish = function (topic, message, options) {
+  try {
+    // 默认选项
+    const OPTS = {qos: 0,
+      retain: false,
+      push_topic: null, ...options || {}};
+
+    this.broker.publish({
+      topic: topic,
+      payload: message,
+      qos: OPTS.qos,
+      retain: OPTS.retain
+    });
+
+    this.log('debug', `MQTT服务器发布消息到主题 ${topic}: ${message}, qos: ${OPTS.qos}, retain: ${OPTS.retain}`);
+    return true;
+  } catch (error) {
+    this.log('error', 'MQTT发布消息失败:', error);
+    return false;
+  }
+};
+
+/**
+ * 订阅主题
+ * @param {string} topic 主题
+ * @param {Function} callback 回调函数
+ */
+Mqtt.prototype.subscribe = function (topic, callback) {
+  this.broker.subscribe(topic, callback);
+};
+
+/**
+ * 取消订阅主题
+ * @param {string} topic 主题
+ * @param {Function} callback 回调函数
+ */
+Mqtt.prototype.unsubscribe = function (topic, callback) {
+  this.broker.unsubscribe(topic, callback);
+};
+
+/**
+ * 停止服务器
+ */
+Mqtt.prototype.stop = function () {
+  // 调用父类的_stop方法
+  this._stop();
+
+  // 关闭服务器
+  this.web.close(() => {
+    // 清空客户端集合
+    this.clients.clear();
+    this.log('info', 'MQTT服务器已停止');
+  });
+};
+
+/**
+ * 停止Adapter服务器
+ * @private
+ */
+Mqtt.prototype._stop = function () {
+  // 关闭所有客户端连接
+  for (let [client_id, client] of this.clients) {
+    try {
+      // 使用MQTT客户端的断开连接方法
+      if (client && client.close) {
+        client.close();
+      }
+    } catch (error) {
+      this.log('error', `关闭MQTT客户端 ${client_id} 失败:`, error);
+    }
+  }
+};
+
+exports.Mqtt = Mqtt;

package/adapter/socket.js

@@ -0,0 +1,113 @@
+const net = require('net');
+const { Adapter } = require('./adapter');
+
+/**
+ * Socket适配器
+ */
+class Socket extends Adapter {
+  static config = {
+    host: '0.0.0.0',
+    port: 8200
+  };
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   * @param {object} parent 父对象
+   */
+  constructor(config, parent) {
+    super({ ...Socket.config, ...config }, parent);
+  }
+}
+
+/**
+ * 初始化适配器
+ * @private
+ */
+Socket.prototype._init = function () {
+  // 创建TCP服务器
+  this.web = net.createServer(this._onConn.bind(this));
+
+  return this;
+};
+
+/**
+ * 客户端连接处理
+ * @param {Socket} socket 客户端socket
+ * @private
+ */
+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());
+  });
+
+  // 监听连接关闭
+  socket.on('close', () => {
+    this._onClose(client_id);
+  });
+
+  // 监听错误事件
+  socket.on('error', (error) => {
+    this._onError(client_id, error);
+  });
+};
+
+/**
+ * 启动适配器
+ */
+Socket.prototype.start = function () {
+  let { host, port } = this.config;
+  this.web.listen(port, host, () => {
+    this.log('info', `启动成功！监听地址：${host}:${port}`);
+  });
+
+  // 监听服务器错误
+  this.web.on('error', (error) => {
+    this.log('error', '启动失败:', error);
+  });
+};
+
+/**
+ * 发送消息
+ * @param {string} client_id 客户端ID
+ * @param {string} message 消息内容
+ * @returns {boolean} 发送是否成功
+ * @private
+ */
+Socket.prototype._send = function (client_id, message) {
+  let socket = this.clients.get(client_id);
+  if (socket && !socket.destroyed) {
+    socket.write(message);
+    this.log('debug', `服务器向 ${client_id} 发送消息: ${message}`);
+    return true;
+  } else {
+    this.log('warn', `客户端 ${client_id} 不存在或已关闭`);
+    return false;
+  }
+};
+
+/**
+ * 停止适配器
+ */
+Socket.prototype.stop = function () {
+  // 调用父类的_stop方法
+  this._stop();
+
+  // 关闭服务器
+  this.web.close(() => {
+    // 清空客户端集合
+    this.clients.clear();
+    this.log('info', '服务器已停止');
+  });
+};
+
+exports.Socket = Socket;

package/adapter/web.js

@@ -0,0 +1,67 @@
+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 服务器实例
+ */
+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;

package/adapter/websocket.js

@@ -0,0 +1,146 @@
+const Koa = require('koa');
+const websocket = require('koa-websocket');
+const { Adapter } = require('./adapter.js');
+
+/**
+ * WebSocket适配器
+ */
+class WebSocket extends Adapter {
+  static config = {
+    host: '0.0.0.0',
+    port: 8300
+  };
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   * @param {object} parent 父对象
+   */
+  constructor(config, parent) {
+    super({ ...WebSocket.config, ...config }, parent);
+  }
+}
+
+/**
+ * 初始化WebSocket适配器
+ * @param {object} web 应用实例
+ * @private
+ */
+WebSocket.prototype._init = function (web) {
+  // 如果提供了应用实例
+  if (web) {
+    // 检查是否已经是websocket实例
+    if (web.ws) {
+      // 已经是websocket实例，直接使用
+      this._web = web;
+      this.external_app = true;
+    } else {
+      // 不是websocket实例，包装它
+      this._web = websocket(web);
+      this.external_app = true;
+    }
+  } else {
+    // 没有提供应用实例，创建新的
+    this._web = websocket(new Koa());
+    this.external_app = false;
+  }
+  this.broker = this._web.ws;
+  // 简化实现：不设置中间件，在连接时处理
+};
+
+/**
+ * 发送消息
+ * @private
+ * @param {string} client_id 客户端ID
+ * @param {string} message 消息内容
+ * @returns {boolean} 发送是否成功
+ */
+WebSocket.prototype._send = function (client_id, message) {
+  let ws = this.clients.get(client_id);
+  if (ws && ws.readyState === 1) { // WebSocket.OPEN
+    ws.send(message);
+    this.log('debug', `服务器向 ${client_id} 发送消息: ${message}`);
+    return true;
+  } else {
+    this.log('warn', `客户端 ${client_id} 不存在或已关闭`);
+    return false;
+  }
+};
+
+/**
+ * 启动WebSocket服务器
+ * @returns {object|undefined} 服务器实例或undefined
+ */
+WebSocket.prototype.start = function () {
+  let {
+    host,
+    port
+  } = this.config;
+  // 如果没有提供外部app实例，启动自己的服务器
+  if (!this.external_app) {
+    return this._web.listen(port, host, () => {
+      this.log('info', `启动成功！监听地址：ws://127.0.0.1:${port}`);
+    });
+  } else {
+    // 如果提供了外部app实例，只需要记录日志
+    this.log('info', `启动成功！访问地址：ws://127.0.0.1:${port}`);
+  }
+
+  // 监听服务器错误（仅当是自己创建的服务器时）
+  if (this._tcp_server && !this.external_app) {
+    this._tcp_server.on('error', (error) => {
+      this.log('error', '服务器启动失败:', error);
+    });
+  }
+};
+
+/**
+ * 停止Adapter服务器
+ * @private
+ */
+WebSocket.prototype._stop = function () {
+  // 关闭所有客户端连接
+  for (let [, ws] of this.clients) {
+    ws.close();
+  }
+};
+
+/**
+ * 处理消息接收
+ * @private
+ * @param {string} client_id 客户端ID
+ * @param {object} ws WebSocket实例
+ * @param {string} message 消息内容
+ */
+WebSocket.prototype._onMessage = function (client_id, ws, message) {
+  this.log('debug', '收到消息', { client_id: client_id });
+};
+
+/**
+ * 处理连接关闭
+ * @private
+ * @param {string} client_id 客户端ID
+ */
+WebSocket.prototype._onClose = function (client_id) {
+  this.clients.delete(client_id);
+  this.log('info', `客户端断开连接: ${client_id}`);
+};
+
+/**
+ * 处理错误事件
+ * @private
+ * @param {string} client_id 客户端ID
+ * @param {Error} error 错误对象
+ */
+WebSocket.prototype._onError = function (client_id, error) {
+  this.log('error', `客户端 ${client_id} 发生错误:`, error);
+};
+
+/**
+ * 使用中间件
+ * @param {function} middleware 中间件函数
+ */
+WebSocket.prototype.use = function (middleware) {
+  this.broker.use(middleware);
+};
+
+exports.WebSocket = WebSocket;

package/com/api/com.json

@@ -0,0 +1,5 @@
+{
+    "name": "Api",
+    "title": "API管理器",
+    "state": 1
+}

package/{core/com → com}/api/config.tpl.json

@@ -1,22 +1,22 @@
 {
 	// 路由路径
-	"path": "{path}",
+	"path": "{path || '/'}",
 	// 名称, 用于动态增删改API配置
-	"name": "{name}",
+	"name": "{name || 'api'}",
 	// 标题, 用于开发文档显示
-	"title": "示例接口",
+	"title": "{title || '示例接口'}",
 	// 描述, 用于介绍该路由的作用
-	"description": "描述接口使用方法",
+	"description": "{description || '描述接口使用方法'}",
 	// 函数文件, 用于驱动脚本, 实现业务 
-	"func_file": "./index.js",
+	"main": "{main || './index.js'}",
 	// 请求方法, 选填 GET, POST, ALL。 ALL指同时支持GET/POST
 	"method": "ALL",
 	// 开放域, 如果域未开放, 则只有特定的协议头才能访问该API, 同时API文档不接见
 	"scope": true,
-	// 缓存时长, 单位: 分钟。使用缓存后, 二次访问API直接从缓存读取, 不重复执行业务脚本
-	"cache": 0,
 	// 是否启用
 	"state": 1,
+	// 缓存时长, 单位: 分钟。使用缓存后, 二次访问API直接从缓存读取, 不重复执行业务脚本
+	"cache": 0,
 	// 是否客户端缓存, 使用客户端则不再访问服务器, 直接从浏览器中拿; 使用服务端缓存则会访问服务器   
 	"client_cache": false,
 	// SQL配置路径, 用于将请求参数拼接成SQL, 实现比较复杂的查询
@@ -26,7 +26,7 @@
 	/* 授权协议 */
 	"oauth": {
 		// 是否需要登录, true表示需要登录才能访问该接口
-		"signIn": false,
+		"sign_in": false,
 		// 会员权限级别, 如果小于该值, 则无法访问, 0为不限制
 		"vip": 0,
 		// 管理员权限级别, 如果小于该值, 则无法访问, 0为不限制