mm_os/tcp.js

MM_OS服务端架构，用于快速构建应用程序，支持网站建设、小程序后台、AI应用、物联网(IOT/AIOT)、游戏服务端等多种场景。

const {
  Manager
} = require('mm_machine');
const {
  Web
} = require('./adapter/web.js');
const {
  Mqtt
} = require('./adapter/mqtt.js');
const {
  Socket
} = require('./adapter/socket.js');
const {
  WebSocket
} = require('./adapter/websocket.js');

const {
  Middleware
} = require('./core/middleware/index.js');
const {
  Notifier
} = require('./core/notifier/index.js');
const {
  Pusher
} = require('./core/pusher/index.js');
const {
  Sender
} = require('./core/sender/index.js');

/**
 * TCP类
 * 负责管理整个应用的服务端架构
 */
class TCP {
  constructor(config, parent) {
    this.getParent = function () {
      return parent;
    };
  }
}

/**
 * 获取适配器
 * @returns {object} 适配器实例
 */
TCP.prototype.getAdapter = function () {
  return this.getParent().adapter;
};

/**
 * 获取管理器
 * @returns {object} 管理器实例
 */
TCP.prototype.getManager = function () {
  return this.getParent().manager;
};

/**
 * 加载
 */
TCP.prototype.load = async function () {
  // 初始化管理器
  await this._initManager();
  // 加载资源
  await this._loadSources();
};

/**
 * 加载资源
 */
TCP.prototype._loadSources = async function () {
  let manager = this.getManager();
  await Promise.all([
    manager.middleware.runAll('load'),
    manager.notifier.runAll('load'),
    manager.sender.runAll('load'),
    manager.pusher.runAll('load')
  ]);
};

/**
 * 初始化
 */
TCP.prototype.init = async function () {
  // 初始化适配器
  await this._initAdapter();
  // 初始化管理器
  await this._initManager();
  // 初始化资源
  await this._initSources();
};

/**
 * 初始化资源
 */
TCP.prototype._initSources = async function () {
  let server = this.getParent();
  let manager = server.manager;
  let adapter = server.adapter;
  await Promise.all([
    manager.notifier.runAll('init', adapter, server.eventer, server.logger),
    manager.sender.runAll('init', adapter, server.eventer, server.logger),
    manager.pusher.runAll('init', adapter, server.eventer, server.logger),
    manager.middleware.runWait('init', adapter, server.eventer, server.logger)
  ]);
};

/**
 * 初始化适配器
 */
TCP.prototype._initAdapter = async function () {
  let server = this.getParent();
  let config  = server.config;
  // http服务器
  var web = new Web(config.web);
  let adapter = server.adapter;
  adapter.web = web;
  web.init(server);
  if (config.web.socket) {
    // websocket服务器 - 与web服务器共享同一个端口
    adapter.ws = await new WebSocket(config.web).init(web);
  }
  if (config.mqtt && config.mqtt.state) {
    // mqtt服务器
    adapter.mqtt = await new Mqtt(config.mqtt).init(server);
  }
  if (config.socket && config.socket.state) {
    // socket服务器
    adapter.socket = await new Socket(config.socket || {}).init(server);
  }
};

/**
 * 初始化管理器
 */
TCP.prototype._initManager = async function () {
  // console.time('[TIMING] _initManager');
  // 管理器配置列表
  var infos = [
    { name: 'middleware', title: '中间件', Module: Middleware },
    { name: 'notifier', title: '通知器', Module: Notifier },
    { name: 'sender', title: '消息发送器', Module: Sender },
    { name: 'pusher', title: '广播器', Module: Pusher }
  ];

  // 管理器实例集合
  var managers = [];

  // 使用for循环初始化所有管理器
  for (var i = 0; i < infos.length; i++) {
    var config = infos[i];
    var manager = this._createManager(config.name, config.title, config.Module);
    managers.push(manager);
  }

  // 并行执行所有管理器的初始化操作
  var list = [];
  for (var j = 0; j < managers.length; j++) {
    list.push(managers[j].do('init'));
  }

  await Promise.all(list);
  // console.timeEnd('[TIMING] _initManager');
};

/**
 * 创建管理器实例
 * @param {string} name 管理器名称
 * @param {string} title 管理器标题
 * @param {Function} cls 管理器类
 * @returns {object} 管理器实例
 */
TCP.prototype._createManager = function (name, title, cls) {
  let server = this.getParent();
  var manager = new Manager(
    {
      name: name,
      title: title,
      filename: name + '.json',
      tpl_dir: `./core/${name}/`.fullname(__dirname),
      base_dir: `./common/${name}/`.fullname(__dirname),
      dir: `./${name}`.fullname()
    },
    server,
    server[name],
    cls
  );
  // 设置到对应的管理器属性
  server.manager[name] = manager;
  return manager;
};

/**
 * 启动
 */
TCP.prototype.start = async function () {
  await this._startSources();
  await this._startAdapter();
};

/**
 * 启动资源
 */
TCP.prototype._startSources = async function () {
  let manager = this.getManager();
  await Promise.all([
    manager.middleware.runAll('start'),
    manager.notifier.runAll('start'),
    manager.sender.runAll('start'),
    manager.pusher.runAll('start')
  ]);
};

/**
 * 启动适配器
 */
TCP.prototype._startAdapter = async function () {
  let list = [];
  let adapter = this.getAdapter();
  for (var k in adapter) {
    try {
      list.push(adapter[k].start());
    } catch (error) {
      this.log('error', '启动适配器失败:', error);
    }
  }
  await Promise.all(list);
};

/**
 * 停止
 */
TCP.prototype.stop = async function () {
  // 停止适配器
  await this._stopAdapter();
  // 停止资源
  await this._stopSources();
};

/**
 * 停止适配器
 */
TCP.prototype._stopAdapter = async function () {
  for (var k in this.getAdapter()) {
    try {
      await this.getAdapter()[k].stop();
    } catch (error) {
      this.log('error', '停止适配器失败:', error);
    }
  }
};

/**
 * 停止资源
 */
TCP.prototype._stopSources = async function () {
  let manager = this.getManager();
  await Promise.all([
    manager.middleware.runAll('stop'),
    manager.notifier.runAll('stop'),
    manager.pusher.runAll('stop'),
    manager.sender.runAll('stop')
  ]);
};

/**
 * 运行
 * @returns {object} TCP实例
 */
TCP.prototype.run = async function () {
  await this.load();
  await this.init();
  await this.start();
  return this;
};

module.exports = {
  TCP
};