ee-core 2.0.3 → 2.1.0-beta.3

package/message/childMessage.js

@@ -9,8 +9,18 @@ class ChildMessage {
    * 向主进程发消息
    */
   sendToMain(eventName, params = {}) {
+    let receiver = Channel.receiver.childJob;
+    return this.send(eventName, params, receiver);
+  }
+
+  /**
+   * 向主进程发消息
+   */
+  send(eventName, params = {}, receiver) {
+    let eventReceiver = receiver || Channel.receiver.forkProcess;
     let message = {
       channel: Channel.process.sendToMain,
+      eventReceiver,
       event: eventName,
       data: params,
     }
@@ -24,6 +34,19 @@ class ChildMessage {
   exit(code = 0) {
     return process.exit(code);
   }
+
+  /**
+   * 发送错误到控制台
+   */
+  sendErrorToTerminal(err) {
+    let errTips = (err && typeof err == 'object') ? err.toString() : '';
+    errTips += ' Error !!! Please See file ee-core.log or ee-error-xxx.log for details !'
+    let message = {
+      channel: Channel.process.showException,
+      data: errTips
+    }
+    process.send(message);
+  }
 }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ee-core",
-  "version": "2.0.3",
+  "version": "2.1.0-beta.3",
   "description": "ee core",
   "main": "index.js",
   "scripts": {
@@ -14,16 +14,11 @@
   "dependencies": {
     "agentkeepalive": "^4.2.0",
     "bytenode": "^1.3.6",
-    "co": "^4.6.0",
     "debug": "^4.3.3",
-    "depd": "^2.0.0",
     "egg-errors": "^2.3.0",
     "egg-logger": "^2.7.1",
-    "extend2": "^1.0.1",
     "fs-extra": "^10.0.0",
-    "get-port": "^5.1.1",
     "globby": "^10.0.0",
-    "humanize-ms": "^1.2.1",
     "is-type-of": "^1.2.1",
     "javascript-obfuscator": "^4.0.0",
     "koa": "^2.13.4",

package/ps/index.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const eis = require('../utils/is');
+const Log = require('../log');
 
 /**
  * 当前进程的所有env
@@ -238,4 +239,47 @@ exports.makeMessage = function(msg = {}) {
   }, msg);
 
   return message;
+}
+
+/**
+ * 退出ChildJob进程
+ */
+exports.exitChildJob = function(code = 0) {
+  try {
+    let args = JSON.parse(process.argv[2]);
+    if (args.type == 'childJob') {
+      process.exit(code);
+    }
+  } catch (e) {
+    process.exit(code);
+  }
+}
+
+
+/**
+ * 任务类型 ChildJob
+ */
+exports.isChildJob = function() {
+  try {
+    let args = JSON.parse(process.argv[2]);
+    if (args.type == 'childJob') {
+      return true;
+    }
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * 任务类型 ChildPoolJob
+ */
+exports.isChildPoolJob = function() {
+  try {
+    let args = JSON.parse(process.argv[2]);
+    if (args.type == 'childPoolJob') {
+      return true;
+    }
+  } catch (e) {
+    return false;
+  }
 }

package/tools/encrypt.js

@@ -7,6 +7,7 @@ const is = require('is-type-of');
 const bytenode = require('bytenode');
 const crypto = require('crypto');
 const JavaScriptObfuscator = require('javascript-obfuscator');
+const globby = require('globby');
 const UtilsJson = require('../utils/json');
 
 class Encrypt {
@@ -16,11 +17,14 @@ class Encrypt {
     this.encryptCodeDir = path.join(this.basePath, 'public');
     this.config = this.loadConfig('encrypt.js');
     this.filesExt = this.config.fileExt || ['.js'];
-    this.type = this.config.type || 'bytecode';
+    this.type = this.config.type || 'confusion';
     this.bOpt = this.config.bytecodeOptions || {};
     this.cOpt = this.config.confusionOptions || {};
+    this.cleanFiles = this.config.cleanFiles || ['electron'];
 
     const directory = this.config.directory || ['electron'];
+    this.patterns = this.config.files || null;
+    this.specificFiles = [ 'electron/preload/bridge.js' ];
     this.tmpFile = ''; // todo
     this.mapFile = ''; // todo
 
@@ -34,49 +38,80 @@ class Encrypt {
       }
     }
 
-    // 检查存在的目录
     for (let i = 0; i < directory.length; i++) {
       let codeDirPath = path.join(this.basePath, directory[i]);
       if (fs.existsSync(codeDirPath)) {
         this.dirs.push(directory[i]);
       }
     }
-    console.log('[ee-core] [tools/encrypt] dirs:', this.dirs);
+
+    this.codefiles = this._initCodeFiles();
+    //console.log('[ee-core] [tools/encrypt] codefiles:', this.codefiles);
   }
 
   /**
-   * 备份 electron 目录代码
+   * 初始化需要加密的文件列表
    */
-  backup () {
-    console.log('[ee-core] [tools/encrypt] backup start');
-
-    for (let i = 0; i < this.dirs.length; i++) {
-      // check code dir
-      let codeDirPath = path.join(this.basePath, this.dirs[i]);
-      if (!fs.existsSync(codeDirPath)) {
-        console.log('[ee-core] [tools/encrypt] ERROR: backup %s is not exist', codeDirPath);
-        return
-      }
+  _initCodeFiles() {
+    if (!this.patterns) return;
 
-      let targetDir = path.join(this.encryptCodeDir, this.dirs[i]);
+    const files = globby.sync(this.patterns, { cwd: this.basePath });
+    return files;
+  }
 
-      // remove old
-      this.rmBackup(targetDir);
+  /**
+   * 备份代码
+   */
+  backup() {
+    // clean
+    this.cleanCode();
 
-      // copy
-      console.log('[ee-core] [tools/encrypt] backup target Dir:', targetDir);
-      if (!fs.existsSync(targetDir)) {
-        this.mkdir(targetDir);
-        this.chmodPath(targetDir, '777');
+    console.log('[ee-core] [tools/encrypt] backup start');
+    if (this.patterns) {
+      this.codefiles.forEach((filepath) => {
+        let source = path.join(this.basePath, filepath);
+        if (fs.existsSync(source)) {
+          let target = path.join(this.encryptCodeDir, filepath);
+          fsPro.copySync(source, target);
+        }
+      })
+    } else {
+      for (let i = 0; i < this.dirs.length; i++) {
+        // check code dir
+        let codeDirPath = path.join(this.basePath, this.dirs[i]);
+        if (!fs.existsSync(codeDirPath)) {
+          console.log('[ee-core] [tools/encrypt] ERROR: backup %s is not exist', codeDirPath);
+          return
+        }
+  
+        // copy
+        let targetDir = path.join(this.encryptCodeDir, this.dirs[i]);
+        console.log('[ee-core] [tools/encrypt] backup target Dir:', targetDir);
+        if (!fs.existsSync(targetDir)) {
+          this.mkdir(targetDir);
+          this.chmodPath(targetDir, '777');
+        }
+  
+        fsPro.copySync(codeDirPath, targetDir);
       }
-
-      fsPro.copySync(codeDirPath, targetDir);
     }
+
     console.log('[ee-core] [tools/encrypt] backup end');
     return true;
   }
   
-  prepare () {
+  /**
+   * 清除加密代码
+   */
+  cleanCode() {
+    this.cleanFiles.forEach((file) => {
+      let tmpFile = path.join(this.encryptCodeDir, file);
+      this.rmBackup(tmpFile);
+      console.log('[ee-core] [tools/encrypt] clean up tmp files:', tmpFile);
+    })
+  }
+
+  prepare() {
     if (this.type == 'bytecode') {
       let filename = this.config.mangle || this.config.mangle.file || null;
       if (filename) {
@@ -96,11 +131,28 @@ class Encrypt {
   /**
    * 加密代码
    */
-  encrypt () {
+  encrypt() {
     console.log('[ee-core] [tools/encrypt] start ciphering');
-    for (let i = 0; i < this.dirs.length; i++) {
-      let codeDirPath = path.join(this.encryptCodeDir, this.dirs[i]);
-      this.loop(codeDirPath);
+    if (this.patterns) {
+      for (const file of this.codefiles) {
+        const fullpath = path.join(this.encryptCodeDir, file);
+        if (!fs.statSync(fullpath).isFile()) continue;
+
+        // 特殊文件处理
+        if (this.specificFiles.includes(file)) {
+          this.generate(fullpath, 'confusion');
+          continue;
+        }
+
+        this.generate(fullpath);
+      }  
+    } else {
+      console.log('[ee-core] [tools/encrypt] !!!!!! please use the new encryption method !!!!!!');
+      for (let i = 0; i < this.dirs.length; i++) {
+        let codeDirPath = path.join(this.encryptCodeDir, this.dirs[i]);
+        this.loop(codeDirPath);
+      }
+      console.log('[ee-core] [tools/encrypt] !!!!!! please use the new encryption method !!!!!!');
     }
 
     console.log('[ee-core] [tools/encrypt] end ciphering');
@@ -109,7 +161,7 @@ class Encrypt {
   /**
    * 递归
    */
-  loop (dirPath) {
+  loop(dirPath) {
     let files = [];
     if (fs.existsSync(dirPath)) {
       files = fs.readdirSync(dirPath);
@@ -130,10 +182,13 @@ class Encrypt {
   /**
    * 生成文件
    */  
-  generate (curPath) {
-    if (this.type == 'bytecode') {
+  generate(curPath, type) {
+    let encryptType = type ? type : this.type;
+    console.log(`[ee-core] [tools/encrypt] file: ${curPath} (${encryptType})`);
+
+    if (encryptType == 'bytecode') {
       this.generateBytecodeFile(curPath);
-    } else if (this.type == 'confusion') {
+    } else if (encryptType == 'confusion') {
       this.generateJSConfuseFile(curPath);
     } else {
       this.generateJSConfuseFile(curPath);
@@ -144,7 +199,7 @@ class Encrypt {
   /**
    * 使用 javascript-obfuscator 生成压缩/混淆文件
    */  
-  generateJSConfuseFile (file) {
+  generateJSConfuseFile(file) {
     let opt = Object.assign({
       compact: true,
       stringArray: true,
@@ -159,7 +214,7 @@ class Encrypt {
   /**
    * 生成字节码文件
    */
-  generateBytecodeFile (curPath) {
+  generateBytecodeFile(curPath) {
     if (path.extname(curPath) !== '.js') {
       return
     }
@@ -181,10 +236,9 @@ class Encrypt {
   /**
    * 移除备份
    */
-  rmBackup (dir) {
-    if (fs.existsSync(dir)) {
-      console.log('[ee-core] [tools/encrypt] clean old directory:', dir);
-      fsPro.removeSync(dir);
+  rmBackup(file) {
+    if (fs.existsSync(file)) {
+      fsPro.removeSync(file);
     }
     return;
   }
@@ -192,7 +246,7 @@ class Encrypt {
   /**
    * 检查文件是否存在
    */
-  fileExist (filePath) {
+  fileExist(filePath) {
     try {
       return fs.statSync(filePath).isFile();
     } catch (err) {
@@ -200,7 +254,7 @@ class Encrypt {
     }
   };
 
-  mkdir (dirpath, dirname) {
+  mkdir(dirpath, dirname) {
     // 判断是否是第一次调用
     if (typeof dirname === 'undefined') {
       if (fs.existsSync(dirpath)) {
@@ -222,7 +276,7 @@ class Encrypt {
     }
   };
 
-  chmodPath (path, mode) {
+  chmodPath(path, mode) {
     let files = [];
     if (fs.existsSync(path)) {
       files = fs.readdirSync(path);
@@ -238,7 +292,7 @@ class Encrypt {
     }
   };
 
-  loadConfig (prop) {
+  loadConfig(prop) {
     const filepath = path.join(this.basePath, 'electron', 'config', prop);
     if (!fs.existsSync(filepath)) {
       return {};
@@ -254,7 +308,7 @@ class Encrypt {
     return ret || {};
   };
 
-  md5 (file) {
+  md5(file) {
     const buffer = fs.readFileSync(file);
     const hash = crypto.createHash('md5');
     hash.update(buffer, 'utf8');
@@ -270,6 +324,12 @@ const run = () => {
   e.encrypt();
 }
 
+const clean = () => {
+  const e = new Encrypt();
+  e.cleanCode();
+}
+
 module.exports = {
-  run
+  run,
+  clean,
 };

package/utils/co.js

@@ -0,0 +1,237 @@
+
+/**
+ * slice() reference.
+ */
+
+var slice = Array.prototype.slice;
+
+/**
+ * Expose `co`.
+ */
+
+module.exports = co['default'] = co.co = co;
+
+/**
+ * Wrap the given generator `fn` into a
+ * function that returns a promise.
+ * This is a separate function so that
+ * every `co()` call doesn't create a new,
+ * unnecessary closure.
+ *
+ * @param {GeneratorFunction} fn
+ * @return {Function}
+ * @api public
+ */
+
+co.wrap = function (fn) {
+  createPromise.__generatorFunction__ = fn;
+  return createPromise;
+  function createPromise() {
+    return co.call(this, fn.apply(this, arguments));
+  }
+};
+
+/**
+ * Execute the generator function or a generator
+ * and return a promise.
+ *
+ * @param {Function} fn
+ * @return {Promise}
+ * @api public
+ */
+
+function co(gen) {
+  var ctx = this;
+  var args = slice.call(arguments, 1)
+
+  // we wrap everything in a promise to avoid promise chaining,
+  // which leads to memory leak errors.
+  // see https://github.com/tj/co/issues/180
+  return new Promise(function(resolve, reject) {
+    if (typeof gen === 'function') gen = gen.apply(ctx, args);
+    if (!gen || typeof gen.next !== 'function') return resolve(gen);
+
+    onFulfilled();
+
+    /**
+     * @param {Mixed} res
+     * @return {Promise}
+     * @api private
+     */
+
+    function onFulfilled(res) {
+      var ret;
+      try {
+        ret = gen.next(res);
+      } catch (e) {
+        return reject(e);
+      }
+      next(ret);
+    }
+
+    /**
+     * @param {Error} err
+     * @return {Promise}
+     * @api private
+     */
+
+    function onRejected(err) {
+      var ret;
+      try {
+        ret = gen.throw(err);
+      } catch (e) {
+        return reject(e);
+      }
+      next(ret);
+    }
+
+    /**
+     * Get the next value in the generator,
+     * return a promise.
+     *
+     * @param {Object} ret
+     * @return {Promise}
+     * @api private
+     */
+
+    function next(ret) {
+      if (ret.done) return resolve(ret.value);
+      var value = toPromise.call(ctx, ret.value);
+      if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
+      return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
+        + 'but the following object was passed: "' + String(ret.value) + '"'));
+    }
+  });
+}
+
+/**
+ * Convert a `yield`ed value into a promise.
+ *
+ * @param {Mixed} obj
+ * @return {Promise}
+ * @api private
+ */
+
+function toPromise(obj) {
+  if (!obj) return obj;
+  if (isPromise(obj)) return obj;
+  if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
+  if ('function' == typeof obj) return thunkToPromise.call(this, obj);
+  if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
+  if (isObject(obj)) return objectToPromise.call(this, obj);
+  return obj;
+}
+
+/**
+ * Convert a thunk to a promise.
+ *
+ * @param {Function}
+ * @return {Promise}
+ * @api private
+ */
+
+function thunkToPromise(fn) {
+  var ctx = this;
+  return new Promise(function (resolve, reject) {
+    fn.call(ctx, function (err, res) {
+      if (err) return reject(err);
+      if (arguments.length > 2) res = slice.call(arguments, 1);
+      resolve(res);
+    });
+  });
+}
+
+/**
+ * Convert an array of "yieldables" to a promise.
+ * Uses `Promise.all()` internally.
+ *
+ * @param {Array} obj
+ * @return {Promise}
+ * @api private
+ */
+
+function arrayToPromise(obj) {
+  return Promise.all(obj.map(toPromise, this));
+}
+
+/**
+ * Convert an object of "yieldables" to a promise.
+ * Uses `Promise.all()` internally.
+ *
+ * @param {Object} obj
+ * @return {Promise}
+ * @api private
+ */
+
+function objectToPromise(obj){
+  var results = new obj.constructor();
+  var keys = Object.keys(obj);
+  var promises = [];
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var promise = toPromise.call(this, obj[key]);
+    if (promise && isPromise(promise)) defer(promise, key);
+    else results[key] = obj[key];
+  }
+  return Promise.all(promises).then(function () {
+    return results;
+  });
+
+  function defer(promise, key) {
+    // predefine the key in the result
+    results[key] = undefined;
+    promises.push(promise.then(function (res) {
+      results[key] = res;
+    }));
+  }
+}
+
+/**
+ * Check if `obj` is a promise.
+ *
+ * @param {Object} obj
+ * @return {Boolean}
+ * @api private
+ */
+
+function isPromise(obj) {
+  return 'function' == typeof obj.then;
+}
+
+/**
+ * Check if `obj` is a generator.
+ *
+ * @param {Mixed} obj
+ * @return {Boolean}
+ * @api private
+ */
+
+function isGenerator(obj) {
+  return 'function' == typeof obj.next && 'function' == typeof obj.throw;
+}
+
+/**
+ * Check if `obj` is a generator function.
+ *
+ * @param {Mixed} obj
+ * @return {Boolean}
+ * @api private
+ */
+function isGeneratorFunction(obj) {
+  var constructor = obj.constructor;
+  if (!constructor) return false;
+  if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
+  return isGenerator(constructor.prototype);
+}
+
+/**
+ * Check for plain object.
+ *
+ * @param {Mixed} val
+ * @return {Boolean}
+ * @api private
+ */
+
+function isObject(val) {
+  return Object == val.constructor;
+}