ee-core 1.5.2-beta.2 → 2.0.0-beta.1

package/module/jobs/index.js

@@ -0,0 +1,55 @@
+const path = require('path');
+const fs = require('fs');
+const assert = require('assert');
+const RendererJob = require('./renderer');
+const ChildJob = require('./child');
+const Utils = require('../utils');
+const Loader = require('../loader');
+
+class Jobs  {
+  constructor() {
+    this.type = undefined;
+    this.instance = undefined;
+  }
+
+  /**
+   * 创建 job
+   */
+  create (name, opt = {}) {
+    this.type = opt.type || 'child';
+    this.dev = opt.dev || false;
+    this.winOptions = opt.winOptions || {};
+    this.childOptions = opt.childOptions || {};
+    this.path = opt.path || null;
+
+
+    const isAbsolute = path.isAbsolute(this.path);
+    if (!isAbsolute) {
+      this.path = path.join(Utils.getBaseDir(), 'jobs', this.path);
+    }
+    const filepath = Loader.resolveModule(this.path);
+
+    assert(fs.existsSync(filepath), `file ${filepath} not exists`);
+
+    this.path = filepath;
+    if (this.type == 'child') {
+      this.instance = new ChildJob(name, filepath, this.childOptions);
+    } else if (this.type == 'renderer') {
+      this.instance = new RendererJob(name, filepath, this.winOptions);
+      if (this.dev) {
+        this.openDevTools();
+      }
+    }
+    
+    return;
+  }
+
+  /**
+   * 显示开发者工具栏（仅支持 RendererJob)
+   */
+  openDevTools () {
+    this.instance.openDevTools();
+  }
+}
+
+module.exports = Jobs;

package/module/jobs/renderer/index.js

@@ -0,0 +1,140 @@
+//require('bytenode');
+const { BrowserWindow } = require('electron');
+const fs = require('fs');
+const LoadView = require('./loadView');
+
+class RendererJob {
+
+  /**
+    * constructor
+    * @param  {String} name - job name
+    * @param  {String} filepath - filepath to file
+    * @param  {Object} options - options to create BrowserWindow
+    */
+  constructor(name, filepath, opt = {}) {
+    let options = Object.assign({
+      show: false,
+      webPreferences: {
+        webSecurity: true,
+        nodeIntegration: true,
+        contextIsolation: false,
+        //enableRemoteModule: true
+      }
+    }, opt);
+
+    this.subWin = new BrowserWindow(options);
+
+    this.jobReady = false;
+    this.exec = filepath;
+    this.name = name;
+    this.listeners = [];
+    this.callbacks = [];
+    this.fails = [];
+    this.id = this.subWin.id;
+    this.webSecurity = options.webPreferences.webSecurity;
+
+    // this.callbacks.push(() => {
+    //   MessageChannel.registry(name, this.id, this.subWin.webContents.getOSProcessId());
+    // });
+
+    // job state listener
+    this.subWin.webContents.on('did-finish-load', this._didFinishLoad);
+    this.subWin.webContents.on('did-fail-load', this._didFailLoad);
+
+    // load job
+    this._loadJob(this.exec);
+  }
+
+  /**
+   * 显示开发者工具栏
+   */
+  openDevTools() {
+    this.subWin.webContents.openDevTools({
+      mode: 'undocked'
+    });
+  }
+
+  /**
+   * 窗口加载完成，即业务代码执行完毕
+   */
+  _didFinishLoad = () => {
+    this.jobReady = true;
+    this.callbacks.forEach(callback => {
+      callback(this.id);
+    });
+  }
+
+  /**
+   * 窗口加载失败，即业务运行失败
+   */
+  _didFailLoad = (error) => {
+    this.jobReady = false;
+    this.fails.forEach(handle => {
+      handle(error.toString());
+    });
+  }
+
+
+  /**
+   * 加载任务
+   */
+  _loadJob(filepath) {
+    if (!this.webSecurity) {
+      this._loadURLUnsafe(filepath);
+    } else {
+      this._loadURLSafe(filepath);
+    }
+  }
+
+  /**
+   * 安全的脚本注入
+   */
+  _loadURLSafe(filepath) {
+    return new Promise((resolve, reject) => {
+      fs.readFile(filepath, { encoding: 'utf-8' }, (err, buffer) => {
+        if (err) {
+          reject(err);
+          this._didFailLoad(err);
+          return console.error(err);
+        }
+
+        let param = {
+          webSecurity: true,
+          script: buffer.toString(),
+          title: `${this.name} job`,
+          base: filepath
+        }
+        const viewData = LoadView(param);
+
+        this.subWin.loadURL(viewData)
+        .then(resolve)
+        .catch(err => {
+          reject(err);
+          this._didFailLoad(err);
+          console.error(err);
+        });
+      })
+    })
+  }
+
+  /**
+   * 不安全的脚本注入
+   */
+  _loadURLUnsafe(filepath) {
+    let param = {
+      webSecurity: false,
+      src: this.exec,
+      title: `${this.name} job`,
+      base: filepath
+    }
+    const viewData = LoadView(param);
+
+    this.subWin.loadURL(viewData)
+    .catch(err => {
+      this._didFailLoad(err);
+      console.error(err);
+    });
+  }
+}
+
+module.exports = RendererJob;

