@x-9lab/xlab 1.6.1 → 2.0.1

package/README.md

@@ -1,8 +1,10 @@
 X-9lab 通用服务端
 =======
 
+> 当前为 v2 版本(breaking change),从 v1 升级请先阅读 [MIGRATION.md](./MIGRATION.md)。
+
 ## 开发环境配置
-1. 安装 [node](https://nodejs.org/) ,需要 10.0.0 以上版本
+1. 安装 [node](https://nodejs.org/) ,需要 20.0.0 以上版本
 
 ## 使用
 - 将 `@x-9lab/xlab` 加入到依赖中
@@ -18,14 +20,21 @@ X-9lab 通用服务端
         ```bash
         xlab --APP_NAME=nice
         ```
+    - 其他命令行参数
+        - `-w` / `--watch` 开启 watch 模式
+        - `-r` / `--root` 指定执行根目录
+        - `-f` / `--file` 指定启动配置文件地址
+        - `PORT=3001` 覆盖监听端口，`IP=127.0.0.1` 指定绑定地址，`ENV=<环境>` 指定运行环境
+- 运行环境
+    由 `ENV=` 参数或 `NODE_ENV` 决定，支持 `development`(开发) / `sandbox`(沙箱) / `production`(生产)，也可使用数字别名 `0` / `2` / `1`；未指定时默认 development。环境决定加载哪份 `@config` 环境配置与 `.xlab` 环境文件
 - 配置文件 `xlab.config.js`
     模块会自动检测执行根目录中是否存在 `xlab.config.js` 文件。如存在该文件则会使用该文件为模块的启动配置文件。支持的配置项：
     1. `watch` 是否开启 watch 模式
-    1. `business` 业务目录名称。注意当前只支持根目录下的文件夹
+    1. `businessDir` 服务端业务目录名称，默认 `@server`。注意当前只支持根目录下的文件夹
 - 配置文件 `.xlab`
-    该文件用于定义系统中的全局变量，模块会自动检测执行根目录中是否存在 `.xlab` 文件。该类型文件一般用于定义一些不方便在代码中声明的敏感数据，因此 `.xlab` 及附属的环境文件 **不应该** 被提交到仓库中。
-    - 使用 `<key>=<value>` 的方式定义数据
-    - 文件中的数据会被加载到 `global.XLAB` 对象中
+    该文件用于定义系统级的环境数据，模块会自动检测执行根目录中是否存在 `.xlab` 文件。该类型文件一般用于定义一些不方便在代码中声明的敏感数据，因此 `.xlab` 及附属的环境文件 **不应该** 被提交到仓库中。
+    - 使用 `<key>=<value>` 的方式定义数据，value 按 JSON 解析
+    - 文件中的数据通过 `getXlabEnv()` 获取
     - `.xlab` 为生产环境定义，`.xlab.development` 为开发环境定义，`.xlab.sandbox` 为沙箱环境定义
 - `watch` 模式
     `xlab` 支持自动重启业务，开发中使用该功能可以减少大量手动重启业务的操作。
@@ -42,6 +51,7 @@ X-9lab 通用服务端
         ```
 - 除了静态资源，服务端业务需要放在项目根目录下的 `@server` 目录中
 - 支持业务自定义以下内容 (无特殊说明的都是存放在 @server 目录中)
+    - 环境预处理，存放于 `@env` 目录(可选)，`@env/index.js` 会在启动最早阶段(配置装载前)被执行，可用于设置 `process.env` 等
     - 配置项，存放于 `@config` 目录
         - 支持不同环境配置文件
             - 无中间词缀的 config 文件为生产环境配置文件
@@ -56,30 +66,56 @@ X-9lab 通用服务端
             - 按照目录结构生成 api
                 - 文件名是 `index` 的会被从 api 上先强行去掉
                 - 默认都是 `get` 请求
+        - 文件名即方法：文件名是 `get/post/put/delete/patch/head/options/all` 之一时，从 api 路径上去掉并作为该接口的请求方法
         - 支持以下形式定义接口
-            - 模块返回的是数组，则使用文件名做为方法名，并在 api 上去掉文件名
-            - 非数组则文件当作正常的 api 地址
             - 模块返回为函数的则直接绑定为接口处理函数
-            - 返回是对象则取对应的字段
-                - `method` 接口类型，如 `get` 或 `post`
+            - 返回是对象则取对应的字段（推荐配合 `defineApi` 获得类型推导）
+                - `method` 接口类型，如 `get` 或 `post`，不指定时由文件名约定决定
+                - `api` 自定义接口地址
                 - `middleware` 接口中间件
                 - `handler` 接口处理函数
+                - `ignoreApiNameCheck` 是否忽略 `/api` 前缀检测
         - 特殊文件夹
             - 以 `@` 开头的文件夹, 该文件夹不会被当成接口文件夹，但可在正常的接口中作为普通模块使用
             - 以 `$` 开头的文件夹, 该文件夹中的文件会成为后续接口的通用中间件，可以用于某类型业务的统一处理，如后台某些接口的额外身份处理。为了防止滥用，该文件夹不会递归查找，也就是说不支持子文件夹的组织形式。
                 - 整个 api 地址的每个父层都可以有独立的中间件文件，执行顺序会按照目录层级执行
                 - 中间件文件夹内的文件只会按照文件名做简单排序，因此请特别注意执行顺序是否符合自己的预期，或采用带序号的文件名
-    - 自定义逻辑，存放于 `custom` 目录，模块需要导出一个函数作为执行入口
-    - 中间件，存放于 `middleware` 目录
-    - 定时任务，存放于 `cron` 目录
-    - 静态资源，默认存放在项目根目录下的 `public` 目录中
-### 全局对象与函数
+    - 自定义逻辑，存放于 `custom` 目录，需在配置项 `custom` 数组中声明才会执行（`"模块名"` 或 `["模块名", 参数]`）。模块导出一个函数作为执行入口（视为 `setup`），或导出 `{ setup, ready, shutdown }` 生命周期钩子对象
+        - `setup` 服务装配前执行，接收 `custom` 配置中声明的参数
+        - `ready` 服务启动完成（listen 成功）后执行
+        - `shutdown` 服务退出前执行，可用于释放连接等资源
+    - 中间件，存放于 `middleware` 目录，通过配置项 `middlewares` 启用与排序
+        - 名称命中内置中间件时加载内置实现，否则加载业务 `middleware` 目录下的同名模块；模块需导出工厂函数 `(config) => koaMiddleware`
+        - 内置中间件：`bad-request`(异常返回兜底，总是启用)、`fresh-filter`(304 协商缓存)、`handle-pre-dir`(代理路径层级处理)、`request-filter`(请求过滤)、`service-mark`(X-Mark 服务标识)、`compress`(压缩)、`cors`(跨域)
+        ```js
+        "middlewares": {
+            "service-mark": true
+            , "cors": { "config": { "type": "sameroot" } }
+        }
+        ```
+    - 定时任务，存放于 `cron` 目录，由配置项 `enableCron` 开启，默认只在 master 进程执行（`enableWorkerCron` 可放开到 worker）
+        - 任务模块导出一个函数作为任务体，可另外导出 `getDelay()`(间隔，毫秒) 与 `enable()`(开关)
+        - 配置项 `crons` 可按文件名覆盖任务的间隔与开关，优先级高于模块自身导出
+    - 静态资源，默认存放在项目根目录下的 `public` 目录中（配置项 `root` 可改）
+### 模块 API
 
-#### 全局对象
-- `log` 全局日志对象
-- `masterLog` 只在 master 上输出的日志对象
+v2 起框架 API 不再挂载到 global，统一从包导入（v1 升级请看 [MIGRATION.md](./MIGRATION.md)）：
 
-#### 全局函数
+```js
+const {
+    boot, shutdown          // 生命周期
+    , app, getApp           // Koa 应用实例
+    , getSysConfig, setSysConfig
+    , requireMod, requireModel, requireService
+    , getLogger, masterLog
+    , getXlabEnv            // .xlab 环境数据
+    , defineApi             // 路由定义帮助函数
+} = require("@x-9lab/xlab");
+```
+
+- `getLogger(cat)` 获取分类日志实例
+- `masterLog(cat, type?, ...msg)` 只在 master 进程上输出的日志方法
+- `requireMod` / `getLogger` 等不依赖服务启动状态，共享库可独立引用；`getSysConfig` / `getXlabEnv` 的数据在启动后才填充，应在调用时读取
 - `getApp` 获取应用实例对象
     ```ts
     /**
@@ -113,7 +149,10 @@ X-9lab 通用服务端
     */
     function setSysConfig(conf: XLab.IConfig): void;
     ```
-- `requireModel` 全局获取 model 的方法
+- `getXlabEnv` 获取 `.xlab` 系列文件定义的环境数据
+- `boot` 启动服务，按固定阶段装配并监听；正常业务由 `xlab` 命令调用，无需手动执行
+- `shutdown` 优雅退出：停止定时任务 → 等待在途请求 → 执行 `shutdown` 钩子 → 退出进程；收到 `SIGTERM` / `SIGINT` 时自动触发
+- `requireModel` 获取 model 的方法
     该方法只是为获取 model 提供一个快捷方式，也可以通过正常的方式去 require
     - 存放路径 `business/@models`
     - 使用方式
@@ -121,7 +160,7 @@ X-9lab 通用服务端
         const { testModel } = requireModel("test");
         ```
     - 类型支持
-        由于 `requireModel` 是一个 `xlab` 的内置方法没有业务本身的 model 定义，因此需要业务方自行追加。出于管理方面的考虑，建议将所有的 model 定义放在一个文件中
+        由于 `requireModel` 是一个 `xlab` 的内置方法没有业务本身的 model 定义，因此需要业务方自行追加（`XLab` 类型命名空间仍为全局，declaration merging 方式与 v1 一致）。出于管理方面的考虑，建议将所有的 model 定义放在一个文件中
         ```ts
         declare global {
             namespace XLab {
@@ -133,7 +172,7 @@ X-9lab 通用服务端
         }
         export { }
         ```
-- `requireService` 全局获取 service 的方法
+- `requireService` 获取 service 的方法
     该方法只是为获取 service 提供一个快捷方式，也可以通过正常的方式去 require
     - 存放路径 `business/@services`
     - 使用方式
@@ -169,84 +208,64 @@ X-9lab 通用服务端
 |-|-|-|-|
 |name|`string`| package.json 中的 name 字段 |服务(应用)名称|
 |version|`string`|package.json 中的 version 字段|版本|
-|env|`string`|development|环境标识|
-|host|`string`| |业务绑定的域名|
+|env|`string`|DEVELOPMENT|环境标识(大写)，由启动环境决定，业务不应配置|
+|host|`string`| |业务绑定的域名，cors 中间件 `sameroot` 模式使用|
 |304|`boolean`| true |是否开启 304 协商缓存|
-|workers|`number`|0|Worker 数量|
-|biServer|`string`||业务服务器地址|
-|protocol|`string`|http|业务服务器协议|
-|debug|`boolean`|false|是否开启 debug 模式|
-|staticMaxage|`number`|1800000|静态文件缓存时间|
+|workers|`number`|0|Worker 数量，大于 0 时以 cluster 模式启动|
+|ip|`string`||服务绑定地址，也可通过 `IP=` 命令行参数指定|
+|timezone|`string`|Asia/Shanghai|时区|
+|debug|`boolean`|非生产环境为 true|是否开启 debug 模式|
+|staticMaxage|`number`|1800000|静态文件缓存时间(仅生产环境启用)|
 |staticHtmlFileMaxage|`number`|0|静态 html 文件缓存时间|
 |staticCros|`boolean`|false|是否允许静态资源跨域访问|
-|enableComboCache|`boolean`|true|是否开启 Combo 缓存|
 |enableCron|`boolean`|false|是否开启定时任务|
-|middleware|`Array<string | (string | Record<string, any>)[]>`|[]|开启的中间件列表。因不方便合并替换，v1.1.0 开始建议使用 `middlewares` 来配置 |
+|enableWorkerCron|`boolean`|false|是否允许 worker 上也执行定时任务|
 |middlewares|`Record<string, MiddlewareConfig>`|{}|开启的中间件列表 |
 ||MiddlewareConfig||`index` 用于定义中间件位置，不提供将使用配置对象中的默认顺序<br/> `name` 中间件名称，不提供将使用配置对象的键名<br/>`config` 中间件配置|
-|custom|`string[]`||自定模块配置|
-|strictSSL|`boolean`||是否启用严格 ssl|
-|apis|`Record<string, string>`|{}|页端注入的 api 设置|
-|hasLo|`boolean`||本地是否存在本地开发配置文件|
-|passExtApis|`boolean`||不处理业务 api|
-|allowCache|`boolean`||是否允许页端缓存|
+|custom|`(string | [string, any])[]`||自定模块配置，元组形式可传入参数|
+|mark|`string`|name 配置|服务标识，用于 service-mark 中间件|
+|apis|`Record<string, string>`|{}|页端注入的 api 设置，自动合并 `@config/@apis` 目录内容|
+|hasLo|`boolean`||本地是否存在本地开发配置文件，由框架自动设置|
+|passExtApis|`boolean`||不合并 `@config/@apis` 目录的 api 配置|
+|allowCache|`boolean`|true|是否允许页端缓存|
 |root|`string`|public|静态文件根目录|
-|port|`number`|5000|监听端口|
-|isMaster|`boolean`||是否是主进程|
-|clearLocalStorage|`boolean`||是否每次都强制清除 LocalStorage|
-|pathReplaceRegExp|`string`||处理代理过来多余的地址层级路径替换判断正则|
+|port|`number`|5000|监听端口，也可通过 `PORT=` 命令行参数指定|
+|isMaster|`boolean`||是否是主进程，由框架自动设置|
+|pathReplaceRegExp|`string`||handle-pre-dir 中间件处理代理多余地址层级的判断正则|
 |routeMobile|`string`||移动端入口文件地址(旧版逻辑)|
-|launchRouter|`Record<string, string>`||不同端入口地址设置, 由 `@x-drive/launch-detect` 提供支持|
-|cron|`{def?: number;}`|{"def": 60}|定时任务设置|
-|injection|`string[]`|[]|注入参数列表|
-|indexPageCacheTime|`number`||首页缓存时间|
-|staticResourceCacheTime|`number`||静态资源缓存时间|
+|cron|`{def?: number;}`|{"def": 60}|定时任务设置，`def` 为默认间隔(秒)|
+|crons|`Record<string, {delay?: number; enable?: boolean;}>`||按任务(文件名)的定时任务配置，`delay` 单位秒，优先级高于任务模块自身的 `getDelay()` / `enable()`|
+|shutdownTimeout|`number`|10000|优雅退出时等待在途请求/worker 结束的超时时间(毫秒)|
+|indexPageCacheTime|`number`||fresh-filter 中间件的首页缓存时间(毫秒)|
+|staticResourceCacheTime|`number`||fresh-filter 中间件的静态资源缓存时间(毫秒)|
+|biServer / protocol / strictSSL / internalServers / internalApis|||框架不读取的业务约定字段，供业务通过 `getSysConfig` 自取|
+
+> v2 起移除:`middleware`(数组形式，v1.1.0 已弃用)、`enableComboCache` 与 `launchRouter`(对应实现已不存在)。
 
-## 文件结构
+## 业务项目文件结构
 
 ```
-├── README.md
-├── business
-│   └── @services
-│   └── @models
-│   │  └── forumUser.js
-│   └── ...
-├── components
-│   ├── cache
-│   ├── common.js
-│   └── ...
-├── @config
-│   ├── config.dev.ts
-│   └── config.ts
-├── middleware
-├── cron
-├── public
-├── test
-├── route
-├── private
-│   └── log
-├── package.json
-├── config.js
-├── router.js
-└── server.js
+业务项目根目录
+├── package.json            # scripts 中调用 xlab 启动
+├── xlab.config.js          # 启动配置(watch / businessDir)，可选
+├── .xlab                   # 环境数据文件(.xlab.development / .xlab.sandbox)，不入库
+├── public                  # 静态资源(root 配置可改)
+└── @server                 # 服务端业务目录(businessDir 配置可改)
+    ├── @env                # 环境预处理，启动最早执行，可选
+    │   └── index.js
+    ├── @config             # 配置: config.js / config.dev.js / config.sand.js / config.lo.js
+    │   └── @apis           # 页端注入的 api 配置，可选
+    ├── business            # 约定路由目录，按目录结构生成 /api/...
+    │   ├── @models         # model，requireModel 读取
+    │   ├── @services       # service，requireService 读取
+    │   ├── $mws            # $ 前缀目录级中间件
+    │   └── ...
+    ├── middleware          # 业务中间件，middlewares 配置启用
+    ├── custom              # 自定义逻辑与生命周期钩子，custom 配置声明
+    └── cron                # 定时任务，enableCron 开启
 ```
 
-### 说明
-- ``business目录``：前端业务
-- ``@services目录``：业务services
-- ``@models目录``：存放model
-- ``components目录``： 存放当前项目组件
-- ``@config``：存放环境配置，不同环境在名称与文件后缀中间使用不同代号区分
-- ``middleware目录``：存放请求特殊处理模块，一般作为中间件
-- ``public目录``：存放前端资源文件
-- ``cron目录``：存放定时任务文件
-- ``test目录``：存放单元测试
-- ``route目录``：存放不同平台的路由配置
-- ``private目录``：存放业务 log ，或其他服务端相关的内容
-- ``package.json``：nodejs后端所需要的依赖描述文件，即npm的 [package.json](https://www.npmjs.org/doc/files/package.json.html) 文件
-- ``router.js``：路由模块
-- ``server.js``：服务器主模块
-- ``config.js``：配置处理模块
+完整可运行的示例见仓库中的 [example](./example) 目录。
 
 ## TODO
 

package/dist/@config/config.dev.js

@@ -2,10 +2,14 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = void 0;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
 const CONFIG = {
     "304": false,
     "workers": 0
 };
-var _default = CONFIG;
-exports.default = _default;
+const _default = CONFIG;

package/dist/@config/config.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = void 0;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
 const CONFIG = {
     "host": "",
     "304": true,
@@ -12,12 +17,10 @@ const CONFIG = {
     "debug": false,
     "staticMaxage": 1800000,
     "staticHtmlFileMaxage": 0,
-    "enableComboCache": true,
     "enableCron": false,
     "enableWorkerCron": false,
     "strictSSL": false,
     "root": "public",
     "timezone": "Asia/Shanghai"
 };
-var _default = CONFIG;
-exports.default = _default;
+const _default = CONFIG;

package/dist/@config/config.sand.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = void 0;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
 const CONFIG = {};
-var _default = CONFIG;
-exports.default = _default;
+const _default = CONFIG;

package/dist/bin/watch.js

@@ -1,11 +1,14 @@
 "use strict";
 const XConfig = require("../default-x-config").default;
-const { date  } = require("@x-drive/utils");
-const crossSpawn = require("cross-spawn");
-const colors = require("colors/safe");
+const { spawn } = require("child_process");
+const { date } = require("@x-drive/utils");
 const path = require("path");
 const fs = require("fs");
-/**输出内容名称 */ const X_LAB_STR = colors.bold(colors.cyan("\uD83D\uDEF8 XLab"));
+/**终端着色,替代对 colors 包的依赖 */ const colors = {
+    "cyanBold": (str)=>`\x1b[1m\x1b[36m${str}\x1b[0m`,
+    "green": (str)=>`\x1b[32m${str}\x1b[0m`
+};
+/**输出内容名称 */ const X_LAB_STR = colors.cyanBold("🛸 XLab");
 /**
  * 子进程对象
  * @type child_process.ChildProcess
@@ -33,7 +36,7 @@ const fs = require("fs");
     }
 }
 /**启动 */ function start() {
-    childProcess = crossSpawn("node", buildSpawnOptions(), {
+    childProcess = spawn(process.execPath, buildSpawnOptions(), {
         "stdio": "inherit"
     }).on("error", (err)=>{
         console.error(err);
@@ -41,8 +44,8 @@ const fs = require("fs");
         if (Number(code) !== 0) {
             const err = new Error(`子进程退出, Code: ${code}`);
             err.code = code;
-            // TODO: 自动拉起来？
             console.error(err);
+            log("业务进程异常退出, watch 保持运行, 修复代码保存后将自动重启");
         }
     }).once("exit", ()=>{
         childProcess.removeAllListeners();
@@ -90,7 +93,7 @@ const fs = require("fs");
         } else {
             if (initing) {
                 initing = false;
-                log("Watch \u6A21\u5F0F\u542F\u52A8\n");
+                log("Watch 模式启动\n");
                 setTimeout(()=>{
                     inited = true;
                 }, wait);
@@ -118,29 +121,46 @@ const fs = require("fs");
                 for(let i = 0; i < config.paths.length; i++){
                     fs.statSync(config.paths[i]);
                     stats += 1;
+                    ;
                 }
             } catch (e) {
                 log(e);
             }
             if (stats > 0) {
-                // 传递主进程 SIGTERM
-                process.on("SIGTERM", ()=>{
-                    if (childProcess && childProcess.connected) {
-                        childProcess.kill("SIGTERM");
-                    }
-                    process.exit(0);
+                // 传递退出信号: 通知业务进程优雅退出并等待其结束后自身再退出
+                // 注意不能用 childProcess.connected 判断(无 IPC 通道时恒为 false)
+                [
+                    "SIGINT",
+                    "SIGTERM"
+                ].forEach((signal)=>{
+                    process.on(signal, ()=>{
+                        if (!childProcess) {
+                            process.exit(0);
+                        }
+                        const child = childProcess;
+                        // 兜底强杀, 时长需覆盖业务的优雅退出(shutdownTimeout 默认 10s)
+                        const timer = setTimeout(()=>{
+                            child.kill("SIGKILL");
+                            process.exit(0);
+                        }, 30000);
+                        child.once("exit", ()=>{
+                            clearTimeout(timer);
+                            process.exit(0);
+                        });
+                        child.kill("SIGTERM");
+                    });
                 });
                 watch(chokidar, config, wait);
                 start();
             } else {
-                log("\u4E1A\u52A1\u81EA\u5B9A\u4E49\u76EE\u5F55\u4E0D\u5B58\u5728, watch \u6A21\u5F0F\u542F\u52A8\u5931\u8D25");
+                log("业务自定义目录不存在, watch 模式启动失败");
             }
             stats = null;
         } else {
-            log("\u8BF7\u5C06 chokidar \u5B89\u88C5\u5230\u5F00\u53D1\u4F9D\u8D56\u4E2D\u4EE5\u542F\u7528 watch \u6A21\u5F0F");
+            log("请将 chokidar 安装到开发依赖中以启用 watch 模式");
         }
     } else {
-        log("\u914D\u7F6E\u4E0D\u5B58\u5728\u6216 watch.enable \u4E3A false, watch \u6A21\u5F0F\u542F\u52A8\u5931\u8D25\n", config);
+        log("配置不存在或 watch.enable 为 false, watch 模式启动失败\n", config);
     }
 }
 module.exports = setup;

package/dist/cluster.js

@@ -2,53 +2,79 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = void 0;
-var clusterCom = _interopRequireWildcard(require("./components/cluster"));
-var _config = require("./config");
-var _cluster = _interopRequireDefault(require("cluster"));
-var _server = _interopRequireDefault(require("./server"));
-var _os = _interopRequireDefault(require("os"));
-function _interopRequireDefault(obj) {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get default () {
+        return _default;
+    },
+    get shutdownWorkers () {
+        return shutdownWorkers;
+    }
+});
+const _cluster = /*#__PURE__*/ _interop_require_wildcard(require("./components/cluster"));
+const _log = require("./components/log");
+const _config = require("./config");
+const _cluster1 = /*#__PURE__*/ _interop_require_default(require("cluster"));
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _interopRequireWildcard(obj) {
-    if (obj && obj.__esModule) {
-        return obj;
-    } else {
-        var newObj = {};
-        if (obj != null) {
-            for(var key in obj){
-                if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
-                    if (desc.get || desc.set) {
-                        Object.defineProperty(newObj, key, desc);
-                    } else {
-                        newObj[key] = obj[key];
-                    }
-                }
-            }
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) return obj;
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") return {
+        default: obj
+    };
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) return cache.get(obj);
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+            else newObj[key] = obj[key];
         }
-        newObj.default = obj;
-        return newObj;
     }
+    newObj.default = obj;
+    if (cache) cache.set(obj, newObj);
+    return newObj;
 }
-const logger = log.getLogger("cluster");
+const logger = _log.globalLog.getLogger("cluster");
 const CPUnum = _os.default.cpus().length;
-const config = (0, _config).get();
+/**判定为快速失败的存活时间窗口(毫秒) */ const QUICK_DEATH_MS = 10 * 1000;
+/**连续快速失败达到该次数后停止自动拉起 */ const MAX_QUICK_DEATHS = 5;
+/**worker 启动时间记录 */ const FORK_AT = new Map();
+/**连续快速失败计数 */ var quickDeaths = 0;
+/**是否正在退出流程中 */ var stopping = false;
 /**
  * 消息处理函数
  * @param  msg 消息配置对象
  */ function masterMessageHandler(msg) {
     if (msg && msg.cmd) {
-        let handler = clusterCom.get(msg.cmd);
+        let handler = _cluster.get(msg.cmd);
         if (handler) {
             let args = msg.args || [];
             args.push(msg.returnData);
             let re = handler.apply(handler, args);
             if (msg.wid) {
-                let worker = _cluster.default.workers[msg.wid];
+                let worker = _cluster1.default.workers[msg.wid];
                 if (worker) {
                     worker.send({
                         "cmd": msg.cmd,
@@ -62,7 +88,18 @@ const config = (0, _config).get();
         }
     }
 }
-/**尝试以 cluster 模式启动服务 */ function start() {
+/**fork 一个 worker 并记录启动时间 */ function forkWorker() {
+    const worker = _cluster1.default.fork();
+    FORK_AT.set(worker.id, Date.now());
+}
+/**
+ * 启动服务监听
+
+ * master 且配置了 workers 时 fork 集群, 否则当前进程直接 listen
+ * @param app Koa 实例
+ * @return    直接监听时返回 http.Server, master fork 模式下无返回
+ */ function start(app) {
+    const config = (0, _config.get)();
     var server;
     var serverListenConf = {
         "port": config.port
@@ -75,26 +112,66 @@ const config = (0, _config).get();
             // 小于使用数则取一半
             let num = CPUnum < config.workers ? Math.ceil(CPUnum / 2) : config.workers;
             for(var i = 0; i < num; i++){
-                _cluster.default.fork();
+                forkWorker();
             }
-            // if(!config.isProd){
-            _cluster.default.on("listening", function(worker, address) {
-                masterLog("cluster", "info", "	Worker ", worker.process.pid, " online, Address: ", address.address, ":", address.port);
+            _cluster1.default.on("listening", function(worker, address) {
+                logger.info("\tWorker ", worker.process.pid, " online, Address: ", address.address, ":", address.port);
             });
-            _cluster.default.on("message", masterMessageHandler);
-            // }
-            _cluster.default.on("exit", function(worker) {
-                logger.warn("Worker " + worker.process.pid + " is dead!");
-                _cluster.default.fork();
+            _cluster1.default.on("message", masterMessageHandler);
+            _cluster1.default.on("exit", function(worker) {
+                const bornAt = FORK_AT.get(worker.id);
+                FORK_AT.delete(worker.id);
+                if (stopping) {
+                    return;
+                }
+                const uptime = Date.now() - (bornAt || 0);
+                if (bornAt && uptime < QUICK_DEATH_MS) {
+                    quickDeaths += 1;
+                } else {
+                    quickDeaths = 0;
+                }
+                if (quickDeaths >= MAX_QUICK_DEATHS) {
+                    logger.error(`Worker ${worker.process.pid} is dead! 连续 ${quickDeaths} 次快速退出, 停止自动拉起, 请排查业务异常`);
+                    return;
+                }
+                logger.warn(`Worker ${worker.process.pid} is dead! Reforking.`);
+                forkWorker();
             });
         } else {
-            server = _server.default.listen(serverListenConf);
+            server = app.listen(serverListenConf);
         }
-        masterLog("cluster", "info", "[%s] online,listening on %s port %d", config.env, config.ip || "localhost", config.port);
+        logger.info("[%s] online,listening on %s port %d", config.env, config.ip || "localhost", config.port);
     } else {
-        server = _server.default.listen(serverListenConf);
+        server = app.listen(serverListenConf);
     }
     return server;
 }
-var _default = start;
-exports.default = _default;
+const _default = start;
+/**
+ * 通知全部 worker 退出并等待其结束
+ * @param timeout 等待超时(毫秒), 超时后不再等待
+ */ function shutdownWorkers(timeout = 10 * 1000) {
+    stopping = true;
+    return new Promise(function(resolve) {
+        const workers = Object.values(_cluster1.default.workers || {}).filter(Boolean);
+        if (!workers.length) {
+            resolve();
+            return;
+        }
+        var alive = workers.length;
+        const timer = setTimeout(function() {
+            logger.warn(`等待 worker 退出超时(${timeout}ms)`);
+            resolve();
+        }, timeout);
+        workers.forEach(function(worker) {
+            worker.once("exit", function() {
+                alive -= 1;
+                if (alive === 0) {
+                    clearTimeout(timer);
+                    resolve();
+                }
+            });
+            worker.process.kill("SIGTERM");
+        });
+    });
+}