ee-core 2.12.0 → 4.0.0

package/socket/httpServer.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const debug = require('debug')('ee-core:socket:httpServer');
 const assert = require('assert');
 const is = require('is-type-of');
 const Koa = require('koa');
@@ -9,25 +10,37 @@ const https = require('https');
 const fs = require('fs');
 const path = require('path');
 const _ = require('lodash');
-const Log = require('../log');
-const Ps = require('../ps');
+const { coreLogger } = require('../log');
+const { getBaseDir } = require('../ps');
+const { getController } = require('../controller');
+const { getConfig } = require('../config');
+const { getPort } = require('../utils/port');
+
+let channelSeparator = '/';
 
 /**
  * http server
  */
 class HttpServer {
-  constructor (app) {
-    this.app = app;
-    this.options = this.app.config.httpServer;
+  constructor () {
+    const { httpServer, mainServer } = getConfig();
+    this.config = httpServer;
+    channelSeparator = mainServer.channelSeparator;
+    this.httpApp = undefined;
+    this.init();
+  }
 
-    if (this.options.enable == false) {
+  async init() {
+    if (this.config.enable == false) {
       return;
     }
 
-    let port = Ps.getHttpPort();
+    const port = await getPort({port: parseInt(this.config.port)});
     if (!port) {
       throw new Error('[ee-core] [socket/HttpServer] http port required, and must be a number !');
     }
+    process.env.EE_HTTP_PORT = port;
+    this.config.port = port;
 
     this._create();
   }
@@ -36,72 +49,64 @@ class HttpServer {
    * 创建服务
    */
   _create () {
-    const app = this.app;
-    const httpServer = this.options;
-    const isHttps = httpServer?.https?.enable ?? false;
-    let sslOptions = {};
+    const config = this.config;
+    const isHttps = config?.https?.enable ?? false;
+    const sslOptions = {};
 
     if (isHttps === true) {
-      httpServer.protocol = 'https://';
-      const keyFile = path.join(app.config.homeDir, httpServer.https.key);
-      const certFile = path.join(app.config.homeDir, httpServer.https.cert);
+      config.protocol = 'https://';
+      const keyFile = path.join(getBaseDir(), config.https.key);
+      const certFile = path.join(getBaseDir(), config.https.cert);
       assert(fs.existsSync(keyFile), 'ssl key file is required');
       assert(fs.existsSync(certFile), 'ssl cert file is required');
 
       sslOptions.key = fs.readFileSync(keyFile);
       sslOptions.cert = fs.readFileSync(certFile);
     }
-    const url = httpServer.protocol + httpServer.host + ':' + httpServer.port;
-    const corsOptions = httpServer.cors;
+    const url = config.protocol + config.host + ':' + config.port;
+    const corsOptions = config.cors;
 
     const koaApp = new Koa();
     koaApp
       .use(cors(corsOptions))
-      .use(koaBody(httpServer.body))
-      .use(async (ctx, next) => {
-        ctx.eeApp = app;
-        await next();
-      })
+      .use(koaBody(config.body))
       .use(this._dispatch);
 
     let msg = '[ee-core] [socket/http] server is: ' + url;
-
     const listenOpt = {
-      host: httpServer.host,
-      port: httpServer.port
+      host: config.host,
+      port: config.port
     }
     if (isHttps) {
       https.createServer(sslOptions, koaApp.callback()).listen(listenOpt, (err) => {
         msg = err ? err : msg;
-        Log.coreLogger.info(msg);
+        coreLogger.info(msg);
       });
     } else {
       koaApp.listen(listenOpt, (e) => {
         msg = e ? e : msg;
-        Log.coreLogger.info(msg);
+        coreLogger.info(msg);
       });
-    }  
+    }
+    
+    this.httpApp = koaApp;
   }
 
   /**
    * 路由分发
    */
   async _dispatch (ctx, next) {
-    const config = ctx.eeApp.config.httpServer;
+    const controller = getController();
+    const { filterRequest } = getConfig().httpServer;
     let uriPath = ctx.request.path;
     const method = ctx.request.method;
     let params = ctx.request.query;
     params = is.object(params) ? JSON.parse(JSON.stringify(params)) : {};
     const body = ctx.request.body;
-    const files = ctx.request.files;
 
     // 默认
     ctx.response.status = 200;
 
-    // 添加到全局属性
-    ctx.eeApp.request = ctx.request;
-    ctx.eeApp.response = ctx.response;
-
     try {
       // 找函数
       // 去除开头的 '/'
@@ -109,23 +114,22 @@ class HttpServer {
         uriPath = uriPath.substring(1);
       }
       // 过滤
-      if (_.includes(config.filterRequest.uris, uriPath)) {
-        ctx.response.body = config.filterRequest.returnData;
+      if (_.includes(filterRequest.uris, uriPath)) {
+        ctx.response.body = filterRequest.returnData;
         await next();
         return
       }
       if (uriPath.slice(0, 10) != 'controller') {
         uriPath = 'controller/' + uriPath;
       }
-      const cmd = uriPath.split('/').join('.');
-      const args = (method == 'POST') ? (ctx.request.header['content-type'] && ctx.request.header['content-type'].startsWith('multipart/form-data;') ? files : body) : params;
-      args.files = ctx.request.files;
-      args.body = ctx.request.body;
-      args.query = ctx.request.query;
+      const cmd = uriPath.split('/').join(channelSeparator);
+      debug('[request] uri %s', cmd);
+      const args = (method == 'POST') ? body: params;
       let fn = null;
       if (is.string(cmd)) {
-        const actions = cmd.split('.');
-        let obj = ctx.eeApp;
+        const actions = cmd.split(channelSeparator);
+        debug('[findFn] channel %o', actions);
+        let obj = { controller };
         actions.forEach(key => {
           obj = obj[key];
           if (!obj) throw new Error(`class or function '${key}' not exists`);
@@ -134,14 +138,20 @@ class HttpServer {
       }
       if (!fn) throw new Error('function not exists');
 
-      const result = await fn.call(ctx.eeApp, args);
+      const result = await fn.call(controller, args, ctx);
       ctx.response.body = result;
     } catch (err) {
-      Log.coreLogger.error('[ee-core/httpServer] throw error:', err);
+      coreLogger.error('[ee-core/httpServer] throw error:', err);
     }
 
     await next();
   }
+
+  getHttpApp() {
+    return this.httpApp;
+  }
 }
 
-module.exports = HttpServer;
+module.exports = {
+  HttpServer
+};

package/socket/index.d.ts

@@ -0,0 +1,10 @@
+import IoServer = require("socket.io");
+import IoClient = require("socket.io-client");
+import { HttpServer } from './httpServer';
+import { IpcServer } from './ipcServer';
+import { SocketServer } from './socketServer';
+export declare function loadSocket(): void;
+export declare function getSocketServer(): SocketServer;
+export declare function getHttpServer(): HttpServer;
+export declare function getIpcServer(): IpcServer;
+export { IoServer, IoClient };

package/socket/index.js

@@ -3,80 +3,63 @@
 const IoServer = require('socket.io');
 const IoClient = require('socket.io-client');
 const Koa = require('koa');
-const EESocketServer = Symbol('Ee#SocketServer');
-const EEIpcServer = Symbol('Ee#IpcServer');
-const EEHttpServer = Symbol('Ee#HttpServer');
-
-const EeSocket = {
-
-  /**
-   * 提供基础库 - 避免用户重复安装
-   */
-  Koa,
-  IoServer,
-  IoClient,
-
-  /**
-   * 启动所有服务
-   */ 
-  startAll(app) {
-    this._createSocketServer(app);
-    this._createHttpServer(app);
-    this._createIpcServer(app);
-  },
-
-  /**
-   * 创建SocketServer
-   */ 
-  _createSocketServer(app) {
-    const SocketServer = require('./socketServer');
-    this[EESocketServer] = new SocketServer(app);
-
-    return this[EESocketServer];
-  },
-
-  /**
-   * 获取 Socket Server
-   */
-  getSocketServer() {
-    return this[EESocketServer] || null;
-  },  
-
-  /**
-   * 创建 Http Server
-   */ 
-  _createHttpServer(app) {
-    const HttpServer = require('./httpServer');
-    this[EEHttpServer] = new HttpServer(app);
-
-    return this[EEHttpServer];
-  },
+const { SocketServer } = require('./socketServer');
+const { HttpServer } = require('./httpServer');
+const { IpcServer } = require('./ipcServer');
+
+const Instance = {
+  socketServer: null,
+  httpServer: null,
+  coreLogger: null,
+};
+
+// create SocketServer
+function createSocketServer() {
+  Instance.socketServer = new SocketServer();
+  return Instance.socketServer;
+}
 
-  /**
-   * 获取 Http Server
-   */
-  getHttpServer() {
-    return this[EEHttpServer] || null;
-  }, 
+// socketServer
+function getSocketServer() {
+  return Instance.socketServer;
+}
 
-  /**
-   * 创建 IPC Server
-   */ 
-  _createIpcServer(app) {
-    const IpcServer = require('./ipcServer');
-    this[EEIpcServer] = new IpcServer(app);
+// create Http Server
+function createHttpServer() {
+  Instance.httpServer = new HttpServer();
+  return Instance.httpServer;
+}
 
-    return this[EEIpcServer];
-  },
+// httpServer
+function getHttpServer() {
+  return Instance.httpServer;
+} 
 
-  /**
-   * 获取 IPC Server
-   */
-  getIpcServer() {
-    return this[EEIpcServer] || null;
-  },   
+// create IPC Server
+function createIpcServer() {
+  Instance.ipcServer = new IpcServer();
+  return Instance.ipcServer;
+}
 
+// ipcServer
+function getIpcServer() {
+  return Instance.ipcServer;
 }
 
 
-module.exports = EeSocket;
+// load socket server
+function loadSocket() {
+  createSocketServer();
+  createHttpServer();
+  createIpcServer();
+} 
+
+module.exports = {
+  Koa,
+  IoServer,
+  IoClient,
+  loadSocket,
+  getSocketServer,
+  getHttpServer,
+  getIpcServer
+};

package/socket/ipcServer.d.ts

@@ -0,0 +1,9 @@
+export declare class IpcServer {
+    directory: string;
+    loop(obj: any, pathname: string): void;
+    register(exportObj: any, propertyChain: any): void;
+    findFn(controller: any, c: any): {
+        controller: any;
+    };
+    init(): void;
+}

package/socket/ipcServer.js

@@ -1,113 +1,106 @@
-const debug = require('debug')('ee-core:ipcServer');
+'use strict';
+
+const debug = require('debug')('ee-core:socket:ipcServer');
 const is = require('is-type-of');
 const { ipcMain } = require('electron');
-const path = require('path');
-const fs = require('fs');
-const globby = require('globby');
-const Utils = require('../core/lib/utils');
-const Wrap = require('../utils/wrap');
-const Log = require('../log');
+const { coreLogger } = require('../log');
+const { getController } = require('../controller');
+const { EXPORTS } = require('../core/loader/file_loader');
+const { getConfig } = require('../config');
 
 class IpcServer {
-  constructor (app) {
-    this.app = app;
-    this.register();
+  constructor () {
+    const { mainServer } = getConfig();
+    this.channelSeparator = mainServer.channelSeparator;
+    this.directory = 'controller';
+    this.init();
+  }
+  init() {
+    const controller = getController();
+    this.loop(controller, this.directory);
   }
 
-  register () {
-    const self = this;
-    // 遍历方法
-    const files = Utils.filePatterns();
-    const directory = path.join(this.app.config.baseDir, 'controller');
-    const filepaths = globby.sync(files, { cwd: directory });
-
-    for (const filepath of filepaths) {
-      const fullpath = path.join(directory, filepath);
-      if (!fs.statSync(fullpath).isFile()) continue;
-
-      const properties = Wrap.getProperties(filepath, {caseStyle: 'lower'});
-      const pathName = directory.split(/[/\\]/).slice(-1) + '.' + properties.join('.');
-
-      let fileObj = Utils.loadFile(fullpath);
-      const fns = {};
-      // 为了统一，仅支持class文件
-      if (is.class(fileObj) || Utils.isBytecodeClass(fileObj)) {
-        let proto = fileObj.prototype;
-        // 不遍历父类的方法
-        //while (proto !== Object.prototype) {
-          const keys = Object.getOwnPropertyNames(proto);
-          for (const key of keys) {
-            if (key === 'constructor') {
-              continue;
-            }
-            const d = Object.getOwnPropertyDescriptor(proto, key);
-            if (is.function(d.value) && !fns.hasOwnProperty(key)) {
-              fns[key] = 1;
-            }
-          }
-          //proto = Object.getPrototypeOf(proto);
-        //}
+  loop(obj, pathname) {
+    const keys = Object.keys(obj);
+    // debug("[loop] keys: %j", keys);
+    for (const key of keys) {
+      if (key === 'constructor') {
+        continue;
+      }
+      let subObj = obj[key];
+      let propertyChain = pathname + '.' + key;
+      if (subObj && subObj[EXPORTS] === true) {
+        this.register(subObj, propertyChain);
+      } else if (typeof subObj === 'object') {
+        // 如果子对象依然是对象，则递归调用继续判断
+        this.loop(subObj, propertyChain);
       }
+    }
+  }
 
-      debug('register class %s fns %j', pathName, fns);
+  register(exportObj, propertyChain) {
+    const controller = getController();
+    const keys = Object.keys(exportObj);
+    for (const key of keys) {
+      // Supports two types of routing separators
+      // channel: controller.file.function | controller/file/function
+      const tmpChannel = `${propertyChain}.${key}`;
+      const channel = tmpChannel.split('.').join(this.channelSeparator);
+      debug('[register] channel %s', channel);
 
-      for (const key in fns) {
-        let channel = pathName + '.' + key;
-        debug('register channel %s', channel);
+      // send/on model
+      ipcMain.on(channel, async (event, params) => {
+        try {
+          const fn = this.findFn(controller, channel);
+          const result = await fn.call(controller, params, event);
 
-        function findFn (app, c) {
-          try {
-            // 找函数
-            const cmd = c;
-            let fn = null;
-            if (is.string(cmd)) {
-              const actions = cmd.split('.');
-              let obj = app;
-              actions.forEach(key => {
-                obj = obj[key];
-                if (!obj) throw new Error(`class or function '${key}' not exists`);
-              });
-              fn = obj;
-            }
-            if (!fn) throw new Error('function not exists');
-            
-            return fn;
-          } catch (err) {
-            Log.coreLogger.error('[ee-core] [socket/IpcServer] throw error:', err);
-          }
-          return null;
+          event.returnValue = result;
+          event.reply(`${channel}`, result);
+        } catch(e) {
+          coreLogger.error('[ee-core] [socket/IpcServer] send/on throw error:', e);
         }
+      });
 
-        // send/on 模型
-        ipcMain.on(channel, async (event, params) => {
-          try {
-            const fn = findFn(self.app, channel);
-            const result = await fn.call(self.app, params, event);
-  
-            event.returnValue = result;
-            event.reply(`${channel}`, result);
-          } catch(e) {
-            Log.coreLogger.error('[ee-core] [socket/IpcServer] send/on throw error:', e);
-            // event.returnValue = e;
-            // event.reply(`${channel}`, e);
-          }
-        });
+      // invoke/handle model
+      ipcMain.handle(channel, async (event, params) => {
+        try {
+          const fn = this.findFn(controller, channel);
+          const result = await fn.call(controller, params, event);
 
-        // invoke/handle 模型
-        ipcMain.handle(channel, async (event, params) => {
-          try {
-            const fn = findFn(self.app, channel);
-            const result = await fn.call(self.app, params, event);
-  
-            return result;
-          } catch(e) {
-            Log.coreLogger.error('[ee-core] [socket/IpcServer] invoke/handle throw error:', e);
-            return e
-          }
+          return result;
+        } catch(e) {
+          coreLogger.error('[ee-core] [socket/IpcServer] invoke/handle throw error:', e);
+        }
+      });
+    }
+  }
+
+  findFn (controller, c) {
+    try {
+      // 找函数
+      const cmd = c;
+      let fn = null;
+      if (is.string(cmd)) {
+        const actions = cmd.split(this.channelSeparator);
+        debug('[findFn] channel %o', actions);
+        let obj = { controller };
+        actions.forEach(key => {
+          obj = obj[key];
+          if (!obj) throw new Error(`class or function '${key}' not exists`);
         });
+        fn = obj;
       }
+      if (!fn) throw new Error('function not exists');
+      
+      return fn;
+    } catch (err) {
+      coreLogger.error('[ee-core] [socket/IpcServer] throw error:', err);
     }
+    return null;
   }
+
 }
 
-module.exports = IpcServer;
+module.exports = {
+  IpcServer
+};

package/socket/socketServer.d.ts

@@ -0,0 +1,10 @@
+import { Server } from "socket.io";
+import { DefaultEventsMap } from "socket.io/dist/typed-events";
+export declare class SocketServer {
+    socket: import("socket.io").Socket<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    io: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
+    config: any;
+    init(): Promise<void>;
+    connect(): void;
+}
+

package/socket/socketServer.js

@@ -1,52 +1,62 @@
 'use strict';
 
-const { Server } = require('socket.io');
+const debug = require('debug')('ee-core:socket:socketServer');
 const is = require('is-type-of');
-const Log = require('../log');
-const Conf = require('../config/cache');
-const Ps = require('../ps');
-const Channel = require('../const/channel');
+const { Server } = require('socket.io');
+const { coreLogger } = require('../log');
+const { getConfig } = require('../config');
+const { SocketIO } = require('../const/channel');
+const { getController } = require('../controller');
+const { getPort } = require('../utils/port');
 
 /**
  * socket server
  */
 class SocketServer {
-  constructor (app) {
-    this.app = app;
+  constructor () {
+    const { socketServer, mainServer } = getConfig();
+    this.config = socketServer;
+    this.channelSeparator = mainServer.channelSeparator;
     this.socket = undefined;
-    const options = Conf.getValue('socketServer');
+    this.io = undefined;
+    this.init();
+  }
 
-    if (options.enable == false) {
+  async init() {
+    if (this.config.enable == false) {
       return;
     }
 
-    let port = Ps.getSocketPort();
+    const port = await getPort({port: parseInt(this.config.port)});
     if (!port) {
       throw new Error('[ee-core] [socket/socketServer] socekt port required, and must be a number !');
     }
+    coreLogger.info('[ee-core] [socket/socketServer] port is:', port);
 
-    Log.coreLogger.info('[ee-core] [socket/socketServer] port is:', port);
-
-    this.io = new Server(port, options);
-    this.connec(options);
+    process.env.EE_SOCKET_PORT = port;
+    this.config.port = port;
+    this.io = new Server(port, this.config);
+    this.connect();
   }
 
-  connec (opt = {}) {
-    const app = this.app;
+  connect () {
+    const controller = getController();
     this.io.on('connection', (socket) => {
-      const channel = opt.channel || Channel.socketIo.partySoftware;
+      const channel = this.config.channel || SocketIO.partySoftware;
       this.socket = socket;
       socket.on(channel, async (message, callback) => {
-        Log.coreLogger.info('[ee-core] [socket/socketServer] socket id:' + socket.id + ' message cmd: ' + message.cmd);
+        coreLogger.info('[ee-core] [socket/socketServer] socket id:' + socket.id + ' message cmd: ' + message.cmd);
 
         try {
-          // 找函数
+          // find function
           const cmd = message.cmd;
-          const args = message.args || message.params;
+          const args = message.args;
           let fn = null;
+          debug('[socket] channel %s', cmd);
           if (is.string(cmd)) {
-            const actions = cmd.split('.');
-            let obj = app;
+            const actions = cmd.split(this.channelSeparator);
+            debug('[findFn] channel %o', actions);
+            let obj = { controller };
             actions.forEach(key => {
               obj = obj[key];
               if (!obj) throw new Error(`class or function '${key}' not exists`);
@@ -55,16 +65,18 @@ class SocketServer {
           }
           if (!fn) throw new Error('function not exists');
 
-          const result = await fn.call(app, args);
+          const result = await fn.call(controller, args);
           if (callback) {
             callback(result);
           }
         } catch (err) {
-          Log.coreLogger.error('[ee-core] [socket/socketServer] throw error:', err);
+          coreLogger.error('[ee-core] [socket/socketServer] throw error:', err);
         }
       });
     });
   }
 }
 
-module.exports = SocketServer;
+module.exports = {
+  SocketServer,
+};