ee-core 2.12.0 → 4.0.0-beta.1

package/core/{lib/loader → loader}/file_loader.js

@@ -1,35 +1,27 @@
 'use strict';
 
+const debug = require('debug')('ee-core:core:loader:file_loader');
 const assert = require('assert');
 const fs = require('fs');
-const debug = require('debug')('ee-core:fileLoader');
 const path = require('path');
 const globby = require('globby');
 const is = require('is-type-of');
-const deprecate = require('../../../utils/depd')('ee');
-const Utils = require('../utils');
-const FULLPATH = Symbol('EE_LOADER_ITEM_FULLPATH');
-const EXPORTS = Symbol('EE_LOADER_ITEM_EXPORTS');
-//const Addon = require('../../../addon');
+const { isBytecodeClass, loadFile, filePatterns } = require('../utils');
+const FULLPATH = Symbol('LOADER_ITEM_FULLPATH');
+const EXPORTS = Symbol('LOADER_ITEM_EXPORTS');
 
 const defaults = {
   directory: null,
   target: null,
   match: undefined,
-  ignore: undefined,
-  lowercaseFirst: false,
   caseStyle: 'camel',
   initializer: null,
   call: true,
-  override: false,
   inject: undefined,
-  filter: null,
-  loader: undefined,
 };
 
 /**
  * Load files from directory to target object.
- * @since 1.0.0
  */
 class FileLoader {
 
@@ -39,46 +31,31 @@ class FileLoader {
    * @param {String|Array} options.directory - directories to be loaded
    * @param {Object} options.target - attach the target object from loaded files
    * @param {String} options.match - match the files when load, support glob, default to all js files
-   * @param {String} options.ignore - ignore the files when load, support glob
    * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
    * @param {Boolean} options.call - determine whether invoke when exports is function
-   * @param {Boolean} options.override - determine whether override the property when get the same name
    * @param {Object} options.inject - an object that be the argument when invoke the function
-   * @param {Function} options.filter - a function that filter the exports which can be loaded
    * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
-   * @param {Object} options.loader - an object that be the argument when invoke the function
    */
   constructor(options) {
     assert(options.directory, 'options.directory is required');
-    assert(options.target, 'options.target is required');
     this.options = Object.assign({}, defaults, options);
-
-    // compatible old options _lowercaseFirst_
-    if (this.options.lowercaseFirst === true) {
-      deprecate('lowercaseFirst is deprecated, use caseStyle instead');
-      this.options.caseStyle = 'lower';
-    }
+    debug("[constructor] options: %o", this.options);
   }
 
   /**
    * attach items to target object. Mapping the directory to properties.
-   * `app/controller/group/repository.js` => `target.group.repository`
+   * `xxx/group/repository.js` => `target.group.repository`
    * @return {Object} target
-   * @since 1.0.0
    */
   load() {
     const items = this.parse();
-    const target = this.options.target;
+    const target = {};
     for (const item of items) {
-      // item { properties: [ 'a', 'b', 'c'], exports }
-      // => target.a.b.c = exports
+      // item { fullpath, properties: [ 'a', 'b', 'c'], exports }
       item.properties.reduce((target, property, index) => {
         let obj;
-        const properties = item.properties.slice(0, index + 1).join('.');
+        // properties is a path slice, only the last value is the file name
         if (index === item.properties.length - 1) {
-          if (property in target) {
-            if (!this.options.override) throw new Error(`can't overwrite property '${properties}' from ${target[property][FULLPATH]} by ${item.fullpath}`);
-          }
           obj = item.exports;
           if (obj && !is.primitive(obj)) {
             obj[FULLPATH] = item.fullpath;
@@ -89,166 +66,78 @@ class FileLoader {
         }
         
         target[property] = obj;
-        debug('loaded %s', properties);
+        // const properties = item.properties.slice(0, index + 1).join('.');
+        // debug('[load] properties: %s', properties);
         return obj;
       }, target);
     }
-
+    //debug('[load] target: %O', target);
     return target;
   }
 
   /**
    * Parse files from given directories, then return an items list, each item contains properties and exports.
-   *
-   * For example, parse `app/controller/group/repository.js`
-   *
-   * ```
-   * module.exports = app => {
-   *   return class RepositoryController extends app.Controller {};
-   * }
-   * ```
-   *
+   * For example, parse `controller/group/repository.js`
    * It returns a item
-   *
    * ```
    * {
+   *   fullpath: '',
    *   properties: [ 'group', 'repository' ],
-   *   exports: app => { ... },
+   *   exports: { ... },
    * }
    * ```
-   *
    * `Properties` is an array that contains the directory of a filepath.
-   *
    * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
    * @return {Array} items
-   * @since 1.0.0
    */
   parse() {
     let files = this.options.match;
     if (!files) {
-      files = (process.env.EE_TYPESCRIPT === 'true' && Utils.extensions['.ts'])
-        ? [ '**/*.(js|ts)', '!**/*.d.ts' ]
-        : [ '**/*.js', '**/*.jsc'];
+      files = filePatterns();
     } else {
       files = Array.isArray(files) ? files : [ files ];
     }
-    
-    let ignore = this.options.ignore;
-    if (ignore) {
-      ignore = Array.isArray(ignore) ? ignore : [ ignore ];
-      ignore = ignore.filter(f => !!f).map(f => '!' + f);
-      files = files.concat(ignore);
-    }
 
     let directories = this.options.directory;
     if (!Array.isArray(directories)) {
       directories = [ directories ];
     }
 
-    const filter = is.function(this.options.filter) ? this.options.filter : null;
     const items = [];
-    debug('parsing %j', directories);
-
+    debug('[parse] directories %o', directories);
+    
     for (const directory of directories) {
       const filepaths = globby.sync(files, { cwd: directory });
+      debug('[parse] filepaths %o', filepaths);
       for (const filepath of filepaths) {
         const fullpath = path.join(directory, filepath);
         if (!fs.statSync(fullpath).isFile()) continue;
         // get properties
-        // app/service/foo/bar.js => [ 'foo', 'bar' ]
+        // controller/foo/bar.js => [ 'foo', 'bar' ]
         const properties = getProperties(filepath, this.options);
-        // app/service/foo/bar.js => service.foo.bar
+        // debug('[parse] properties %o', properties);
+        // controller/foo/bar.js => controller.foo.bar
         const pathName = directory.split(/[/\\]/).slice(-1) + '.' + properties.join('.');
+        // debug('[parse] pathName %s', pathName);
         // get exports from the file
         let exports = getExports(fullpath, this.options, pathName);
         // ignore exports when it's null or false returned by filter function
-        if (exports == null || (filter && filter(exports) === false)) continue;
+        if (exports == null) continue;
 
         // set properties of class
-        if (is.class(exports) || Utils.isBytecodeClass(exports)) {
+        if (is.class(exports) || isBytecodeClass(exports)) {
           exports.prototype.pathName = pathName;
           exports.prototype.fullPath = fullpath;
         }
-
         items.push({ fullpath, properties, exports });
-        debug('parse %s, properties %j, export %O', fullpath, properties, exports);
+        //debug('[parse] fullpath %s, properties %o, export %o', fullpath, properties, exports);
       }
     }
-
+    //debug('[parse] items %O', items);
     return items;
   }
-
-  /**
-   * attach items to target object for addons.
-   * `app/addon/group/index.js` => `target.group`
-   * @return {Object} target
-   * @since 1.0.0
-   */
-  loadAddons() {
-    const items = [];
-    const files = '*';
-    const app = this.options.inject;
-    const loader = this.options.loader;
-    const target = this.options.target;
-    let directories = this.options.directory;
-    
-    if (!Array.isArray(directories)) {
-      directories = [ directories ];
-    }
-
-    // check addon 
-    const config = app.config.addons;
-    let filterAddons = [];
-    for (let key of Object.keys(config)) {
-      if (!config[key].enable) {
-        filterAddons.push(key);
-      }
-    }
-
-    for (const directory of directories) {
-      const addonpaths = globby.sync(files, { cwd: directory, deep: 1, onlyDirectories: true});
-      for (const addonName of addonpaths) {
-        if (filterAddons.includes(addonName)) continue;
-
-        const filepath = path.join(directory, addonName, 'index');
-        const fullpath = loader.resolveModule(filepath);
-        if (!fs.existsSync(fullpath)) {
-          throw new Error(`The ${filepath} file does not exist`);
-        }
-        if (!fs.statSync(fullpath).isFile()) continue;
-  
-        let exports = getExports(fullpath, this.options, addonName);
-        if (exports == null) continue;
-  
-        const properties = [addonName];
-        if (is.class(exports) || Utils.isBytecodeClass(exports)) {
-          exports.prototype.pathName = addonName;
-          exports.prototype.fullPath = fullpath;
-        }
-  
-        items.push({ fullpath, properties, exports });
-      }
-  
-      for (const item of items) {
-        const property = item.properties[0];
-        let obj = item.exports;
-        if (obj && !is.primitive(obj)) {
-          obj[FULLPATH] = item.fullpath;
-          obj[EXPORTS] = true;
-        }
-        
-        target[property] = obj;
-      }
-    }
-
-    return target;
-  }
 }
 
-module.exports = FileLoader;
-module.exports.EXPORTS = EXPORTS;
-module.exports.FULLPATH = FULLPATH;
-
 // convert file path to an array of properties
 // a/b/c.js => ['a', 'b', 'c']
 function getProperties(filepath, { caseStyle }) {
@@ -265,29 +154,18 @@ function getProperties(filepath, { caseStyle }) {
 // Get exports from filepath
 // If exports is null/undefined, it will be ignored
 function getExports(fullpath, { initializer, call, inject }, pathName) {
-  let exports = Utils.loadFile(fullpath);
-
-  // process exports as you like
+  let exports = loadFile(fullpath);
+  //debug('[getExports] exports %o', exports);
   if (initializer) {
+    // exports type is Class or Object
     exports = initializer(exports, { path: fullpath, pathName });
   }
 
-  // return exports when it's a class or generator
-  //
-  // module.exports = class Service {};
-  // or
-  // module.exports = function*() {}
-  //new exports;
-
-  if (is.class(exports) || is.generatorFunction(exports) || is.asyncFunction(exports) || Utils.isBytecodeClass(exports)) {
+  if (is.class(exports) || is.generatorFunction(exports) || is.asyncFunction(exports) || isBytecodeClass(exports)) {
     return exports;
   }
 
-  // return exports after call when it's a function
-  //
-  // module.exports = function(app) {
-  //   return {};
-  // }
+  // whether to execute the function
   if (call && is.function(exports)) {
     exports = exports(inject);
     if (exports != null) {
@@ -295,7 +173,6 @@ function getExports(fullpath, { initializer, call, inject }, pathName) {
     }
   }
 
-  // return exports what is
   return exports;
 }
 
@@ -311,7 +188,7 @@ function defaultCamelize(filepath, caseStyle) {
     // fooBar.js  > FooBar
     // FooBar.js  > FooBar
     // FooBar.js  > FooBar
-    // FooBar.js  > fooBar (if lowercaseFirst is true)
+    // FooBar.js  > fooBar
     property = property.replace(/[_-][a-z]/ig, s => s.substring(1).toUpperCase());
     let first = property[0];
     switch (caseStyle) {
@@ -327,3 +204,9 @@ function defaultCamelize(filepath, caseStyle) {
     return first + property.substring(1);
   });
 }
+
+module.exports = {
+  FileLoader,
+  EXPORTS,
+  FULLPATH,
+};

package/core/utils/index.js

@@ -0,0 +1,83 @@
+'use strict';
+
+require('bytenode');
+const is = require('is-type-of');
+const path = require('path');
+const fs = require('fs');
+const BuiltinModule = require('module');
+
+// Guard against poorly mocked module constructors.
+const Module = module.constructor.length > 1
+  ? module.constructor
+  /* istanbul ignore next */
+  : BuiltinModule;
+
+// Module._extensions:
+// '.js': [Function (anonymous)],
+// '.json': [Function (anonymous)],
+// '.node': [Function: func],
+// '.jsc': [Function (anonymous)]
+
+const extensions = Module._extensions;
+
+function loadFile(filepath) {
+  try {
+    // if not js module, just return content buffer
+    const extname = path.extname(filepath);
+    if (extname && !Module._extensions[extname]) {
+      return fs.readFileSync(filepath);
+    }
+
+    // require js module
+    const obj = require(filepath);
+    if (!obj) return obj;
+    // it's es module
+    if (obj.__esModule) return 'default' in obj ? obj.default : obj;
+    return obj;
+  } catch (err) {
+    err.message = `[ee-core] load file: ${filepath}, error: ${err.message}`;
+    throw err;
+  }
+}
+
+async function callFn(fn, args, ctx) {
+  args = args || [];
+  if (!is.function(fn)) return;
+  return ctx ? fn.call(ctx, ...args) : fn(...args);
+}
+
+function getResolvedFilename(filepath, baseDir) {
+  const reg = /[/\\]/g;
+  return filepath.replace(baseDir + path.sep, '').replace(reg, '/');
+}
+
+/**
+ * 字节码类
+ */
+function isBytecodeClass(exports) {
+  let isClass = false;
+
+  // 标识
+  if (exports.toString().indexOf('[class') != -1) {
+    isClass = true;
+  }
+  
+  return isClass;
+}
+
+/**
+ * 文件类型
+ */
+function filePatterns() {
+  const files = [ '**/*.js','**/*.jsc' ];
+  return files;
+}
+
+module.exports = {
+  extensions,
+  loadFile,
+  callFn,
+  getResolvedFilename,
+  isBytecodeClass,
+  filePatterns,
+};

package/core/{lib/utils → utils}/timing.js

@@ -4,7 +4,6 @@ const assert = require('assert');
 const MAP = Symbol('Timing#map');
 const LIST = Symbol('Timing#list');
 
-
 class Timing {
 
   constructor() {
@@ -74,4 +73,6 @@ class Timing {
   }
 }
 
-module.exports = Timing;
+module.exports = {
+  Timing
+};

package/cross/cross.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const EventEmitter = require('events');
+const { getConfig } = require('../config');
+const { sleep, getValueFromArgv, replaceArgsValue } = require('../utils/helper');
+const { SpawnProcess } = require('./spawnProcess');
+const { Events } = require('../const/channel');
+const { extend } = require('../utils/extend');
+const { getPort } = require('../utils/port');
+
+class CrossProcess {
+  constructor() {
+    this.emitter = undefined;
+
+    // pid唯一
+    // {pid:{name,entity}, pid:{name,entity}, ...}
+    this.children = {};
+  
+    // name唯一
+    // {name:pid, name:pid, ...}
+    this.childrenMap = {};
+
+    // eventEmitter
+    this._initEventEmitter();
+  }
+
+  async create() {
+
+    // boot services
+    const crossCfg = getConfig().cross;
+    //await sleep(5 * 1000);
+
+    for (let key of Object.keys(crossCfg)) {
+      let val = crossCfg[key];
+      if (val.enable == true) {
+        this.run(key)
+      }
+    }
+  }
+
+  // run
+  async run(service, opt = {}) {
+    const crossConf = getConfig().cross;
+    const defaultOpt = crossConf[service] || {};
+    const targetConf = extend(true, {}, defaultOpt, opt);
+    if (Object.keys(targetConf).length == 0) {
+      throw new Error(`[ee-core] [cross] The service [${service}] config does not exit`);
+    }
+    
+    // format params
+    let tmpArgs = targetConf.args;
+    let confPort = parseInt(getValueFromArgv(tmpArgs, 'port'));
+    // 某些程序给它传入不存在的参数时会报错
+    if (isNaN(confPort) && targetConf.port > 0) {
+      confPort = targetConf.port;
+    }
+    if (confPort > 0) {
+      // 动态生成port，传入的端口必须为int
+      confPort = await getPort({ port: confPort });
+      // 替换port
+      targetConf.args = replaceArgsValue(tmpArgs, "port", String(confPort));
+    }
+
+    // 创建进程
+    const subProcess = new SpawnProcess(this, { targetConf, port: confPort });
+    let uniqueName = targetConf.name;
+    if (this.childrenMap.hasOwnProperty(uniqueName)) {
+      uniqueName = uniqueName + "-" + String(subProcess.pid);
+    }
+    this.childrenMap[uniqueName] = subProcess.pid;
+    subProcess.name = uniqueName;
+    this.children[subProcess.pid] = {
+      name: uniqueName,
+      entity: subProcess
+    };
+
+    return subProcess;
+  }
+
+  killAll() {
+    Object.keys(this.children).forEach(pid => {
+      this.kill(pid)
+    });
+  }
+
+  kill(pid) {
+    const entity = this.getProc(pid);
+    if (entity) {
+      entity.kill();
+    }
+  }
+
+  killByName(name) {
+    const entity = this.getProcByName(name);
+    if (entity) {
+      entity.kill();
+    }
+  }
+
+  getUrl(name) {
+    const entity = this.getProcByName(name);
+    const url = entity.getUrl();
+
+    return url;
+  }
+
+  // 获取 proc
+  getProcByName(name) {
+    const pid = this.childrenMap[name];
+    if (!pid) {
+      throw new Error(`[ee-core] [cross] The process named [${name}] does not exit`);
+    }
+    const entity = this.getProc(pid);
+
+    return entity;
+  }
+
+  // 获取 proc
+  getProc(pid) {
+    const child = this.children[pid];
+    if (!pid) {
+      throw new Error(`[ee-core] [cross] The process pid [${pid}] does not exit`);
+    }
+
+    return child.entity;
+  } 
+
+  // 获取pids  
+  getPids() {
+    let pids = Object.keys(this.children);
+    return pids;
+  }
+
+  _initEventEmitter() {
+    this.emitter = new EventEmitter();  
+    this.emitter.on(Events.childProcessExit, (data) => {
+      const child = this.children[data.pid];
+      delete this.childrenMap[child.name];
+      delete this.children[data.pid];
+    });
+    this.emitter.on(Events.childProcessError, (data) => {
+      const child = this.children[data.pid];
+      delete this.childrenMap[child.name];
+      delete this.children[data.pid];
+    });
+  }
+}  
+
+module.exports = {
+  CrossProcess,
+  cross: new CrossProcess()
+};