utiller 1.0.23

package/lib/pooller/index.js

@@ -0,0 +1,1249 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classPrivateFieldGet2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldGet"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _index2 = require("../index.js");
+
+var _configer = require("configer");
+
+var _exceptioner = _interopRequireDefault(require("../exceptioner"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+var _run = /*#__PURE__*/new WeakMap();
+
+/**
+*
+Pooller 有以下特點:
+1.task可以設定timeout
+2.queue滿了的可以設定task interval
+3.如果是runByEachTask length, queue裡面沒有task時，可以設定sleeptime, 以及Sleepcounts
+4.task 可以cancelled by hash
+5.runByParams,runByTimes,runInInfinite,runByEachTask
+6.可以設定taskFailHandler, 這樣遇到錯誤就不會停掉poollers
+*
+*/
+var InfinitePool = /*#__PURE__*/function () {
+  /** 用來處理Task的延遲,假設要偷網頁東西, 不能太頻繁, 要偽裝成手動只能透過這方式, 如果是multi thread, 延遲是針對worker滿載後,再加進去的那一個 */
+
+  /** 用來處理每一個task的timeout, 避免task處理太久卡在Queue裡面 */
+
+  /** 裡面放 {high:[], low:[], medium }*/
+
+  /** 裡面放準備要執行的Task, 這邊的task就沒辦法remove了 */
+
+  /** 目前queue機制是while(isQueuePolling)  沒任務就睡一下, 有任務就做事情, 發現task有延遲, 就要注意是不是taskInterval*/
+
+  /** 為了刪除未執行的task, 但只限於runByTask, 因為下一個run之後, hash就改變了    */
+
+  /** 為了刪除執行完的promise */
+  function InfinitePool() {
+    var _this = this;
+
+    var maxWorkers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _configer.configer.POOLLER_WORKER_DEFAULT;
+    var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _index2.utiller.getRandomValue(0, 100000000000);
+    (0, _classCallCheck2["default"])(this, InfinitePool);
+    (0, _defineProperty2["default"])(this, "state", _configer.configer.POOLLER_STATE.RUN_BY_EACH_TASK);
+    (0, _defineProperty2["default"])(this, "enableOfTaskSleepByInterval", _configer.configer.POOLLER_ENABLE_TASK_SLEEP_BY_INTERVAL);
+    (0, _defineProperty2["default"])(this, "taskSleepInterval", _configer.configer.POOLLER_TASK_OF_INTERVAL_DEFAULT);
+    (0, _defineProperty2["default"])(this, "enableOfTaskTimeout", _configer.configer.POOLLER_ENABLE_TIMEOUT);
+    (0, _defineProperty2["default"])(this, "timeOfTaskTimeout", _configer.configer.POOLLER_TASK_TIMEOUT_DEFAULT);
+    (0, _defineProperty2["default"])(this, "maxWorker", void 0);
+    (0, _defineProperty2["default"])(this, "ignoreFirstRun", false);
+    (0, _defineProperty2["default"])(this, "paramQueue", []);
+    (0, _defineProperty2["default"])(this, "taskQueue", {});
+    (0, _defineProperty2["default"])(this, "executingTaskQueue", []);
+    (0, _defineProperty2["default"])(this, "isQueuePolling", false);
+    (0, _defineProperty2["default"])(this, "dispatchers", []);
+    (0, _defineProperty2["default"])(this, "initialTaskKickOff", false);
+    (0, _defineProperty2["default"])(this, "mHashNTaskMap", {});
+    (0, _defineProperty2["default"])(this, "mHashNPromiseMap", {});
+    (0, _defineProperty2["default"])(this, "hashCallbackMapOfWaiting4Result", {});
+    (0, _defineProperty2["default"])(this, "poolId", "");
+    (0, _defineProperty2["default"])(this, "setPoolId", function () {
+      var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _this.poolId;
+      _this.poolId = id;
+    });
+    (0, _defineProperty2["default"])(this, "getPoolId", function () {
+      return _this.poolId;
+    });
+    (0, _defineProperty2["default"])(this, "stopInBackground", /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      return _regenerator["default"].wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _this.isQueuePolling = false;
+
+            case 1:
+              if (!(_lodash["default"].size(_this.executingTaskQueue) > 0)) {
+                _context.next = 6;
+                break;
+              }
+
+              _context.next = 4;
+              return _index2.utiller.syncDelay(1000);
+
+            case 4:
+              _context.next = 1;
+              break;
+
+            case 6:
+              return _context.abrupt("return", true);
+
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    })));
+    (0, _defineProperty2["default"])(this, "isRunning", function () {
+      return _this.isQueuePolling;
+    });
+    (0, _defineProperty2["default"])(this, "getTaskQueueCount", function () {
+      var size = 0;
+      if (_this.state === _configer.configer.POOLLER_STATE.RUN_BY_PARAMS) return _this.paramQueue.length;
+
+      var _iterator = _createForOfIteratorHelper(_configer.configer.POOLLER_PRIORITY),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var prior = _step.value;
+          size += _this.taskQueue[prior].length;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      return size;
+    });
+    (0, _defineProperty2["default"])(this, "add", function (task) {
+      var priority = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "low";
+
+      if (typeof task === "function") {
+        if (_configer.configer.POOLLER_PRIORITY.indexOf(priority) < 0) {
+          throw new _exceptioner["default"](4001, "priority can't be ".concat(priority));
+        }
+
+        var hash = _index2.utiller.getRandomHash();
+
+        var taskInfo = {
+          task: task,
+          hash: hash
+        };
+
+        _this.appendHashTaskMap(taskInfo);
+
+        _this.taskQueue[priority].push(taskInfo);
+
+        return hash;
+      } else {
+        throw new _exceptioner["default"](4002, "task can't be ".concat((0, _typeof2["default"])(task)));
+      }
+    });
+    (0, _defineProperty2["default"])(this, "taskWrapper", function (task, hash) {
+      return function () {
+        var self = _this;
+        var timeoutHash = "";
+        var taskResult;
+        var taskError;
+        var param = self.paramQueue.shift();
+        var taskResolved = true;
+        /** 用來判斷task 有沒有走到 catch裡面, 不然resolve了但return undefined, task會不知所措 */
+
+        return new Promise(function (resolve, reject) {
+          if (self.enableOfTaskTimeout) {
+            timeoutHash = setTimeout(function () {
+              try {
+                throw new _exceptioner["default"](4010, self.getPoollerLogFormat("TASK HASH:".concat(hash, " IS TIMEOUT ").concat(self.timeOfTaskTimeout, "} ms ").concat(param ? ",PARAMS IS ".concat(JSON.stringify(param)) : "")));
+              } catch (error) {
+                reject(error);
+              }
+            }, self.timeOfTaskTimeout);
+          }
+          /** 真正的任務是從這裡開始 */
+
+
+          console.log(self.getPoollerLogFormat("task executing"));
+          task(param).then(function (result) {
+            // console.log(self.getPoollerLogFormat('task get result'));
+            taskResult = result;
+          })["catch"](function (error) {
+            // console.error(self.getPoollerLogFormat('inner error'), error);
+            taskError = error;
+            taskResolved = false;
+          })["finally"](function () {
+            clearTimeout(timeoutHash);
+            /** 要記得 resolve, reject 在這裡代表的是放在executingQueue裡面的promise, reject,resolve其中一個必須觸發, executingQueue才不會堵塞
+             ** 而任務需要的task是透過 removeResolveOrRejectPromiseByHash() */
+            // console.info(self.getPoollerLogFormat(self.getPoollerLogFormat('inner finally')));
+
+            resolve("".concat(hash, " done"));
+          });
+        })["catch"](function (error) {
+          // console.error(self.getPoollerLogFormat(self.getPoollerLogFormat('outer error')), error);
+          taskResolved = false;
+          taskError = error;
+        })["finally"](function () {
+          // console.info(self.getPoollerLogFormat(self.getPoollerLogFormat('outer finally')));
+          self.removeResolveOrRejectPromiseByHash(hash, {
+            taskResolved: taskResolved,
+            resolve: taskResult,
+            reject: taskError
+          });
+        });
+      };
+    });
+    (0, _defineProperty2["default"])(this, "adds", function (tasks) {
+      var priority = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "low";
+      var hashes = [];
+
+      if (_lodash["default"].isArray(tasks)) {
+        var _iterator2 = _createForOfIteratorHelper(tasks),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var task = _step2.value;
+            hashes.push(_this.add(task, priority));
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      } else {
+        throw new _exceptioner["default"](4003, "should be async function array, not ".concat((0, _typeof2["default"])(tasks)));
+      }
+
+      return hashes;
+    });
+    (0, _defineProperty2["default"])(this, "removeTaskMapByHash", function (hash) {
+      delete _this.mHashNTaskMap[hash];
+    });
+    (0, _defineProperty2["default"])(this, "beforeRun", function () {
+      _this.isQueuePolling = true;
+      /** 有點多餘的設計, 本來是想要當沒有task時, 有個house-keeping的設計, 但發現只要在任務加入時, 觸發runByEachTask即可
+      this.currentSleepCounts = 0;
+      */
+    });
+    (0, _defineProperty2["default"])(this, "afterRun", function () {
+      _this.clearCache();
+    });
+    (0, _defineProperty2["default"])(this, "runInInfinite", /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var task,
+          interval,
+          _args2 = arguments;
+      return _regenerator["default"].wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              task = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : [];
+              interval = _args2.length > 1 ? _args2[1] : undefined;
+
+              _this.beforeRun();
+
+              if (!_lodash["default"].isFunction(task)) {
+                _context2.next = 7;
+                break;
+              }
+
+              _this.add(task);
+
+              _context2.next = 12;
+              break;
+
+            case 7:
+              if (!_lodash["default"].isArray(task)) {
+                _context2.next = 11;
+                break;
+              }
+
+              _this.adds(task);
+
+              _context2.next = 12;
+              break;
+
+            case 11:
+              throw new _exceptioner["default"](4006, "type of task is ===> ".concat((0, _typeof2["default"])(task)));
+
+            case 12:
+              _this.enableTaskSleepInterval(!!interval, interval);
+
+              _this.setState(_configer.configer.POOLLER_STATE.RUN_INFINITE);
+
+            case 14:
+              if (!_this.isRunning()) {
+                _context2.next = 19;
+                break;
+              }
+
+              _context2.next = 17;
+              return (0, _classPrivateFieldGet2["default"])(_this, _run).call(_this);
+
+            case 17:
+              _context2.next = 14;
+              break;
+
+            case 19:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    })));
+    (0, _defineProperty2["default"])(this, "runByParams", /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+      var params,
+          task,
+          _iterator3,
+          _step3,
+          param,
+          _args3 = arguments;
+
+      return _regenerator["default"].wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              params = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : [];
+              task = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : undefined;
+
+              if (_lodash["default"].isFunction(task)) {
+                _context3.next = 4;
+                break;
+              }
+
+              throw new _exceptioner["default"](4006, "runByParams error, typeof task can't be ".concat((0, _typeof2["default"])(task)));
+
+            case 4:
+              if (_lodash["default"].isArray(params)) {
+                _context3.next = 6;
+                break;
+              }
+
+              throw new _exceptioner["default"](4006, "runByParams error, typeof params can't be ".concat((0, _typeof2["default"])(params)));
+
+            case 6:
+              _iterator3 = _createForOfIteratorHelper(params);
+
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  param = _step3.value;
+
+                  _this.paramQueue.push(param);
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+
+              _this.add(task);
+
+              _this.setState(_configer.configer.POOLLER_STATE.RUN_BY_PARAMS);
+
+              _this.beforeRun();
+
+            case 11:
+              if (!(_this.isRunning() && !_lodash["default"].isEmpty(_this.paramQueue))) {
+                _context3.next = 16;
+                break;
+              }
+
+              _context3.next = 14;
+              return (0, _classPrivateFieldGet2["default"])(_this, _run).call(_this);
+
+            case 14:
+              _context3.next = 11;
+              break;
+
+            case 16:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    })));
+    (0, _defineProperty2["default"])(this, "runByEachTask", /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+      var tasks,
+          _args4 = arguments;
+      return _regenerator["default"].wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              tasks = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : [];
+              _this.id = _index2.utiller.getRandomHash(3);
+
+              _this.beforeRun();
+
+              _this.adds(tasks);
+
+              _this.setState(_configer.configer.POOLLER_STATE.RUN_BY_EACH_TASK);
+
+            case 5:
+              if (!_this.isRunning()) {
+                _context4.next = 11;
+                break;
+              }
+
+              if (_this.getTaskQueueCount() <= 0) {
+                _this.terminate();
+              }
+
+              _context4.next = 9;
+              return (0, _classPrivateFieldGet2["default"])(_this, _run).call(_this, _this.id);
+
+            case 9:
+              _context4.next = 5;
+              break;
+
+            case 11:
+              _this.terminate();
+
+            case 12:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    })));
+    (0, _defineProperty2["default"])(this, "runByTimes", /*#__PURE__*/function () {
+      var _ref5 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(times) {
+        var tasks,
+            index,
+            _args5 = arguments;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                tasks = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : [];
+
+                _this.adds(tasks);
+
+                _this.beforeRun();
+
+                _this.setState(_configer.configer.POOLLER_STATE.RUN_BY_TIMES);
+
+                index = 0;
+
+              case 5:
+                if (!(index < times)) {
+                  _context5.next = 11;
+                  break;
+                }
+
+                _context5.next = 8;
+                return (0, _classPrivateFieldGet2["default"])(_this, _run).call(_this);
+
+              case 8:
+                index++;
+                _context5.next = 5;
+                break;
+
+              case 11:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5);
+      }));
+
+      return function (_x) {
+        return _ref5.apply(this, arguments);
+      };
+    }());
+    (0, _defineProperty2["default"])(this, "runInBackGround", function (_asyncfunc) {
+      for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        params[_key - 1] = arguments[_key];
+      }
+
+      if (!(typeof _asyncfunc === "function")) {
+        throw new _exceptioner["default"](4002, "_asyncfunc can't be ".concat((0, _typeof2["default"])(_asyncfunc)));
+      }
+
+      return setTimeout( /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                _context6.prev = 0;
+                _context6.next = 3;
+                return _asyncfunc.apply(void 0, params);
+
+              case 3:
+                _context6.next = 8;
+                break;
+
+              case 5:
+                _context6.prev = 5;
+                _context6.t0 = _context6["catch"](0);
+                throw new _exceptioner["default"](4009, {
+                  message: "".concat(_this.getPoollerLogFormat(""))
+                }, _context6.t0);
+
+              case 8:
+                _context6.prev = 8;
+
+                _this.terminate();
+
+                _index2.utiller.appendInfo("".concat(_this.getPoollerLogFormat("background gc after terminated"), " "));
+
+                return _context6.finish(8);
+
+              case 12:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, null, [[0, 5, 8, 12]]);
+      })), 1);
+    });
+    (0, _defineProperty2["default"])(this, "getPoollerLogFormat", function (msg) {
+      return "POOLLER ID: ".concat(_this.getPoolId()).concat(_lodash["default"].isEmpty(msg) ? "" : " , ").concat(msg);
+    });
+    (0, _defineProperty2["default"])(this, "setTaskFailHandler", function (listener) {
+      _this.taskFailHandler = listener;
+    });
+    (0, _defineProperty2["default"])(this, "touchTaskDispatcher", function () {
+      var dispatcher = setTimeout( /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                _context7.next = 2;
+                return _this.syncTaskDispatcher();
+
+              case 2:
+                _this.dispatchers.splice(_this.dispatchers.indexOf(dispatcher), 1);
+
+              case 3:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7);
+      })), 0);
+
+      _this.dispatchers.push(dispatcher);
+    });
+    (0, _defineProperty2["default"])(this, "showState", function () {
+      _index2.utiller.appendInfo(_this.getPoollerLogFormat("workerCount: ".concat(_this.maxWorker)));
+
+      _index2.utiller.appendInfo(_this.getPoollerLogFormat("taskQueue: ".concat(_this.getTaskQueueCount())));
+
+      _index2.utiller.appendInfo(_this.getPoollerLogFormat("executingQueue: ".concat(_this.executingTaskQueue.length)));
+
+      _index2.utiller.appendInfo(_this.getPoollerLogFormat("mHashNTaskMap: ".concat(_lodash["default"].size(_this.mHashNTaskMap))));
+
+      _index2.utiller.appendInfo(_this.getPoollerLogFormat("mHashNPromiseMap: ".concat(_lodash["default"].size(_this.mHashNPromiseMap))));
+    });
+
+    _classPrivateFieldInitSpec(this, _run, {
+      writable: true,
+      value: function () {
+        var _value = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+          return _regenerator["default"].wrap(function _callee8$(_context8) {
+            while (1) {
+              switch (_context8.prev = _context8.next) {
+                case 0:
+                  _context8.next = 2;
+                  return _this.syncTaskDispatcher();
+
+                case 2:
+                  if (!(_this.executingTaskQueue.length >= _this.maxWorker)) {
+                    _context8.next = 7;
+                    break;
+                  }
+
+                  _context8.next = 5;
+                  return Promise.race(_this.executingTaskQueue.map(function (asyncTask) {
+                    return asyncTask();
+                  }));
+
+                case 5:
+                  _context8.next = 10;
+                  break;
+
+                case 7:
+                  if (!(_this.getTaskQueueCount() === 0 && _this.executingTaskQueue.length > 0)) {
+                    _context8.next = 10;
+                    break;
+                  }
+
+                  _context8.next = 10;
+                  return Promise.race(_this.executingTaskQueue.map(function (asyncTask) {
+                    return asyncTask();
+                  }));
+
+                case 10:
+                  if (_this.executingTaskQueue.length > _this.maxWorker) {
+                    _index2.utiller.appendError("\u4E00\u5B9A\u662F\u6539\u58DE\u4E86\uFF01\uFF01\uFF01\uFF01 ".concat(_this.getPoollerLogFormat("executing queue ".concat(_this.executingTaskQueue.length, " !!"))));
+                  }
+                  /** 只要完成run 就要把sleepTimeCount歸零
+                   * this.currentSleepCounts = 0;
+                   */
+
+
+                case 11:
+                case "end":
+                  return _context8.stop();
+              }
+            }
+          }, _callee8);
+        }));
+
+        function value() {
+          return _value.apply(this, arguments);
+        }
+
+        return value;
+      }()
+    });
+
+    (0, _defineProperty2["default"])(this, "getTaskInfoDependOnPriority", function () {
+      var _iterator4 = _createForOfIteratorHelper(_configer.configer.POOLLER_PRIORITY),
+          _step4;
+
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var prior = _step4.value;
+
+          if (_this.taskQueue[prior].length > 0) {
+            switch (_this.state) {
+              case _configer.configer.POOLLER_STATE.RUN_BY_EACH_TASK:
+                return _this.taskQueue[prior].shift();
+
+              case _configer.configer.POOLLER_STATE.RUN_BY_PARAMS:
+              case _configer.configer.POOLLER_STATE.RUN_BY_TIMES:
+              case _configer.configer.POOLLER_STATE.RUN_INFINITE:
+                var taskInfo = _this.taskQueue[prior].shift();
+
+                _this.add(taskInfo.task);
+
+                return taskInfo;
+
+              default:
+                throw new _exceptioner["default"](4005, "this.state ==> ".concat(_this.state));
+            }
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+
+      if (!_lodash["default"].isEqual(_this.state, _configer.configer.POOLLER_STATE.RUN_BY_EACH_TASK)) throw new _exceptioner["default"](4007);
+    });
+    (0, _defineProperty2["default"])(this, "removeResolveOrRejectPromiseByHash", function (hash, result) {
+      var callback = _this.hashCallbackMapOfWaiting4Result[hash];
+
+      if (callback !== undefined) {
+        callback(result);
+      }
+
+      delete _this.hashCallbackMapOfWaiting4Result[hash];
+
+      _this.removePromiseFromExecutingQueue(hash);
+
+      _this.removeCompletedPromiseFromMapByHash(hash);
+    });
+    (0, _defineProperty2["default"])(this, "removeCompletedPromiseFromMapByHash", function (hash) {
+      delete _this.mHashNPromiseMap[hash];
+    });
+    this.maxWorker = maxWorkers;
+    this.setPoolId(_lodash["default"].toString(name));
+
+    var _iterator5 = _createForOfIteratorHelper(_configer.configer.POOLLER_PRIORITY),
+        _step5;
+
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var prior = _step5.value;
+        this.taskQueue[prior] = [];
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+  }
+
+  (0, _createClass2["default"])(InfinitePool, [{
+    key: "enableQueueTerminateBySleepCount",
+    value:
+    /**
+     * @deprecated there's no sleep mechanism
+     */
+    function enableQueueTerminateBySleepCount() {
+      var enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var interval = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _configer.configer.POOLLER_QUEUE_TIME_OF_SLEEP_INTERVAL_DEFAULT;
+      var times = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _configer.configer.POOLLER_MAX_SLEEP_COUNTS_DEFAULT;
+      this.enableOfQueueTerminateSleepCount = enable;
+      this.queueMaxSleepCounts = times;
+      this.intervalOfQueueSleep = interval;
+    }
+  }, {
+    key: "clearCache",
+    value: function clearCache() {
+      this.executingTaskQueue.length = 0;
+      this.mHashNTaskMap = {};
+      this.taskQueue = {};
+    }
+  }, {
+    key: "terminate",
+    value: function terminate() {
+      this.isQueuePolling = false;
+    }
+    /** return true if task completed, after 15 secs, force leave */
+
+  }, {
+    key: "setWorker",
+    value: function setWorker(counts) {
+      this.maxWorker = counts;
+    }
+  }, {
+    key: "cleanTaskInterval",
+    value: function cleanTaskInterval() {
+      this.taskSleepInterval = {
+        min: 0,
+        max: 0
+      };
+    }
+    /**
+     * interval:{min: 800, max: 1000}
+     * */
+
+  }, {
+    key: "enableTaskSleepInterval",
+    value: function enableTaskSleepInterval() {
+      var enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var interval = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _configer.configer.POOLLER_TASK_OF_INTERVAL_DEFAULT;
+      this.enableOfTaskSleepByInterval = enable;
+
+      if (_lodash["default"].isNumber(interval)) {
+        interval = {
+          min: interval,
+          max: interval
+        };
+      }
+
+      this.taskSleepInterval = interval;
+    }
+  }, {
+    key: "enableTaskTimeout",
+    value: function enableTaskTimeout() {
+      var enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var millionSec = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _configer.configer.POOLLER_TASK_TIMEOUT_DEFAULT;
+      this.enableOfTaskTimeout = enable;
+      this.timeOfTaskTimeout = millionSec;
+    }
+  }, {
+    key: "addTaskAndWait4Result",
+    value: function () {
+      var _addTaskAndWait4Result = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(asyncTask) {
+        var _this2 = this;
+
+        var priority,
+            taskName,
+            _args9 = arguments;
+        return _regenerator["default"].wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                priority = _args9.length > 1 && _args9[1] !== undefined ? _args9[1] : "low";
+                taskName = _args9.length > 2 && _args9[2] !== undefined ? _args9[2] : "noName";
+                this.trigger();
+                return _context9.abrupt("return", new Promise(function (resolve, reject) {
+                  var callback = function callback(result) {
+                    if (result.taskResolved) {
+                      resolve(result.resolve);
+                    } else {
+                      reject(result.reject);
+                    }
+                  };
+
+                  var hash = _this2.add(asyncTask, priority);
+
+                  _this2.registerHash4Result(hash, callback);
+                }));
+
+              case 4:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this);
+      }));
+
+      function addTaskAndWait4Result(_x2) {
+        return _addTaskAndWait4Result.apply(this, arguments);
+      }
+
+      return addTaskAndWait4Result;
+    }()
+  }, {
+    key: "registerHash4Result",
+    value: function registerHash4Result(hash, callback) {
+      this.hashCallbackMapOfWaiting4Result[hash] = callback;
+    }
+  }, {
+    key: "appendHashTaskMap",
+    value: function appendHashTaskMap(taskInfo) {
+      this.mHashNTaskMap[taskInfo.hash] = taskInfo;
+    }
+  }, {
+    key: "getTaskInfoByHash",
+    value: function getTaskInfoByHash(hash) {
+      return this.mHashNTaskMap[hash];
+    }
+    /**
+     * remove task in queue by its hash, hash was created when add to queue
+     *
+     * method will return true when succeed delete
+     *
+     * 放到executing queue, 就沒辦法刪除了
+     *
+     **/
+
+  }, {
+    key: "remove",
+    value: function remove(hash) {
+      var taskInfo = this.getTaskInfoByHash(hash);
+
+      if (taskInfo) {
+        var _iterator6 = _createForOfIteratorHelper(_configer.configer.POOLLER_PRIORITY),
+            _step6;
+
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var prior = _step6.value;
+
+            var _index = _lodash["default"].indexOf(this.taskQueue[prior], taskInfo);
+
+            if (_index > 0) {
+              this.taskQueue[prior].splice(_index, 1);
+              this.removeTaskMapByHash(hash);
+              return true;
+            }
+          }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+
+        return false;
+      } else {
+        throw new _exceptioner["default"](4004, hash);
+      }
+    }
+  }, {
+    key: "runByEachTaskInBackGround",
+    value: function runByEachTaskInBackGround() {
+      if (this.atomicBgInstance !== undefined) ;
+      clearTimeout(this.atomicBgInstance);
+      this.atomicBgInstance = this.runInBackGround(this.runByEachTask);
+      return this;
+    }
+  }, {
+    key: "setState",
+    value:
+    /** run by how many task in queue, FIFO, if task completed, pool with intervalOfQueueSleep for a while
+     * ,after this.queueMaxSleepCounts, pooller would closed */
+    function setState(_state) {
+      this.state = _state;
+    }
+  }, {
+    key: "firstTaskDone",
+    value: function firstTaskDone() {
+      if (!this.initialTaskKickOff) {
+        this.initialTaskKickOff = true;
+        return false;
+      }
+
+      return this.initialTaskKickOff;
+    }
+    /** 如果設定interval, 第一個run不要執行的話,就設定true */
+
+  }, {
+    key: "setIgnoreFirstRun",
+    value: function setIgnoreFirstRun() {
+      this.ignoreFirstRun = true;
+    }
+    /** 加上一個 被動式啟動, 不然一直while() run, 可能有效能上的問題,現階端只支援RUN_BY_TASK */
+
+  }, {
+    key: "trigger",
+    value: function trigger() {
+      if (this.isQueuePolling) {
+        return;
+      }
+
+      if (this.state === _configer.configer.POOLLER_STATE.RUN_BY_EACH_TASK) {
+        /** 因為不這樣做, 就會產生 race condition, 會產生出3個runInGround instance */
+        this.runByEachTaskInBackGround();
+        return;
+      }
+
+      throw new _exceptioner["default"](4011, "this.state is ==> ".concat(_index2.utiller.getItsKeyByValue(_configer.configer.POOLLER_STATE, this.state)));
+    }
+  }, {
+    key: "isQueueFull",
+    value: function isQueueFull() {
+      return this.executingTaskQueue.length >= this.maxWorker - 1;
+    }
+  }, {
+    key: "syncTaskDispatcher",
+    value: function () {
+      var _syncTaskDispatcher = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+        var initialTaskShouldNotRun, restInInterval, taskInfo, promise;
+        return _regenerator["default"].wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                initialTaskShouldNotRun = this.ignoreFirstRun && !this.firstTaskDone();
+
+                if (!(initialTaskShouldNotRun || this.firstTaskDone() && this.isQueueFull() && this.enableOfTaskSleepByInterval)) {
+                  _context10.next = 9;
+                  break;
+                }
+
+                _context10.next = 4;
+                return _index2.utiller.syncDelayRandom(this.taskSleepInterval.min, this.taskSleepInterval.max);
+
+              case 4:
+                restInInterval = _context10.sent;
+                if (_configer.configer.MODULE_MSG.SHOW_SUCCEED) _index2.utiller.appendInfo("".concat(this.getPoollerLogFormat("Dispatcher \u7167\u898F\u77E9 \u7761  ".concat(restInInterval, " million-secs \u5F8C\u624D\u80FDDispatch Task")), " "));
+
+                if (this.isRunning()) {
+                  _context10.next = 9;
+                  break;
+                }
+
+                _index2.utiller.appendInfo("".concat(this.getPoollerLogFormat(" Dispatcher \u7761\u8D77\u4F86\u4E4B\u5F8C, \u9047\u5230this.isTaskRunning === true, \u6240\u4EE5\u5C31\u7D50\u675F\u9019\u500BDispatch")));
+
+                return _context10.abrupt("return");
+
+              case 9:
+                taskInfo = this.getTaskInfoDependOnPriority();
+
+                if (taskInfo) {
+                  promise = this.taskWrapper(taskInfo.task, taskInfo.hash);
+                  this.removeTaskMapByHash(taskInfo.hash);
+                  this.appendHashPromiseMap(taskInfo.hash, promise);
+                  this.appendToExecuteQueue(promise);
+                }
+
+              case 11:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, this);
+      }));
+
+      function syncTaskDispatcher() {
+        return _syncTaskDispatcher.apply(this, arguments);
+      }
+
+      return syncTaskDispatcher;
+    }()
+  }, {
+    key: "appendToExecuteQueue",
+    value: function appendToExecuteQueue(promise) {
+      this.executingTaskQueue.push(promise);
+    }
+  }, {
+    key: "removePromiseFromExecutingQueue",
+    value: function removePromiseFromExecutingQueue(hash) {
+      this.executingTaskQueue.splice(this.executingTaskQueue.indexOf(this.getPromiseByHash(hash)), 1);
+    }
+  }, {
+    key: "appendHashPromiseMap",
+    value: function appendHashPromiseMap(hash, promise) {
+      this.mHashNPromiseMap[hash] = promise;
+    }
+  }, {
+    key: "getPromiseByHash",
+    value: function getPromiseByHash(hash) {
+      return this.mHashNPromiseMap[hash];
+    }
+    /** 如果有function 就代表是一個需要回傳result的task, task在線等的意思*/
+
+  }, {
+    key: "isWait4ResultTask",
+    value: function isWait4ResultTask(hash) {
+      return this.hashCallbackMapOfWaiting4Result[hash];
+    }
+  }, {
+    key: "exampleOfRunInBackground",
+    value: function () {
+      var _exampleOfRunInBackground = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13() {
+        var pool, asyncTask, startTimoutTask;
+        return _regenerator["default"].wrap(function _callee13$(_context13) {
+          while (1) {
+            switch (_context13.prev = _context13.next) {
+              case 0:
+                startTimoutTask = function _startTimoutTask(delayTime, taskSpendTime, sign) {
+                  var priority = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "low";
+                  setTimeout( /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
+                    var printSign;
+                    return _regenerator["default"].wrap(function _callee12$(_context12) {
+                      while (1) {
+                        switch (_context12.prev = _context12.next) {
+                          case 0:
+                            _context12.prev = 0;
+                            _context12.next = 3;
+                            return pool.addTaskAndWait4Result(asyncTask(sign, taskSpendTime), priority);
+
+                          case 3:
+                            printSign = _context12.sent;
+
+                            _index2.utiller.appendInfo("answser => ", printSign);
+
+                            _context12.next = 10;
+                            break;
+
+                          case 7:
+                            _context12.prev = 7;
+                            _context12.t0 = _context12["catch"](0);
+
+                            _index2.utiller.appendError(_context12.t0.message);
+
+                          case 10:
+                          case "end":
+                            return _context12.stop();
+                        }
+                      }
+                    }, _callee12, null, [[0, 7]]);
+                  })), delayTime);
+                };
+
+                asyncTask = function _asyncTask(sign) {
+                  var taskSpend = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2000;
+                  return /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+                    return _regenerator["default"].wrap(function _callee11$(_context11) {
+                      while (1) {
+                        switch (_context11.prev = _context11.next) {
+                          case 0:
+                            _context11.next = 2;
+                            return _index2.utiller.syncDelay(taskSpend);
+
+                          case 2:
+                            return _context11.abrupt("return", sign);
+
+                          case 3:
+                          case "end":
+                            return _context11.stop();
+                        }
+                      }
+                    }, _callee11);
+                  }));
+                };
+
+                pool = new InfinitePool(1).runByEachTaskInBackGround();
+                pool.enableTaskTimeout(true, 3000);
+                startTimoutTask(0, 1000, "A", "low");
+                startTimoutTask(35, 1000, "C", "high");
+                startTimoutTask(500, 3000, "B", "low");
+                startTimoutTask(3000, 1000, "D", "medium");
+
+              case 8:
+                if (!true) {
+                  _context13.next = 14;
+                  break;
+                }
+
+                _index2.utiller.appendInfo("system is running");
+
+                _context13.next = 12;
+                return _index2.utiller.syncDelay(100000);
+
+              case 12:
+                _context13.next = 8;
+                break;
+
+              case 14:
+              case "end":
+                return _context13.stop();
+            }
+          }
+        }, _callee13);
+      }));
+
+      function exampleOfRunInBackground() {
+        return _exampleOfRunInBackground.apply(this, arguments);
+      }
+
+      return exampleOfRunInBackground;
+    }()
+  }, {
+    key: "exampleOfRunInfinte",
+    value: function () {
+      var _exampleOfRunInfinte = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee15() {
+        return _regenerator["default"].wrap(function _callee15$(_context15) {
+          while (1) {
+            switch (_context15.prev = _context15.next) {
+              case 0:
+                _context15.next = 2;
+                return new InfinitePool(2).runInInfinite( /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee14() {
+                  return _regenerator["default"].wrap(function _callee14$(_context14) {
+                    while (1) {
+                      switch (_context14.prev = _context14.next) {
+                        case 0:
+                          console.log("1000");
+
+                        case 1:
+                        case "end":
+                          return _context14.stop();
+                      }
+                    }
+                  }, _callee14);
+                })), 1000);
+
+              case 2:
+              case "end":
+                return _context15.stop();
+            }
+          }
+        }, _callee15);
+      }));
+
+      function exampleOfRunInfinte() {
+        return _exampleOfRunInfinte.apply(this, arguments);
+      }
+
+      return exampleOfRunInfinte;
+    }()
+  }, {
+    key: "exampleOfRunByParam",
+    value: function () {
+      var _exampleOfRunByParam = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee17() {
+        var oneToTen, pool;
+        return _regenerator["default"].wrap(function _callee17$(_context17) {
+          while (1) {
+            switch (_context17.prev = _context17.next) {
+              case 0:
+                oneToTen = _lodash["default"].range(1, 10);
+                pool = new InfinitePool(1);
+                pool.enableTaskSleepInterval(true, 1000);
+                _context17.next = 5;
+                return pool.runByParams(oneToTen, /*#__PURE__*/function () {
+                  var _ref11 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee16(param) {
+                    return _regenerator["default"].wrap(function _callee16$(_context16) {
+                      while (1) {
+                        switch (_context16.prev = _context16.next) {
+                          case 0:
+                            console.log(param);
+
+                          case 1:
+                          case "end":
+                            return _context16.stop();
+                        }
+                      }
+                    }, _callee16);
+                  }));
+
+                  return function (_x3) {
+                    return _ref11.apply(this, arguments);
+                  };
+                }());
+
+              case 5:
+              case "end":
+                return _context17.stop();
+            }
+          }
+        }, _callee17);
+      }));
+
+      function exampleOfRunByParam() {
+        return _exampleOfRunByParam.apply(this, arguments);
+      }
+
+      return exampleOfRunByParam;
+    }()
+  }, {
+    key: "exampleOfRunByCount",
+    value: function () {
+      var _exampleOfRunByCount = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee19() {
+        var pool, time;
+        return _regenerator["default"].wrap(function _callee19$(_context19) {
+          while (1) {
+            switch (_context19.prev = _context19.next) {
+              case 0:
+                pool = new InfinitePool(1);
+                time = 0;
+                _context19.next = 4;
+                return pool.runByTimes(20, [/*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee18() {
+                  return _regenerator["default"].wrap(function _callee18$(_context18) {
+                    while (1) {
+                      switch (_context18.prev = _context18.next) {
+                        case 0:
+                          _context18.next = 2;
+                          return _index2.utiller.syncDelay(1000);
+
+                        case 2:
+                          time++;
+                          console.log("execute the ".concat(time, " time"));
+
+                        case 4:
+                        case "end":
+                          return _context18.stop();
+                      }
+                    }
+                  }, _callee18);
+                }))]);
+
+              case 4:
+              case "end":
+                return _context19.stop();
+            }
+          }
+        }, _callee19);
+      }));
+
+      function exampleOfRunByCount() {
+        return _exampleOfRunByCount.apply(this, arguments);
+      }
+
+      return exampleOfRunByCount;
+    }()
+  }]);
+  return InfinitePool;
+}();
+
+var _default = InfinitePool;
+exports["default"] = _default;