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

package/{lib/httpclient.js → module/httpclient/index.js}

@@ -1,10 +1,10 @@
-'use strict';
-
 const Agent = require('agentkeepalive');
 const HttpsAgent = require('agentkeepalive').HttpsAgent;
 const urllib = require('urllib');
 const ms = require('humanize-ms');
 const { FrameworkBaseError } = require('egg-errors');
+const Storage = require('../storage');
+const Log = require('../log');
 
 class HttpClientError extends FrameworkBaseError {
   get module() {
@@ -13,18 +13,52 @@ class HttpClientError extends FrameworkBaseError {
 }
 
 class HttpClient extends urllib.HttpClient2 {
-  constructor(app) {
-    normalizeConfig(app);
-    const config = app.config.httpclient;
+  constructor(options = {}) {
+
+    if (Object.keys(options).length == 0) {
+      const sysConfig = this._getCoreDB().getItem('config');
+      options = sysConfig.httpclient;
+    }
+
+    const config = Object.assign({
+      enableDNSCache: false,
+      dnsCacheLookupInterval: 10000,
+      dnsCacheMaxLength: 1000,
+      request: {
+        timeout: 5000,
+      },
+      httpAgent: {
+        keepAlive: true,
+        freeSocketTimeout: 4000,
+        maxSockets: Number.MAX_SAFE_INTEGER,
+        maxFreeSockets: 256,
+      },
+      httpsAgent: {
+        keepAlive: true,
+        freeSocketTimeout: 4000,
+        maxSockets: Number.MAX_SAFE_INTEGER,
+        maxFreeSockets: 256,
+      },
+    }, options);
+
+    normalizeConfig(config);
+
     super({
-      app,
       defaultArgs: config.request,
       agent: new Agent(config.httpAgent),
       httpsAgent: new HttpsAgent(config.httpsAgent),
     });
-    this.app = app;
+    this.config = config;
   }
 
+  /**
+   * 获取 coredb
+   */
+  _getCoreDB() {
+    const coreDB = Storage.connection('system');
+    return coreDB;
+  }  
+
   request(url, args, callback) {
     if (typeof args === 'function') {
       callback = args;
@@ -74,8 +108,8 @@ class HttpClient extends urllib.HttpClient2 {
   }
 }
 
-function normalizeConfig(app) {
-  const config = app.config.httpclient;
+function normalizeConfig(httpConfig) {
+  const config = httpConfig;
 
   // compatibility
   if (typeof config.keepAlive === 'boolean') {
@@ -118,12 +152,12 @@ function normalizeConfig(app) {
   }
 
   if (config.httpAgent.timeout < 30000) {
-    app.coreLogger.warn('[ee:httpclient] config.httpclient.httpAgent.timeout(%s) can\'t below 30000, auto reset to 30000',
+    Log.coreLogger.warn('[ee:httpclient] config.httpclient.httpAgent.timeout(%s) can\'t below 30000, auto reset to 30000',
       config.httpAgent.timeout);
     config.httpAgent.timeout = 30000;
   }
   if (config.httpsAgent.timeout < 30000) {
-    app.coreLogger.warn('[ee:httpclient] config.httpclient.httpsAgent.timeout(%s) can\'t below 30000, auto reset to 30000',
+    Log.coreLogger.warn('[ee:httpclient] config.httpclient.httpsAgent.timeout(%s) can\'t below 30000, auto reset to 30000',
       config.httpsAgent.timeout);
     config.httpsAgent.timeout = 30000;
   }

package/module/jobs/child/app.js

@@ -0,0 +1,23 @@
+const Exception = require('ee-core/module/exception');
+Exception.start();
+
+const Loader = require('ee-core/module/loader');
+const Log = require('ee-core/module/log');
+
+class ChildApp {
+  constructor() {
+    const args = process.argv[2];
+    this.opt = args ? JSON.parse(args) : {};
+  }
+
+  run () {
+    Log.info('[child-process] run');
+    
+    const jobFile = this.opt.jobPath;
+
+    Loader.loadJobFile(jobFile);
+  }
+}
+
+const app = new ChildApp()
+app.run();

package/module/jobs/child/forkProcess.js

@@ -0,0 +1,104 @@
+const path = require('path');
+const { fork } = require('child_process');
+
+class ForkProcess {
+  constructor(host, modulePath, processArgs = [], processOptions = {}) {
+    this.host = host;
+    this.modulePath = modulePath;
+    this.args;
+    this.options = processOptions;
+    this.sleeping = false;
+    this.activitiesCount = 0;
+    this.activitiesMap = new Map();
+
+    // 传递给子进程的参数
+    let scriptArgs = {
+      jobPath: modulePath
+    }
+    processArgs.push(JSON.stringify(scriptArgs));
+    this.args = processArgs;
+    
+    const appPath = path.join(__dirname, 'app.js');
+    this.child = fork(appPath, this.args, this.options);
+
+    this.pid = this.child.pid;
+    this._init();
+  }
+
+  /**
+   * 进程挂起
+   */
+  sleep() {
+    if (this.activitiesCount) {
+      if (this.sleeping) return;
+      process.kill(this.pid, 'SIGSTOP');
+      this.sleeping = true;
+    }
+  }
+
+  /**
+   * 进程唤醒
+   */
+  wakeup() {
+    if (!this.sleeping) return;
+    process.kill(this.pid, 'SIGCONT');
+    this.sleeping = false;
+  }
+
+  /**
+   * 进程初始化
+   */
+  _init() {
+    this.child.on('message', (data) => {
+      const id = data.id;
+      this.connectionsCountMinus(id);
+      delete data.id;
+      delete data.action;
+      //this.host.emit('forked_message', {data, id});
+    });
+    this.child.on('exit', (code, signal) => {
+      // if (code !== 0 && code !== null) {
+      //   this.host.emit('forked_error', code, this.pid);
+      // } else {
+      //   this.host.emit('forked_exit', this.pid);
+      // }
+    });
+    this.child.on('error', (err) => {
+      console.log('forked error: ', err);
+      // this.host.emit('forked_error', err, this.pid);
+    });
+  }
+
+  /**
+   * 向进程发消息
+   */
+  send(params) {
+    if (this.sleeping) {
+      this.wakeup();
+    }
+    this.connectionsCountPlus(params.id);
+    this.child.send(params);
+  }
+
+  /**
+   * 连接数+
+   */
+  _connectionsCountPlus(id) {
+    this.activitiesMap.set(id, 1);
+    this.activitiesCount += 1;
+    this.host.connectionsMap[this.pid] = this.activitiesCount;
+  }
+
+  /**
+   * 连接数-
+   */
+  _connectionsCountMinus(id) {
+    if (this.activitiesMap.has(id)) {
+      this.activitiesCount = (this.activitiesCount > 0) ? (this.activitiesCount - 1) : 0;
+      this.activitiesMap.delete(id);
+    }
+    this.host.connectionsMap[this.pid] = this.activitiesCount;
+  }
+}
+
+module.exports = ForkProcess;

package/module/jobs/child/index.js

@@ -0,0 +1,35 @@
+//require('bytenode');
+const path = require('path');
+const ForkProcess = require('./forkProcess');
+const Ps = require('../../utils/ps');
+const Constants = require('../../const');
+
+class ChildJob {
+
+  /**
+    * constructor
+    * @param  {String} name - job name
+    * @param  {String} filepath - filepath
+    * @param  {Object} opt - child process options 
+    */
+  constructor(name, filepath, opt = {}) {
+    // todo
+    //processArgs: Ps.isDev() ?  [`--inspect=${Constants.jobs.inspectStartIndex}`] : [],
+    let options = Object.assign({
+      processArgs: Ps.isDev() ?  [] : [],
+      processOptions: { 
+        //cwd: path.dirname(filepath),
+        env: Ps.allEnv(), 
+        stdio: 'pipe' 
+      }
+    }, opt);
+
+    this.childProcess = new ForkProcess(this, filepath, options.processArgs, options.processOptions);
+
+    this.jobReady = false;
+    this.exec = filepath;
+    this.name = name;
+  }
+}
+
+module.exports = ChildJob;

package/module/jobs/index.js

@@ -0,0 +1,56 @@
+const path = require('path');
+const fs = require('fs');
+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(), this.path);
+    }
+    const filepath = Loader.resolveModule(this.path);
+
+    if (!fs.existsSync(filepath)) {
+      throw new Error(`[ee-core] [jobs-create] file ${this.path} 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,130 @@
+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');
+const Log = require('../log');
+
+module.exports = {
+
+  /**
+   * 加载单个文件(如果是函数，将被执行)
+   *
+   * @param {String} filepath - fullpath
+   * @param {Array} inject - pass rest arguments into the function when invoke
+   * @return {Object} exports
+   * @since 1.0.0
+   */
+  loadOneFile (filepath, ...inject) {
+    const isAbsolute = path.isAbsolute(filepath);
+    if (!isAbsolute) {
+      filepath = path.join(Ps.getBaseDir(), filepath);
+    }
+
+    filepath = filepath && this.resolveModule(filepath);
+    if (!fs.existsSync(filepath)) {
+      let errorMsg = `[ee-core] [module/loader/index] loadOneFile ${filepath} does not exist`;
+      Log.coreLogger.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+
+    const ret = UtilsCore.loadFile(filepath);
+    if (is.function(ret) && !is.class(ret) && !UtilsCore.isBytecodeClass(ret)) {
+      ret = ret(...inject);
+    }
+    return ret;
+  },
+
+  /**
+   * 加载job文件
+   *
+   * @param {String} filepath - fullpath
+   * @param {Array} inject - pass rest arguments into the function when invoke
+   * @return {Object} exports
+   * @since 1.0.0
+   */
+  loadJobFile (filepath, ...inject) {
+    if (!fs.existsSync(filepath)) {
+      let warnMsg = `[ee-core] [module/loader/index] loadJobFile ${filepath} does not exist`;
+      Log.coreLogger.error(warnMsg);
+    }
+
+    const ret = UtilsCore.loadFile(filepath);
+    if (is.function(ret) && !is.class(ret) && !UtilsCore.isBytecodeClass(ret)) {
+      ret = ret(...inject);
+    }
+    return ret;
+  },  
+
+  /**
+   * 模块的绝对路径
+   * @param {String} filepath - fullpath
+   */
+  resolveModule(filepath) {
+    let fullpath;
+    try {
+      fullpath = require.resolve(filepath);
+    } catch (e) {
+
+      // 特殊后缀处理
+      if (filepath && (filepath.endsWith('.defalut') || filepath.endsWith('.prod'))) {
+        fullpath = filepath + '.jsc';
+      } else if (filepath && filepath.endsWith('.js')) {
+        fullpath = filepath + 'c';
+      }
+
+      if (!fs.existsSync(filepath) && !fs.existsSync(fullpath)) {
+        let files = { filepath, fullpath }
+        Log.coreLogger.warn(`[ee-core] [module-loader-resolveModule] unknow filepath: ${files}`)
+        return undefined;
+      }
+    }
+
+    return fullpath;
+  },
+
+  /**
+   * 加载模块(子进程中使用)
+   *
+   * @param {String} filepath - fullpath
+   * @return {Object} exports
+   * @since 1.0.0
+   */
+  requireModule (filepath, type = '') {
+    let fullpath;
+    const isAbsolute = path.isAbsolute(filepath);
+    if (!isAbsolute) {
+      filepath = path.join(Ps.getBaseDir(), type, filepath);
+    }
+
+    fullpath = this.resolveModule(filepath);
+    if (!fs.existsSync(fullpath)) {
+      let errorMsg = `[ee-core] [module-loader-index] requireModule filepath: ${filepath} does not exist`;
+      Log.coreLogger.error(errorMsg);
+    }
+    const ret = UtilsCore.loadFile(fullpath);
+
+    return ret;
+  },  
+
+  /**
+   * 加载jobs模块(子进程中使用)
+   *
+   * @param {String} filepath - fullpath
+   * @return {Object} exports
+   * @since 1.0.0
+   */
+  requireJobsModule (filepath) {
+    const ret = this.requireModule(filepath, 'jobs');
+
+    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;