package/module/jobs/renderer/loadView.js

@@ -0,0 +1,40 @@
+const Ps = require('../../utils/ps');
+
+/**
+  * loadView 生成BrowserWindow的html content
+  */
+const loadView = function (opt = {}) {
+  const webSecurity = opt.webSecurity;
+  const src = opt.src;
+  const title = opt.title;
+  const script = opt.script;
+
+  //const scriptUrl = new URL('eefile://' + src);
+  const scriptUrl = 'eefile://' + src;
+  console.log('[ee-core:job] scriptUrl: ', scriptUrl);
+
+  // 脚本内容
+  //const scriptBytenode = Ps.isDev() ? '' : `<script> require('bytenode') </script>`;
+  const scriptContent = webSecurity ? `<script> ${ script } </script>` : `<script src='${scriptUrl}'></script>`;
+
+  // html内容
+  const htmlContent = (`
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>${title}</title>
+        <meta charset="UTF-8">
+      </head>
+      <body>
+        ${scriptContent}
+      </body>
+    </html>
+  `);
+
+  const DataURI = 'data:text/html;charset=UTF-8,';
+  const data = DataURI + encodeURIComponent(htmlContent);
+
+  return data;
+};
+
+module.exports = loadView;

package/module/loader/index.js

@@ -0,0 +1,78 @@
+const is = require('is-type-of');
+const fs = require('fs');
+const path = require('path');
+const UtilsCore = require('../../core/lib/utils');
+const Ps = require('../utils/ps');
+
+module.exports = {
+
+  /**
+   * 加载单个文件(如果是函数，将被执行)
+   *
+   * @param {String} filepath - fullpath
+   * @param {Array} inject - pass rest arguments into the function when invoke
+   * @return {Object} exports
+   * @since 1.0.0
+   */
+  loadFile (filepath, ...inject) {
+    filepath = filepath && this.resolveModule(filepath);
+    if (!filepath) {
+      return null;
+    }
+
+    const ret = UtilsCore.loadFile(filepath);
+    if (is.function(ret) && !is.class(ret) && !UtilsCore.isBytecodeClass(ret)) {
+      ret = ret(...inject);
+    }
+    return ret;
+  },
+
+  /**
+   * 模块的绝对路径
+   */
+  resolveModule(filepath) {
+    const isAbsolute = path.isAbsolute(filepath);
+    if (!isAbsolute) {
+      filepath = path.join(Ps.getBaseDir(), 'jobs', filepath);
+    }
+
+    let fullPath;
+    try {
+      fullPath = require.resolve(filepath);
+    } catch (e) {
+      let jscFile = filepath + '.jsc';
+      if (fs.existsSync(jscFile)) {
+        return jscFile;
+      }
+      return undefined;
+    }
+
+    return fullPath;
+  },
+
+  /**
+   * 加载模块(子进程中使用)
+   *
+   * @param {String} filepath - fullpath
+   * @return {Object} exports
+   * @since 1.0.0
+   */
+  requireModule (filepath) {
+    filepath = filepath && this.resolveModule(filepath);
+    if (!filepath) {
+      return null;
+    }
+    const ret = UtilsCore.loadFile(filepath);
+
+    return ret;
+  },  
+
+}
+
+
+
+
+
+
+
+

