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

package/{lib/constant.js → module/const/index.js}

@@ -1,10 +1,13 @@
-module.exports = {
-  storageKey: {
-    cache: 'cache',
-  },
-  socketIo: {
-    channel: {
-      partySoftware: 'c1',
-    }
-  }
+module.exports = {
+  storageKey: {
+    cache: 'cache',
+  },
+  socketIo: {
+    channel: {
+      partySoftware: 'c1',
+    }
+  },
+  jobs: {
+    inspectStartIndex: 5858
+  }
 };

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

@@ -1,136 +1,170 @@
-'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');
-
-class HttpClientError extends FrameworkBaseError {
-  get module() {
-    return 'httpclient';
-  }
-}
-
-class HttpClient extends urllib.HttpClient2 {
-  constructor(app) {
-    normalizeConfig(app);
-    const config = app.config.httpclient;
-    super({
-      app,
-      defaultArgs: config.request,
-      agent: new Agent(config.httpAgent),
-      httpsAgent: new HttpsAgent(config.httpsAgent),
-    });
-    this.app = app;
-  }
-
-  request(url, args, callback) {
-    if (typeof args === 'function') {
-      callback = args;
-      args = null;
-    }
-
-    args = args || {};
-
-    // the callback style
-    if (callback) {
-      //this.app.deprecate('[httpclient] We now support async for this function, so callback isn\'t recommended.');
-      super.request(url, args)
-        .then(result => process.nextTick(() => callback(null, result.data, result.res)))
-        .catch(err => process.nextTick(() => callback(err)));
-      return;
-    }
-
-    // the Promise style
-    return super.request(url, args)
-      .catch(err => {
-        if (err.code === 'ENETUNREACH') {
-          throw HttpClientError.create(err.message, err.code);
-        }
-        throw err;
-      });
-  }
-
-  curl(url, args, callback) {
-    return this.request(url, args, callback);
-  }
-
-  requestThunk(url, args) {
-    //this.app.deprecate('[httpclient] Please use `request()` instead of `requestThunk()`');
-    return callback => {
-      this.request(url, args, (err, data, res) => {
-        if (err) {
-          return callback(err);
-        }
-        callback(null, {
-          data,
-          status: res.status,
-          headers: res.headers,
-          res,
-        });
-      });
-    };
-  }
-}
-
-function normalizeConfig(app) {
-  const config = app.config.httpclient;
-
-  // compatibility
-  if (typeof config.keepAlive === 'boolean') {
-    config.httpAgent.keepAlive = config.keepAlive;
-    config.httpsAgent.keepAlive = config.keepAlive;
-  }
-  if (config.timeout) {
-    config.timeout = ms(config.timeout);
-    config.httpAgent.timeout = config.timeout;
-    config.httpsAgent.timeout = config.timeout;
-  }
-  // compatibility httpclient.freeSocketKeepAliveTimeout => httpclient.freeSocketTimeout
-  if (config.freeSocketKeepAliveTimeout && !config.freeSocketTimeout) {
-    config.freeSocketTimeout = config.freeSocketKeepAliveTimeout;
-    delete config.freeSocketKeepAliveTimeout;
-  }
-  if (config.freeSocketTimeout) {
-    config.freeSocketTimeout = ms(config.freeSocketTimeout);
-    config.httpAgent.freeSocketTimeout = config.freeSocketTimeout;
-    config.httpsAgent.freeSocketTimeout = config.freeSocketTimeout;
-  } else {
-    // compatibility agent.freeSocketKeepAliveTimeout
-    if (config.httpAgent.freeSocketKeepAliveTimeout && !config.httpAgent.freeSocketTimeout) {
-      config.httpAgent.freeSocketTimeout = config.httpAgent.freeSocketKeepAliveTimeout;
-      delete config.httpAgent.freeSocketKeepAliveTimeout;
-    }
-    if (config.httpsAgent.freeSocketKeepAliveTimeout && !config.httpsAgent.freeSocketTimeout) {
-      config.httpsAgent.freeSocketTimeout = config.httpsAgent.freeSocketKeepAliveTimeout;
-      delete config.httpsAgent.freeSocketKeepAliveTimeout;
-    }
-  }
-
-  if (typeof config.maxSockets === 'number') {
-    config.httpAgent.maxSockets = config.maxSockets;
-    config.httpsAgent.maxSockets = config.maxSockets;
-  }
-  if (typeof config.maxFreeSockets === 'number') {
-    config.httpAgent.maxFreeSockets = config.maxFreeSockets;
-    config.httpsAgent.maxFreeSockets = config.maxFreeSockets;
-  }
-
-  if (config.httpAgent.timeout < 30000) {
-    app.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',
-      config.httpsAgent.timeout);
-    config.httpsAgent.timeout = 30000;
-  }
-
-  if (typeof config.request.timeout === 'string') {
-    config.request.timeout = ms(config.request.timeout);
-  }
-}
-
-module.exports = HttpClient;
+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() {
+    return 'httpclient';
+  }
+}
+
+class HttpClient extends urllib.HttpClient2 {
+  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({
+      defaultArgs: config.request,
+      agent: new Agent(config.httpAgent),
+      httpsAgent: new HttpsAgent(config.httpsAgent),
+    });
+    this.config = config;
+  }
+
+  /**
+   * 获取 coredb
+   */
+  _getCoreDB() {
+    const coreDB = Storage.connection('system');
+    return coreDB;
+  }  
+
+  request(url, args, callback) {
+    if (typeof args === 'function') {
+      callback = args;
+      args = null;
+    }
+
+    args = args || {};
+
+    // the callback style
+    if (callback) {
+      //this.app.deprecate('[httpclient] We now support async for this function, so callback isn\'t recommended.');
+      super.request(url, args)
+        .then(result => process.nextTick(() => callback(null, result.data, result.res)))
+        .catch(err => process.nextTick(() => callback(err)));
+      return;
+    }
+
+    // the Promise style
+    return super.request(url, args)
+      .catch(err => {
+        if (err.code === 'ENETUNREACH') {
+          throw HttpClientError.create(err.message, err.code);
+        }
+        throw err;
+      });
+  }
+
+  curl(url, args, callback) {
+    return this.request(url, args, callback);
+  }
+
+  requestThunk(url, args) {
+    //this.app.deprecate('[httpclient] Please use `request()` instead of `requestThunk()`');
+    return callback => {
+      this.request(url, args, (err, data, res) => {
+        if (err) {
+          return callback(err);
+        }
+        callback(null, {
+          data,
+          status: res.status,
+          headers: res.headers,
+          res,
+        });
+      });
+    };
+  }
+}
+
+function normalizeConfig(httpConfig) {
+  const config = httpConfig;
+
+  // compatibility
+  if (typeof config.keepAlive === 'boolean') {
+    config.httpAgent.keepAlive = config.keepAlive;
+    config.httpsAgent.keepAlive = config.keepAlive;
+  }
+  if (config.timeout) {
+    config.timeout = ms(config.timeout);
+    config.httpAgent.timeout = config.timeout;
+    config.httpsAgent.timeout = config.timeout;
+  }
+  // compatibility httpclient.freeSocketKeepAliveTimeout => httpclient.freeSocketTimeout
+  if (config.freeSocketKeepAliveTimeout && !config.freeSocketTimeout) {
+    config.freeSocketTimeout = config.freeSocketKeepAliveTimeout;
+    delete config.freeSocketKeepAliveTimeout;
+  }
+  if (config.freeSocketTimeout) {
+    config.freeSocketTimeout = ms(config.freeSocketTimeout);
+    config.httpAgent.freeSocketTimeout = config.freeSocketTimeout;
+    config.httpsAgent.freeSocketTimeout = config.freeSocketTimeout;
+  } else {
+    // compatibility agent.freeSocketKeepAliveTimeout
+    if (config.httpAgent.freeSocketKeepAliveTimeout && !config.httpAgent.freeSocketTimeout) {
+      config.httpAgent.freeSocketTimeout = config.httpAgent.freeSocketKeepAliveTimeout;
+      delete config.httpAgent.freeSocketKeepAliveTimeout;
+    }
+    if (config.httpsAgent.freeSocketKeepAliveTimeout && !config.httpsAgent.freeSocketTimeout) {
+      config.httpsAgent.freeSocketTimeout = config.httpsAgent.freeSocketKeepAliveTimeout;
+      delete config.httpsAgent.freeSocketKeepAliveTimeout;
+    }
+  }
+
+  if (typeof config.maxSockets === 'number') {
+    config.httpAgent.maxSockets = config.maxSockets;
+    config.httpsAgent.maxSockets = config.maxSockets;
+  }
+  if (typeof config.maxFreeSockets === 'number') {
+    config.httpAgent.maxFreeSockets = config.maxFreeSockets;
+    config.httpsAgent.maxFreeSockets = config.maxFreeSockets;
+  }
+
+  if (config.httpAgent.timeout < 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) {
+    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;
+  }
+
+  if (typeof config.request.timeout === 'string') {
+    config.request.timeout = ms(config.request.timeout);
+  }
+}
+
+module.exports = HttpClient;

package/module/jobs/child/forkProcess.js

@@ -0,0 +1,99 @@
+const { fork } = require('child_process');
+
+class ForkProcess {
+  constructor(host, modulePath, processArgs = [], processOptions = {}) {
+    this.host = host;
+    this.modulePath = modulePath;
+    this.args = processArgs;
+    this.options = processOptions;
+    this.sleeping = false;
+    this.activitiesCount = 0;
+    this.activitiesMap = new Map();
+
+    this.child = fork(
+      this.modulePath,
+      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,33 @@
+//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 = {}) {
+    let options = Object.assign({
+      processArgs: Ps.isDev() ?  [`--inspect=${Constants.jobs.inspectStartIndex}`] : [],
+      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,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;