pubo-node 1.0.141 → 1.0.142

package/es/child-process/index.js

@@ -1,171 +1,268 @@
-var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
+import { exec } from 'child_process';
+import { waitFor } from 'pubo-utils';
+// 获取进程名称
+
+function _await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
   }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _async(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+var _iteratorSymbol = /*#__PURE__*/typeof Symbol !== "undefined" ? Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator")) : "@@iterator";
+function _settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof _Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+        value = value.v;
+      } else {
+        value.o = _settle.bind(null, pact, state);
+        return;
+      }
+    }
+    if (value && value.then) {
+      value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+      return;
+    }
+    pact.s = state;
+    pact.v = value;
+    var observer = pact.o;
+    if (observer) {
+      observer(pact);
+    }
+  }
+}
+var _Pact = /*#__PURE__*/function () {
+  function _Pact() {}
+  _Pact.prototype.then = function (onFulfilled, onRejected) {
+    var result = new _Pact();
+    var state = this.s;
+    if (state) {
+      var callback = state & 1 ? onFulfilled : onRejected;
+      if (callback) {
+        try {
+          _settle(result, 1, callback(this.v));
+        } catch (e) {
+          _settle(result, 2, e);
+        }
+        return result;
+      } else {
+        return this;
       }
     }
-    function rejected(value) {
+    this.o = function (_this) {
       try {
-        step(generator["throw"](value));
+        var value = _this.v;
+        if (_this.s & 1) {
+          _settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          _settle(result, 1, onRejected(value));
+        } else {
+          _settle(result, 2, value);
+        }
       } catch (e) {
-        reject(e);
+        _settle(result, 2, e);
       }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var __generator = this && this.__generator || function (thisArg, body) {
-  var _ = {
-      label: 0,
-      sent: function sent() {
-        if (t[0] & 1) throw t[1];
-        return t[1];
-      },
-      trys: [],
-      ops: []
-    },
-    f,
-    y,
-    t,
-    g;
-  return g = {
-    next: verb(0),
-    "throw": verb(1),
-    "return": verb(2)
-  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
-    return this;
-  }), g;
-  function verb(n) {
-    return function (v) {
-      return step([n, v]);
     };
-  }
-  function step(op) {
-    if (f) throw new TypeError("Generator is already executing.");
-    while (g && (g = 0, op[0] && (_ = 0)), _) try {
-      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-      if (y = 0, t) op = [op[0] & 2, t.value];
-      switch (op[0]) {
-        case 0:
-        case 1:
-          t = op;
-          break;
-        case 4:
-          _.label++;
-          return {
-            value: op[1],
-            done: false
-          };
-        case 5:
-          _.label++;
-          y = op[1];
-          op = [0];
-          continue;
-        case 7:
-          op = _.ops.pop();
-          _.trys.pop();
-          continue;
-        default:
-          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-            _ = 0;
-            continue;
-          }
-          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-            _.label = op[1];
-            break;
-          }
-          if (op[0] === 6 && _.label < t[1]) {
-            _.label = t[1];
-            t = op;
-            break;
-          }
-          if (t && _.label < t[2]) {
-            _.label = t[2];
-            _.ops.push(op);
-            break;
+    return result;
+  };
+  return _Pact;
+}();
+function _isSettledPact(thenable) {
+  return thenable instanceof _Pact && thenable.s & 1;
+}
+function _forTo(array, body, check) {
+  var i = -1,
+    pact,
+    reject;
+  function _cycle(result) {
+    try {
+      while (++i < array.length && (!check || !check())) {
+        result = body(i);
+        if (result && result.then) {
+          if (_isSettledPact(result)) {
+            result = result.v;
+          } else {
+            result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
+            return;
           }
-          if (t[2]) _.ops.pop();
-          _.trys.pop();
-          continue;
+        }
+      }
+      if (pact) {
+        _settle(pact, 1, result);
+      } else {
+        pact = result;
       }
-      op = body.call(thisArg, _);
     } catch (e) {
-      op = [6, e];
-      y = 0;
-    } finally {
-      f = t = 0;
+      _settle(pact || (pact = new _Pact()), 2, e);
     }
-    if (op[0] & 5) throw op[1];
-    return {
-      value: op[0] ? op[1] : void 0,
-      done: true
-    };
   }
-};
-var __values = this && this.__values || function (o) {
-  var s = typeof Symbol === "function" && Symbol.iterator,
-    m = s && o[s],
-    i = 0;
-  if (m) return m.call(o);
-  if (o && typeof o.length === "number") return {
-    next: function next() {
-      if (o && i >= o.length) o = void 0;
-      return {
-        value: o && o[i++],
-        done: !o
+  _cycle();
+  return pact;
+}
+function _forOf(target, body, check) {
+  if (typeof target[_iteratorSymbol] === "function") {
+    var _cycle = function _cycle(result) {
+      try {
+        while (!(step = iterator.next()).done && (!check || !check())) {
+          result = body(step.value);
+          if (result && result.then) {
+            if (_isSettledPact(result)) {
+              result = result.v;
+            } else {
+              result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
+              return;
+            }
+          }
+        }
+        if (pact) {
+          _settle(pact, 1, result);
+        } else {
+          pact = result;
+        }
+      } catch (e) {
+        _settle(pact || (pact = new _Pact()), 2, e);
+      }
+    };
+    var iterator = target[_iteratorSymbol](),
+      step,
+      pact,
+      reject;
+    _cycle();
+    if (iterator["return"]) {
+      var _fixup = function _fixup(value) {
+        try {
+          if (!step.done) {
+            iterator["return"]();
+          }
+        } catch (e) {}
+        return value;
       };
+      if (pact && pact.then) {
+        return pact.then(_fixup, function (e) {
+          throw _fixup(e);
+        });
+      }
+      _fixup();
     }
-  };
-  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = this && this.__read || function (o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o),
-    r,
-    ar = [],
-    e;
+    return pact;
+  }
+  // No support for Symbol.iterator
+  if (!("length" in target)) {
+    throw new TypeError("Object is not iterable");
+  }
+  // Handle live collections properly
+  var values = [];
+  for (var i = 0; i < target.length; i++) {
+    values.push(target[i]);
+  }
+  return _forTo(values, function (i) {
+    return body(values[i]);
+  }, check);
+}
+function _continue(value, then) {
+  return value && value.then ? value.then(then) : then(value);
+}
+function _empty() {}
+function _awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(_empty) : Promise.resolve();
+  }
+}
+function _catch(body, recover) {
   try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = {
-      error: error
-    };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
-    }
+    var result = body();
+  } catch (e) {
+    return recover(e);
   }
-  return ar;
-};
-var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
+  if (result && result.then) {
+    return result.then(void 0, recover);
   }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { exec } from 'child_process';
-import { waitFor } from 'pubo-utils';
-// 获取进程名称
+  return result;
+}
+function _continueIgnored(value) {
+  if (value && value.then) {
+    return value.then(_empty);
+  }
+}
+export var SIGKILL = _async(function (pid, signal) {
+  if (signal === void 0) {
+    signal = 2;
+  }
+  return process.platform === 'win32' ? new Promise(function (resolve, reject) {
+    exec("taskkill /pid " + pid + " /T /F", function (err) {
+      if (err) {
+        reject(err);
+      } else {
+        resolve('');
+      }
+    });
+  }) : _await(getProcessTree(pid), function (tree) {
+    // 获取所有进程PID,从叶到根
+    var tmp = [tree.pid];
+    flatProcessTree(tree, tmp);
+    tmp.reverse();
+    return _continue(_forOf(tmp, function (item) {
+      return _awaitIgnored(_SIGKILL(item, signal));
+    }), function () {
+      return 'success';
+    });
+  });
+});
+// 杀死进程
+var _SIGKILL = _async(function (pid, signal, times) {
+  if (signal === void 0) {
+    signal = 2;
+  }
+  if (times === void 0) {
+    times = 1;
+  }
+  if (times > 5) {
+    throw new Error('SIGKILL 失败. times > 5');
+  }
+  if (process.platform === 'win32') {
+    process.kill(pid, signal);
+    return;
+  }
+  exec("kill -" + signal + " " + pid);
+  return _continueIgnored(_catch(function () {
+    return _awaitIgnored(waitFor(function () {
+      return isProcessDied(pid);
+    }, {
+      checkTime: 1000,
+      timeout: 10000
+    }));
+  }, function () {
+    return _awaitIgnored(_SIGKILL(pid, 9, times + 1));
+  }));
+}); // 广度优先遍历进程树，将pid放入tmp
+// 判断进程是否死亡
+export var isProcessDied = _async(function (pid) {
+  return _await(getProcessCpuUseByPid(pid), function (used) {
+    return used < 0;
+  });
+});
+// 获取子进程
 export function getProcessName(pid) {
   return new Promise(function (resolve, reject) {
-    exec("grep \"Name:\" /proc/".concat(pid, "/status"), function (err, data) {
+    exec("grep \"Name:\" /proc/" + pid + "/status", function (err, data) {
       if (err) {
         reject(err);
       } else {
@@ -177,7 +274,7 @@ export function getProcessName(pid) {
 // 获取进程 cpu 使用率
 export function getProcessCpuUseByPid(pid) {
   return new Promise(function (resolve) {
-    exec("ps -p ".concat(pid, " -o %cpu="), function (err, stdout) {
+    exec("ps -p " + pid + " -o %cpu=", function (err, stdout) {
       if (err) {
         resolve(-1);
       } else {
@@ -189,7 +286,7 @@ export function getProcessCpuUseByPid(pid) {
 // 获取进程 command 使用率
 export function getProcessCommandByPid(pid) {
   return new Promise(function (resolve) {
-    exec("ps -p ".concat(pid, " -o command="), function (err, stdout) {
+    exec("ps -p " + pid + " -o command=", function (err, stdout) {
       if (err) {
         resolve('');
       } else {
@@ -198,25 +295,9 @@ export function getProcessCommandByPid(pid) {
     });
   });
 }
-// 判断进程是否死亡
-export function isProcessDied(pid) {
-  return __awaiter(this, void 0, void 0, function () {
-    var used;
-    return __generator(this, function (_a) {
-      switch (_a.label) {
-        case 0:
-          return [4 /*yield*/, getProcessCpuUseByPid(pid)];
-        case 1:
-          used = _a.sent();
-          return [2 /*return*/, used < 0];
-      }
-    });
-  });
-}
-// 获取子进程
 export function getProcessByPpid(pid) {
   return new Promise(function (resolve) {
-    exec("ps -o pid --no-headers --ppid ".concat(pid), function (err, stdout) {
+    exec("ps -o pid --no-headers --ppid " + pid, function (err, stdout) {
       if (err) {
         resolve([]);
       } else {
@@ -230,185 +311,34 @@ export function getProcessByPpid(pid) {
   });
 }
 // 获取进程树
-export var getProcessTree = function getProcessTree(pid, tree) {
-  return __awaiter(void 0, void 0, void 0, function () {
-    var pids, pids_1, pids_1_1, id, item, e_1_1;
-    var e_1, _a;
-    return __generator(this, function (_b) {
-      switch (_b.label) {
-        case 0:
-          if (!tree) {
-            tree = {
-              pid: pid,
-              children: []
-            };
-          }
-          return [4 /*yield*/, getProcessByPpid(pid)];
-        case 1:
-          pids = _b.sent();
-          _b.label = 2;
-        case 2:
-          _b.trys.push([2, 7, 8, 9]);
-          pids_1 = __values(pids), pids_1_1 = pids_1.next();
-          _b.label = 3;
-        case 3:
-          if (!!pids_1_1.done) return [3 /*break*/, 6];
-          id = pids_1_1.value;
-          item = {
-            pid: id,
-            children: []
-          };
-          return [4 /*yield*/, getProcessTree(id, item)];
-        case 4:
-          _b.sent();
-          tree.children.push(item);
-          _b.label = 5;
-        case 5:
-          pids_1_1 = pids_1.next();
-          return [3 /*break*/, 3];
-        case 6:
-          return [3 /*break*/, 9];
-        case 7:
-          e_1_1 = _b.sent();
-          e_1 = {
-            error: e_1_1
-          };
-          return [3 /*break*/, 9];
-        case 8:
-          try {
-            if (pids_1_1 && !pids_1_1.done && (_a = pids_1["return"])) _a.call(pids_1);
-          } finally {
-            if (e_1) throw e_1.error;
-          }
-          return [7 /*endfinally*/];
-        case 9:
-          return [2 /*return*/, tree];
-      }
-    });
-  });
-};
-// 杀死进程
-function _SIGKILL(pid, signal, times) {
-  if (signal === void 0) {
-    signal = 2;
-  }
-  if (times === void 0) {
-    times = 1;
+export var getProcessTree = _async(function (pid, tree) {
+  if (!tree) {
+    tree = {
+      pid: pid,
+      children: []
+    };
   }
-  return __awaiter(this, void 0, void 0, function () {
-    var err_1;
-    var _this = this;
-    return __generator(this, function (_a) {
-      switch (_a.label) {
-        case 0:
-          if (times > 5) {
-            throw new Error('SIGKILL 失败. times > 5');
-          }
-          if (process.platform === 'win32') {
-            process.kill(pid, signal);
-            return [2 /*return*/];
-          }
-
-          exec("kill -".concat(signal, " ").concat(pid));
-          _a.label = 1;
-        case 1:
-          _a.trys.push([1, 3,, 5]);
-          return [4 /*yield*/, waitFor(function () {
-            return __awaiter(_this, void 0, void 0, function () {
-              return __generator(this, function (_a) {
-                return [2 /*return*/, isProcessDied(pid)];
-              });
-            });
-          }, {
-            checkTime: 1000,
-            timeout: 10000
-          })];
-        case 2:
-          _a.sent();
-          return [3 /*break*/, 5];
-        case 3:
-          err_1 = _a.sent();
-          return [4 /*yield*/, _SIGKILL(pid, 9, times + 1)];
-        case 4:
-          _a.sent();
-          return [3 /*break*/, 5];
-        case 5:
-          return [2 /*return*/];
-      }
+  return _await(getProcessByPpid(pid), function (pids) {
+    return _continue(_forOf(pids, function (id) {
+      var item = {
+        pid: id,
+        children: []
+      };
+      return _await(getProcessTree(id, item), function () {
+        tree.children.push(item);
+      });
+    }), function () {
+      return tree;
     });
   });
-}
-// 广度优先遍历进程树，将pid放入tmp
+});
 var flatProcessTree = function flatProcessTree(tree, tmp) {
   if (tree.children) {
-    tmp.push.apply(tmp, __spreadArray([], __read(tree.children.map(function (item) {
+    tmp.push.apply(tmp, tree.children.map(function (item) {
       return item.pid;
-    })), false));
+    }));
     tree.children.forEach(function (item) {
       return flatProcessTree(item, tmp);
     });
   }
-};
-export function SIGKILL(pid, signal) {
-  if (signal === void 0) {
-    signal = 2;
-  }
-  return __awaiter(this, void 0, void 0, function () {
-    var tree, tmp, tmp_1, tmp_1_1, item, e_2_1;
-    var e_2, _a;
-    return __generator(this, function (_b) {
-      switch (_b.label) {
-        case 0:
-          if (process.platform === 'win32') {
-            return [2 /*return*/, new Promise(function (resolve, reject) {
-              exec("taskkill /pid ".concat(pid, " /T /F"), function (err) {
-                if (err) {
-                  reject(err);
-                } else {
-                  resolve('');
-                }
-              });
-            })];
-          }
-          return [4 /*yield*/, getProcessTree(pid)];
-        case 1:
-          tree = _b.sent();
-          tmp = [tree.pid];
-          flatProcessTree(tree, tmp);
-          tmp.reverse();
-          _b.label = 2;
-        case 2:
-          _b.trys.push([2, 7, 8, 9]);
-          tmp_1 = __values(tmp), tmp_1_1 = tmp_1.next();
-          _b.label = 3;
-        case 3:
-          if (!!tmp_1_1.done) return [3 /*break*/, 6];
-          item = tmp_1_1.value;
-          return [4 /*yield*/, _SIGKILL(item, signal)];
-        case 4:
-          _b.sent();
-          _b.label = 5;
-        case 5:
-          tmp_1_1 = tmp_1.next();
-          return [3 /*break*/, 3];
-        case 6:
-          return [3 /*break*/, 9];
-        case 7:
-          e_2_1 = _b.sent();
-          e_2 = {
-            error: e_2_1
-          };
-          return [3 /*break*/, 9];
-        case 8:
-          try {
-            if (tmp_1_1 && !tmp_1_1.done && (_a = tmp_1["return"])) _a.call(tmp_1);
-          } finally {
-            if (e_2) throw e_2.error;
-          }
-          return [7 /*endfinally*/];
-        case 9:
-          return [2 /*return*/, 'success'];
-      }
-    });
-  });
-}
+};