package/module/log/index.js

@@ -0,0 +1,53 @@
+const Logger = require('./logger');
+const EELoggers = Symbol('EeApplication#EELoggers');
+
+const Log = {
+  /**
+   * 创建日志实例
+   */
+  create (config) {
+    const eeLog = Logger.create(config);
+
+    return eeLog;
+  },
+
+  /**
+   * logger
+   */
+  get logger() {
+    if (!this[EELoggers]) {
+      this[EELoggers] = Logger.create();
+    }
+
+    return this[EELoggers]['logger'] || null;
+  },
+
+  /**
+   * coreLogger
+   */
+  get coreLogger () {
+    if (!this[EELoggers]) {
+      this[EELoggers] = Logger.create();
+    }
+
+    return this[EELoggers]['coreLogger'] || null;
+  },
+
+  get error() {
+    return this.logger.error.bind(this.logger);
+  },
+
+  get warn() {
+    return this.logger.warn.bind(this.logger);
+  },
+
+  get info() {
+    return this.logger.info.bind(this.logger);
+  },
+
+  get debug() {
+    return this.logger.debug.bind(this.logger);
+  },
+};
+
+module.exports = Log;

package/module/log/logger.js

@@ -0,0 +1,61 @@
+const Loggers = require('egg-logger').EggLoggers;
+const assert = require('assert');
+const Ps = require('../utils/ps');
+const Storage = require('../storage');
+
+module.exports = {
+
+  /**
+   * 创建
+   */
+  create(config = {}) {
+    let opt = {};
+    
+    if (Object.keys(config).length == 0) {
+      const defaultConfig = {
+        logger: {
+          type: 'application',
+          dir: Ps.getLogDir(),
+          encoding: 'utf8',
+          env: Ps.env(),
+          level: 'INFO',
+          consoleLevel: 'INFO',
+          disableConsoleAfterReady: !Ps.isDev(),
+          outputJSON: false,
+          buffer: true,
+          appLogName: `ee.log`,
+          coreLogName: 'ee-core.log',
+          agentLogName: 'ee-agent.log',
+          errorLogName: `ee-error.log`,
+          coreLogger: {},
+          allowDebugAtProd: false,
+          enablePerformanceTimer: false,
+        },
+        customLogger: {}
+      }
+      const sysConfig = this._getCoreDB().getItem('config');
+      opt = Object.assign(defaultConfig, {
+        logger: sysConfig.logger,
+        customLogger: sysConfig.customLogger || {}
+      });
+    } else {
+      opt.logger = config.logger;
+      opt.customLogger = config.customLogger;
+    }
+    //console.log('log---------', config);
+
+    assert(Object.keys(opt).length != 0, `logger config is null`);
+
+    const loggers = new Loggers(opt);
+
+    return loggers;
+  },
+
+  /**
+   * 获取 coredb
+   */
+  _getCoreDB() {
+    const coreDB = Storage.connection('system');
+    return coreDB;
+  }
+};

package/module/message/index.js

@@ -0,0 +1,13 @@
+const { isDev, isRenderer, isMain } = require('../utils/ps');
+
+const m = {};
+
+if (isMain) {
+  m.d = require();
+}
+
+if (isRenderer) {
+  m.d = require();
+}
+
+module.exports = m;

package/module/message/ipcMain.js

