@jbrowse/core 2.0.1 → 2.1.0

package/rpc/BaseRpcDriver.js

@@ -1,424 +1,188 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-exports.watchWorker = watchWorker;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
-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 _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _mobxStateTree = require("mobx-state-tree");
-
-var _util = require("../util");
-
-var _remoteAbortSignals = require("./remoteAbortSignals");
-
-var _configuration = require("../configuration");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchWorker = void 0;
+const mobx_state_tree_1 = require("mobx-state-tree");
+const util_1 = require("../util");
+const remoteAbortSignals_1 = require("./remoteAbortSignals");
+const configuration_1 = require("../configuration");
 function isClonable(thing) {
-  if (typeof thing === 'function') {
-    return false;
-  }
-
-  if (thing instanceof Error) {
-    return false;
-  }
-
-  return true;
-} // watches the given worker object, returns a promise that will be rejected if
-// the worker times out
-
-
-function watchWorker(_x, _x2, _x3) {
-  return _watchWorker.apply(this, arguments);
+    if (typeof thing === 'function') {
+        return false;
+    }
+    if (thing instanceof Error) {
+        return false;
+    }
+    return true;
 }
-
-function _watchWorker() {
-  _watchWorker = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(worker, pingTime, rpcDriverClassName) {
-    return _regenerator.default.wrap(function _callee6$(_context6) {
-      while (1) {
-        switch (_context6.prev = _context6.next) {
-          case 0:
-            return _context6.abrupt("return", new Promise(function (_resolve, reject) {
-              function delay() {
-                setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
-                  return _regenerator.default.wrap(function _callee5$(_context5) {
-                    while (1) {
-                      switch (_context5.prev = _context5.next) {
-                        case 0:
-                          _context5.prev = 0;
-                          _context5.next = 3;
-                          return worker.call('ping', [], {
-                            timeout: pingTime * 2,
-                            rpcDriverClassName: rpcDriverClassName
-                          });
-
-                        case 3:
-                          delay();
-                          _context5.next = 9;
-                          break;
-
-                        case 6:
-                          _context5.prev = 6;
-                          _context5.t0 = _context5["catch"](0);
-                          reject(_context5.t0);
-
-                        case 9:
-                        case "end":
-                          return _context5.stop();
-                      }
-                    }
-                  }, _callee5, null, [[0, 6]]);
-                })), pingTime);
-              }
-
-              delay();
-            }));
-
-          case 1:
-          case "end":
-            return _context6.stop();
+// watches the given worker object, returns a promise that will be rejected if
+// the worker times out
+async function watchWorker(worker, pingTime, rpcDriverClassName) {
+    // after first ping succeeds, apply wait for timeout
+    return new Promise((_resolve, reject) => {
+        function delay() {
+            setTimeout(async () => {
+                try {
+                    await worker.call('ping', [], {
+                        timeout: pingTime * 2,
+                        rpcDriverClassName,
+                    });
+                    delay();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }, pingTime);
         }
-      }
-    }, _callee6);
-  }));
-  return _watchWorker.apply(this, arguments);
+        delay();
+    });
 }
-
+exports.watchWorker = watchWorker;
 function detectHardwareConcurrency() {
-  var mainThread = typeof window !== 'undefined';
-  var canDetect = mainThread && 'hardwareConcurrency' in window.navigator;
-
-  if (mainThread && canDetect) {
-    return window.navigator.hardwareConcurrency;
-  }
-
-  return 1;
+    const mainThread = typeof window !== 'undefined';
+    const canDetect = mainThread && 'hardwareConcurrency' in window.navigator;
+    if (mainThread && canDetect) {
+        return window.navigator.hardwareConcurrency;
+    }
+    return 1;
 }