@@ -0,0 +1,160 @@
+
+class IpcMain  {
+  constructor() {
+    this.event = new EventEmitter();
+    this.services = {};
+    /* 根据name获取window id */
+    ipcMain.handle('MessageChannel.getIdFromName', (e, args) => {
+      return (this.services[args.name] || {}).id;
+    });
+    /* 使用name和window id注册一个服务 */
+    ipcMain.handle('MessageChannel.registryService', (e, args) => {
+      const { name, id } = args;
+      this.registry(name, id);
+      return this.services[name];
+    });
+
+  }
+
+  /**
+    * invoke [在主进程(main)中向另外一个服务进程(service)发送异步请求，并取得回调Promise]
+    * @param  {[String]} name [服务名]
+    * @param  {[String]} channel [服务监听的信号名]
+    * @param  {[Any]} args [携带参数(会被序列化，不会传递对象Proptype信息)]
+    * @return {[Promise]} [回调]
+    */
+  invoke (name, channel, args={}) {
+    const pid = getRandomString();
+    const { id } = this.services[name];
+
+    return new Promise((resolve, reject) => {
+      if (name === 'main') reject(new Error(`MessageChannel: the main process can not send a message to itself!`))
+      if (!id) reject(new Error(`MessageChannel: can not get the id of the window names ${name}`));
+      const win = BrowserWindow.fromId(id);
+      if (!win) reject(new Error(`MessageChannel: can not find a window with id: ${id}`));
+      win.webContents.send(channel, Object.assign(args, { pid, isFromMain: true }));
+      ipcMain.once(pid, function(event, rsp) {
+        resolve(rsp);
+      });
+
+    });
+  }
+
+  /**
+    * handle [在主进程中(main)监听来自其它渲染进程(service/window)的请求，将promiseFunc执行的结果返回]
+    * @param  {[String]} channel [服务监听的信号名]
+    * @param  {[Function]} promiseFunc [此函数执行的结果会被发送到消息发送者]
+    * @return {[Promise]} [回调]
+    */
+  handle(channel, promiseFunc) {
+    if (!promiseFunc instanceof Function) throw new Error('MessageChannel: promiseFunc must be a function!');
+    ipcMain.handle(channel, (event, ...args) => {
+      return promiseFunc(event, ...args).then((result) => {
+  
+        return result;
+      });
+    });
+  }
+
+  /**
+    * handle [在主进程中(main)监听一次来自其它渲染进程(service/window)的请求，将promiseFunc执行的结果返回]
+    * @param  {[String]} channel [服务监听的信号名]
+    * @param  {[Function]} promiseFunc [此函数执行的结果会被发送到消息发送者]
+    * @return {[Promise]} [回调]
+    */
+  handleOnce(channel, promiseFunc) {
+    if (!promiseFunc instanceof Function) throw new Error('MessageChannel: promiseFunc must be a function!');
+    ipcMain.handleOnce(channel, (event, ...args) => {
+      return promiseFunc(event, ...args).then(result => {
+
+        return result;
+      });
+    });
+  }
+
+  /**
+    * send [在主进程(main)向另外一个服务进程(service)发送异步请求，不可立即取得值，请配合on监听信号使用]
+    * @param  {[String]} name [服务名]
+    * @param  {[String]} channel [服务监听的信号名]
+    * @param  {[Any]} args [携带参数(会被序列化，不会传递对象Proptype信息)]
+    */
+  send(name, channel, args={}) {
+    const id = (this.services[name] || {}).id;
+
+
+    if (!id) throw new Error(`MessageChannel: can not get the id of the window names ${name}`);
+    const win = BrowserWindow.fromId(id);
+    if (!win) throw new Error(`MessageChannel: can not find a window with id: ${id}`);
+
+    win.webContents.send(channel, args);
+  }
+
+  /**
+    * send [在主进程中(main)向指定某个id的渲染进程窗口(service/window)发送请求，不可立即取得值，请配合on监听信号使用]
+    * @param  {[String]} id [window id]
+    * @param  {[String]} channel [服务监听的信号名]
+    * @param  {[Any]} args [携带参数(会被序列化，不会传递对象Proptype信息)]
+    */
+  sendTo(id, channel, args) {
+
+    if (!BrowserWindow.fromId(id)) throw new Error(`MessageChannel: can not find a window with id:${id}!`);
+    BrowserWindow.fromId(id).webContents.send(channel, args);
+  }
+
+  /**
+    * on [在主进程中(main)监听来自其它渲染进程(service/window)的请求]
+    * @param  {[String]} channel [服务监听的信号名]
+    * @param  {[Function]} func [消息到达后，此函数会被触发，同于原生ipcRenderer.on]
+    */
+  on(channel, func) {
+    if (!func instanceof Function) throw new Error('MessageChannel: func must be a function!');
+    ipcMain.on(channel, (event, ...args) => {
+
+      func(event, ...args);
+    });
+  }
+
+  /**
+    * once [在主进程中(main)监听一次来自其它渲染进程(service/window)的请求]
+    * @param  {[String]} channel [服务监听的信号名]
+    * @param  {[Function]} func [消息到达后，此函数会被触发，同于原生ipcRenderer.on]
+    */
+   once(channel, func) {
+    if (!func instanceof Function) throw new Error('MessageChannel: func must be a function!');
+    ipcMain.once(channel, (event, ...args) => {
+
+      func(event, ...args);
+    });
+  }
+  
+  /**
+     * registry [注册BrowserWindow和BrowserService]
+     * @param  {[String]} name [唯一的名字]
+     * @param  {[String]} id [window id]
+     * @param  {[String]} pid [process id]
+     */
+  registry(name, id, pid) {
+    if (name === 'main') throw new Error(`MessageChannel: you can not registry a service named:${name}, it's reserved for the main process!`)
+    if (this.services[name]) console.warn(`MessageChannel: the service - ${name} has been registeried!`)
+    this.services[name] = { name, id, pid };
+    this.event.emit('registry', this.services[name]);
+  }
+
+  /**
+     * unregistry [注册BrowserWindow和BrowserService]
+     * @param  {[String]} name [唯一的名字]
+     * @param  {[String]} id [window id]
+     * @param  {[String]} pid [process id]
+     */
+    unregistry(name) {
+      if (name === 'main') throw new Error(`MessageChannel: you can not unregistry a service named:${name}, it's reserved for the main process!`);
+      if (this.services[name]) console.warn(`MessageChannel: the service - ${name} will be unregisteried!`);
+      if (this.services[name]) {
+        this.event.emit('unregistry', this.services[name]);
+        delete this.services[name];
+      } else {
+        console.warn(`MessageChannel: unregistry -> the service - ${name} is not found!`);
+      }
+    }
+}
+