-
-var LazyWorker = /*#__PURE__*/function () {
-  function LazyWorker(driver) {
-    (0, _classCallCheck2.default)(this, LazyWorker);
-    this.driver = driver;
-    (0, _defineProperty2.default)(this, "workerP", void 0);
-  }
-
-  (0, _createClass2.default)(LazyWorker, [{
-    key: "getWorker",
-    value: function () {
-      var _getWorker = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var _this = this;
-
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!this.workerP) {
-                  this.workerP = this.driver.makeWorker().then(function (worker) {
-                    watchWorker(worker, _this.driver.maxPingTime, _this.driver.name).catch(function (error) {
-                      if (worker) {
+class LazyWorker {
+    constructor(driver) {
+        this.driver = driver;
+    }
+    async getWorker() {
+        if (!this.workerP) {
+            this.workerP = this.driver
+                .makeWorker()
+                .then(worker => {
+                watchWorker(worker, this.driver.maxPingTime, this.driver.name).catch(error => {
+                    if (worker) {
                         console.error('worker did not respond, killing and generating new one');
                         console.error(error);
                         worker.destroy();
                         worker.status = 'killed';
                         worker.error = error;
-                        _this.workerP = undefined;
-                      }
-                    });
-                    return worker;
-                  }).catch(function (e) {
-                    _this.workerP = undefined;
-                    throw e;
-                  });
-                }
-
-                return _context.abrupt("return", this.workerP);
-
-              case 2:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function getWorker() {
-        return _getWorker.apply(this, arguments);
-      }
-
-      return getWorker;
-    }()
-  }]);
-  return LazyWorker;
-}();
-
-var BaseRpcDriver = /*#__PURE__*/function () {
-  function BaseRpcDriver(args) {
-    (0, _classCallCheck2.default)(this, BaseRpcDriver);
-    (0, _defineProperty2.default)(this, "name", void 0);
-    (0, _defineProperty2.default)(this, "lastWorkerAssignment", -1);
-    (0, _defineProperty2.default)(this, "workerAssignments", new Map());
-    (0, _defineProperty2.default)(this, "workerPool", void 0);
-    (0, _defineProperty2.default)(this, "maxPingTime", 30000);
-    (0, _defineProperty2.default)(this, "workerCheckFrequency", 5000);
-    (0, _defineProperty2.default)(this, "config", void 0);
-    this.config = args.config;
-  } // filter the given object and just remove any non-clonable things from it
-
-
-  (0, _createClass2.default)(BaseRpcDriver, [{
-    key: "filterArgs",
-    value: function filterArgs(thing, sessionId) {
-      var _this2 = this;
-
-      if (Array.isArray(thing)) {
-        return thing.filter(isClonable).map(function (t) {
-          return _this2.filterArgs(t, sessionId);
-        });
-      }
-
-      if ((0, _typeof2.default)(thing) === 'object' && thing !== null) {
-        // AbortSignals are specially handled
-        if (thing instanceof AbortSignal) {
-          return (0, _remoteAbortSignals.serializeAbortSignal)(thing, this.remoteAbort.bind(this, sessionId));
-        }
-
-        if ((0, _mobxStateTree.isStateTreeNode)(thing) && !(0, _mobxStateTree.isAlive)(thing)) {
-          throw new Error('dead state tree node passed to RPC call');
-        } // special case, don't try to iterate the file's subelements as the
-        // object entries below would
-
-
-        if (thing instanceof File) {
-          return thing;
+                        this.workerP = undefined;
+                    }
+                });
+                return worker;
+            })
+                .catch(e => {
+                this.workerP = undefined;
+                throw e;
+            });
         }
-
-        return Object.fromEntries(Object.entries(thing).filter(function (e) {
-          return isClonable(e[1]);
-        }).map(function (_ref) {
-          var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
-              k = _ref2[0],
-              v = _ref2[1];
-
-          return [k, _this2.filterArgs(v, sessionId)];
-        }));
-      }
-
-      return thing;
+        return this.workerP;
     }
-  }, {
-    key: "remoteAbort",
-    value: function () {
-      var _remoteAbort = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(sessionId, functionName, signalId) {
-        var worker;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                _context2.next = 2;
-                return this.getWorker(sessionId);
-
-              case 2:
-                worker = _context2.sent;
-                worker.call(functionName, {
-                  signalId: signalId
-                }, {
-                  timeout: 1000000,
-                  rpcDriverClassName: this.name
-                });
-
-              case 4:
-              case "end":
-                return _context2.stop();
+}
+class BaseRpcDriver {
+    constructor(args) {
+        this.lastWorkerAssignment = -1;
+        this.workerAssignments = new Map(); // sessionId -> worker number
+        this.maxPingTime = 30000;
+        this.workerCheckFrequency = 5000;
+        this.config = args.config;
+    }
+    // filter the given object and just remove any non-clonable things from it
+    filterArgs(thing, sessionId) {
+        if (Array.isArray(thing)) {
+            return thing
+                .filter(isClonable)
+                .map(t => this.filterArgs(t, sessionId));
+        }
+        if (typeof thing === 'object' && thing !== null) {
+            // AbortSignals are specially handled
+            if (thing instanceof AbortSignal) {
+                return (0, remoteAbortSignals_1.serializeAbortSignal)(thing, this.remoteAbort.bind(this, sessionId));
+            }
+            if ((0, mobx_state_tree_1.isStateTreeNode)(thing) && !(0, mobx_state_tree_1.isAlive)(thing)) {
+                throw new Error('dead state tree node passed to RPC call');
+            }
+            // special case, don't try to iterate the file's subelements as the
+            // object entries below would
+            if (thing instanceof File) {
+                return thing;
             }
-          }
-        }, _callee2, this);
-      }));
-
-      function remoteAbort(_x4, _x5, _x6) {
-        return _remoteAbort.apply(this, arguments);
-      }
-
-      return remoteAbort;
-    }()
-  }, {
-    key: "createWorkerPool",
-    value: function createWorkerPool() {
-      var _this3 = this;
-
-      var hardwareConcurrency = detectHardwareConcurrency();
-      var workerCount = (0, _configuration.readConfObject)(this.config, 'workerCount') || (0, _util.clamp)(1, Math.max(1, hardwareConcurrency - 1), 5);
-      return (0, _toConsumableArray2.default)(new Array(workerCount)).map(function () {
-        return new LazyWorker(_this3);
-      });
+            return Object.fromEntries(Object.entries(thing)
+                .filter(e => isClonable(e[1]))
+                .map(([k, v]) => [k, this.filterArgs(v, sessionId)]));
+        }
+        return thing;
+    }
+    async remoteAbort(sessionId, functionName, signalId) {
+        const worker = await this.getWorker(sessionId);
+        worker.call(functionName, { signalId }, { timeout: 1000000, rpcDriverClassName: this.name });
+    }
+    createWorkerPool() {
+        const hardwareConcurrency = detectHardwareConcurrency();
+        const workerCount = (0, configuration_1.readConfObject)(this.config, 'workerCount') ||
+            (0, util_1.clamp)(1, Math.max(1, hardwareConcurrency - 1), 5);
+        return [...new Array(workerCount)].map(() => new LazyWorker(this));
+    }
+    getWorkerPool() {
+        if (!this.workerPool) {
+            const res = this.createWorkerPool();
+            this.workerPool = res;
+            return res; // making this several steps makes TS happy
+        }
+        return this.workerPool;
     }
-  }, {
-    key: "getWorkerPool",
-    value: function getWorkerPool() {
-      if (!this.workerPool) {
-        var res = this.createWorkerPool();
-        this.workerPool = res;
-        return res; // making this several steps makes TS happy
-      }
-
-      return this.workerPool;
+    async getWorker(sessionId) {
+        const workers = this.getWorkerPool();
+        let workerNumber = this.workerAssignments.get(sessionId);
+        if (workerNumber === undefined) {
+            const workerAssignment = (this.lastWorkerAssignment + 1) % workers.length;
+            this.workerAssignments.set(sessionId, workerAssignment);
+            this.lastWorkerAssignment = workerAssignment;
+            workerNumber = workerAssignment;
+        }
+        // console.log(`${sessionId} -> worker ${workerNumber}`)
+        const worker = workers[workerNumber].getWorker();
+        if (!worker) {
+            throw new Error('no web workers registered for RPC');
+        }
+        return worker;
     }
-  }, {
-    key: "getWorker",
-    value: function () {
-      var _getWorker2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(sessionId) {
-        var workers, workerNumber, workerAssignment, worker;
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                workers = this.getWorkerPool();
-                workerNumber = this.workerAssignments.get(sessionId);
-
-                if (workerNumber === undefined) {
-                  workerAssignment = (this.lastWorkerAssignment + 1) % workers.length;
-                  this.workerAssignments.set(sessionId, workerAssignment);
-                  this.lastWorkerAssignment = workerAssignment;
-                  workerNumber = workerAssignment;
-                } // console.log(`${sessionId} -> worker ${workerNumber}`)
-
-
-                worker = workers[workerNumber].getWorker();
-
-                if (worker) {
-                  _context3.next = 6;
-                  break;
+    async call(pluginManager, sessionId, functionName, args, options = {}) {
+        if (!sessionId) {
+            throw new TypeError('sessionId is required');
+        }
+        let done = false;
+        const worker = await this.getWorker(sessionId);
+        const rpcMethod = pluginManager.getRpcMethodType(functionName);
+        const serializedArgs = await rpcMethod.serializeArguments(args, this.name);
+        const filteredAndSerializedArgs = this.filterArgs(serializedArgs, sessionId);
+        // now actually call the worker
+        const callP = worker
+            .call(functionName, filteredAndSerializedArgs, {
+            timeout: 5 * 60 * 1000,
+            statusCallback: args.statusCallback,
+            rpcDriverClassName: this.name,
+            ...options,
+        })
+            .finally(() => {
+            done = true;
+        });
+        // check every 5 seconds to see if the worker has been killed, and
+        // reject the killedP promise if it has
+        let killedCheckInterval;
+        const killedP = new Promise((resolve, reject) => {
+            killedCheckInterval = setInterval(() => {
+                // must've been killed
+                if (worker.status === 'killed') {
+                    reject(new Error(`operation timed out, worker process stopped responding, ${worker.error}`));
                 }
-
-                throw new Error('no web workers registered for RPC');
-
-              case 6:
-                return _context3.abrupt("return", worker);
-
-              case 7:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3, this);
-      }));
-
-      function getWorker(_x7) {
-        return _getWorker2.apply(this, arguments);
-      }
-
-      return getWorker;
-    }()
-  }, {
-    key: "call",
-    value: function () {
-      var _call = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(pluginManager, sessionId, functionName, args) {
-        var _this4 = this;
-
-        var options,
-            done,
-            worker,
-            rpcMethod,
-            serializedArgs,
-            filteredAndSerializedArgs,
-            callP,
-            killedCheckInterval,
-            killedP,
-            resultP,
-            _args4 = arguments;
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) {
-            switch (_context4.prev = _context4.next) {
-              case 0:
-                options = _args4.length > 4 && _args4[4] !== undefined ? _args4[4] : {};
-
-                if (sessionId) {
-                  _context4.next = 3;
-                  break;
+                else if (done) {
+                    resolve(true);
                 }
-
-                throw new TypeError('sessionId is required');
-
-              case 3:
-                done = false;
-                _context4.next = 6;
-                return this.getWorker(sessionId);
-
-              case 6:
-                worker = _context4.sent;
-                rpcMethod = pluginManager.getRpcMethodType(functionName);
-                _context4.next = 10;
-                return rpcMethod.serializeArguments(args, this.name);
-
-              case 10:
-                serializedArgs = _context4.sent;
-                filteredAndSerializedArgs = this.filterArgs(serializedArgs, sessionId); // now actually call the worker
-
-                callP = worker.call(functionName, filteredAndSerializedArgs, _objectSpread({
-                  timeout: 5 * 60 * 1000,
-                  // 5 minutes
-                  statusCallback: args.statusCallback,
-                  rpcDriverClassName: this.name
-                }, options)).finally(function () {
-                  done = true;
-                }); // check every 5 seconds to see if the worker has been killed, and
-                // reject the killedP promise if it has
-
-                killedP = new Promise(function (resolve, reject) {
-                  killedCheckInterval = setInterval(function () {
-                    // must've been killed
-                    if (worker.status === 'killed') {
-                      reject(new Error("operation timed out, worker process stopped responding, ".concat(worker.error)));
-                    } else if (done) {
-                      resolve(true);
-                    }
-                  }, _this4.workerCheckFrequency);
-                }).finally(function () {
-                  clearInterval(killedCheckInterval);
-                }); // the result is a race between the actual result promise, and the "killed"
-                // promise. the killed promise will only actually win if the worker was
-                // killed before the call could return
-
-                resultP = Promise.race([callP, killedP]);
-                return _context4.abrupt("return", rpcMethod.deserializeReturn(resultP, args, this.name));
-
-              case 16:
-              case "end":
-                return _context4.stop();
-            }
-          }
-        }, _callee4, this);
-      }));
-
-      function call(_x8, _x9, _x10, _x11) {
-        return _call.apply(this, arguments);
-      }
-
-      return call;
-    }()
-  }]);
-  return BaseRpcDriver;
-}();
-
-exports.default = BaseRpcDriver;
+            }, this.workerCheckFrequency);
+        }).finally(() => {
+            clearInterval(killedCheckInterval);
+        });
+        // the result is a race between the actual result promise, and the "killed"
+        // promise. the killed promise will only actually win if the worker was
+        // killed before the call could return
+        const resultP = Promise.race([callP, killedP]);
+        return rpcMethod.deserializeReturn(resultP, args, this.name);
+    }
+}
+exports.default = BaseRpcDriver;