package/{lib → module}/socket/ipcServer.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const debug = require('debug')('ee-core:ipcServer');
 const EggConsoleLogger = require('egg-logger').EggConsoleLogger;
 const is = require('is-type-of');
@@ -7,8 +5,8 @@ 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 Utils = require('../../core/lib/utils');
+const Wrap = require('../utils/wrap');
 
 class IpcServer {
   constructor (app) {
@@ -24,7 +22,7 @@ class IpcServer {
 
     const self = this;
     // 遍历方法
-    const files = utils.filePatterns();
+    const files = Utils.filePatterns();
     const directory = path.join(this.app.config.baseDir, 'controller');
     const filepaths = globby.sync(files, { cwd: directory });
 
@@ -32,13 +30,13 @@ class IpcServer {
       const fullpath = path.join(directory, filepath);
       if (!fs.statSync(fullpath).isFile()) continue;
 
-      const properties = wrap.getProperties(filepath, {caseStyle: 'lower'});
+      const properties = Wrap.getProperties(filepath, {caseStyle: 'lower'});
       const pathName = directory.split(/[/\\]/).slice(-1) + '.' + properties.join('.');
 
-      let fileObj = utils.loadFile(fullpath);
+      let fileObj = Utils.loadFile(fullpath);
       const fns = {};
       // 为了统一，仅支持class文件
-      if (is.class(fileObj) || utils.isBytecodeClass(fileObj)) {
+      if (is.class(fileObj) || Utils.isBytecodeClass(fileObj)) {
         let proto = fileObj.prototype;
         // 不遍历父类的方法
         //while (proto !== Object.prototype) {

package/{lib → module}/socket/socketClient.js

@@ -2,8 +2,9 @@
 
 const assert = require('assert');
 const IoClient = require('socket.io-client');
-const constant = require('../constant');
+const Constants = require('../const');
 const EggConsoleLogger = require('egg-logger').EggConsoleLogger;
+const Storage = require('../storage');
 
 class SocketClient {
   constructor (port) {
@@ -29,7 +30,7 @@ class SocketClient {
   call (method = '', ...params) {
     return new Promise((resolve, reject) => {
       // 获取通信频道
-      const channel = constant.socketIo.channel.partySoftware;
+      const channel = Constants.socketIo.channel.partySoftware;
       this.client.emit(channel, { cmd: method, params: params }, (response) => {
         resolve(response);
       });
@@ -37,7 +38,7 @@ class SocketClient {
   }
 
   getCoreDB () {
-    const coreDB = require('../storage/index').JsonDB.connection('system');
+    const coreDB = Storage.connection('system');
     return coreDB;
   }