@jbrowse/core 1.6.5 → 1.6.6

package/rpc/BaseRpcDriver.js

@@ -53,27 +53,20 @@ function watchWorker(_x, _x2, _x3) {
 }
 
 function _watchWorker() {
-  _watchWorker = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(worker, pingTime, rpcDriverClassName) {
-    return _regenerator.default.wrap(function _callee3$(_context3) {
+  _watchWorker = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(worker, pingTime, rpcDriverClassName) {
+    return _regenerator.default.wrap(function _callee6$(_context6) {
       while (1) {
-        switch (_context3.prev = _context3.next) {
+        switch (_context6.prev = _context6.next) {
           case 0:
-            _context3.next = 2;
-            return worker.call('ping', [], {
-              timeout: 100000000,
-              rpcDriverClassName: rpcDriverClassName
-            });
-
-          case 2:
-            return _context3.abrupt("return", new Promise(function (_resolve, reject) {
+            return _context6.abrupt("return", new Promise(function (_resolve, reject) {
               function delay() {
-                setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
-                  return _regenerator.default.wrap(function _callee2$(_context2) {
+                setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+                  return _regenerator.default.wrap(function _callee5$(_context5) {
                     while (1) {
-                      switch (_context2.prev = _context2.next) {
+                      switch (_context5.prev = _context5.next) {
                         case 0:
-                          _context2.prev = 0;
-                          _context2.next = 3;
+                          _context5.prev = 0;
+                          _context5.next = 3;
                           return worker.call('ping', [], {
                             timeout: pingTime * 2,
                             rpcDriverClassName: rpcDriverClassName
@@ -81,32 +74,32 @@ function _watchWorker() {
 
                         case 3:
                           delay();
-                          _context2.next = 9;
+                          _context5.next = 9;
                           break;
 
                         case 6:
-                          _context2.prev = 6;
-                          _context2.t0 = _context2["catch"](0);
-                          reject(_context2.t0);
+                          _context5.prev = 6;
+                          _context5.t0 = _context5["catch"](0);
+                          reject(_context5.t0);
 
                         case 9:
                         case "end":
-                          return _context2.stop();
+                          return _context5.stop();
                       }
                     }
-                  }, _callee2, null, [[0, 6]]);
+                  }, _callee5, null, [[0, 6]]);
                 })), pingTime);
               }
 
               delay();
             }));
 
-          case 3:
+          case 1:
           case "end":
-            return _context3.stop();
+            return _context6.stop();
         }
       }
-    }, _callee3);
+    }, _callee6);
   }));
   return _watchWorker.apply(this, arguments);
 }
@@ -131,28 +124,56 @@ var LazyWorker = /*#__PURE__*/function () {
 
   (0, _createClass2.default)(LazyWorker, [{
     key: "getWorker",
-    value: function getWorker(pluginManager, rpcDriverClassName) {
-      var _this = this;
+    value: function () {
+      var _getWorker = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(pluginManager, rpcDriverClassName) {
+        var _this = this;
+
+        var worker;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (this.worker) {
+                  _context.next = 6;
+                  break;
+                }
+
+                _context.next = 3;
+                return this.driver.makeWorker(pluginManager);
+
+              case 3:
+                worker = _context.sent;
+                watchWorker(worker, this.driver.maxPingTime, rpcDriverClassName).catch(function (error) {
+                  if (_this.worker) {
+                    console.error('worker did not respond, killing and generating new one');
+                    console.error(error);
 
-      if (!this.worker) {
-        var worker = this.driver.makeWorker(pluginManager);
-        watchWorker(worker, this.driver.maxPingTime, rpcDriverClassName).catch(function (error) {
-          if (_this.worker) {
-            console.error('worker did not respond, killing and generating new one');
-            console.error(error);
+                    _this.worker.destroy();
 
-            _this.worker.destroy();
+                    _this.worker.status = 'killed';
+                    _this.worker.error = error;
+                    _this.worker = undefined;
+                  }
+                });
+                this.worker = worker;
 
-            _this.worker.status = 'killed';
-            _this.worker.error = error;
-            _this.worker = undefined;
+              case 6:
+                return _context.abrupt("return", this.worker);
+
+              case 7:
+              case "end":
+                return _context.stop();
+            }
           }
-        });
-        this.worker = worker;
+        }, _callee, this);
+      }));
+
+      function getWorker(_x4, _x5) {
+        return _getWorker.apply(this, arguments);
       }
 
-      return this.worker;
-    }
+      return getWorker;
+    }()
   }]);
   return LazyWorker;
 }();
@@ -214,15 +235,39 @@ var BaseRpcDriver = /*#__PURE__*/function () {
     }
   }, {
     key: "remoteAbort",
-    value: function remoteAbort(pluginManager, sessionId, functionName, signalId) {
-      var worker = this.getWorker(sessionId, pluginManager);
-      worker.call(functionName, {
-        signalId: signalId
-      }, {
-        timeout: 1000000,
-        rpcDriverClassName: this.name
-      });
-    }
+    value: function () {
+      var _remoteAbort = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(pluginManager, 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, pluginManager);
+
+              case 2:
+                worker = _context2.sent;
+                worker.call(functionName, {
+                  signalId: signalId
+                }, {
+                  timeout: 1000000,
+                  rpcDriverClassName: this.name
+                });
+
+              case 4:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function remoteAbort(_x6, _x7, _x8, _x9) {
+        return _remoteAbort.apply(this, arguments);
+      }
+
+      return remoteAbort;
+    }()
   }, {
     key: "createWorkerPool",
     value: function createWorkerPool() {
@@ -247,30 +292,54 @@ var BaseRpcDriver = /*#__PURE__*/function () {
     }
   }, {
     key: "getWorker",
-    value: function getWorker(sessionId, pluginManager) {
-      var workers = this.getWorkerPool();
-      var workerNumber = this.workerAssignments.get(sessionId);
+    value: function () {
+      var _getWorker2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(sessionId, pluginManager) {
+        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(pluginManager, this.name);
 
-      if (workerNumber === undefined) {
-        var workerAssignment = (this.lastWorkerAssignment + 1) % workers.length;
-        this.workerAssignments.set(sessionId, workerAssignment);
-        this.lastWorkerAssignment = workerAssignment;
-        workerNumber = workerAssignment;
-      } // console.log(`${sessionId} -> worker ${workerNumber}`)
+                if (worker) {
+                  _context3.next = 6;
+                  break;
+                }
 
+                throw new Error('no web workers registered for RPC');
 
-      var worker = workers[workerNumber].getWorker(pluginManager, this.name);
+              case 6:
+                return _context3.abrupt("return", worker);
+
+              case 7:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
 
-      if (!worker) {
-        throw new Error('no web workers registered for RPC');
+      function getWorker(_x10, _x11) {
+        return _getWorker2.apply(this, arguments);
       }
 
-      return worker;
-    }
+      return getWorker;
+    }()
   }, {
     key: "call",
     value: function () {
-      var _call = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(pluginManager, sessionId, functionName, args) {
+      var _call = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(pluginManager, sessionId, functionName, args) {
         var _this4 = this;
 
         var options,
@@ -283,15 +352,15 @@ var BaseRpcDriver = /*#__PURE__*/function () {
             killedCheckInterval,
             killedP,
             resultP,
-            _args = arguments;
-        return _regenerator.default.wrap(function _callee$(_context) {
+            _args4 = arguments;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
           while (1) {
-            switch (_context.prev = _context.next) {
+            switch (_context4.prev = _context4.next) {
               case 0:
-                options = _args.length > 4 && _args[4] !== undefined ? _args[4] : {};
+                options = _args4.length > 4 && _args4[4] !== undefined ? _args4[4] : {};
 
                 if (sessionId) {
-                  _context.next = 3;
+                  _context4.next = 3;
                   break;
                 }
 
@@ -299,13 +368,17 @@ var BaseRpcDriver = /*#__PURE__*/function () {
 
               case 3:
                 done = false;
-                worker = this.getWorker(sessionId, pluginManager);
+                _context4.next = 6;
+                return this.getWorker(sessionId, pluginManager);
+
+              case 6:
+                worker = _context4.sent;
                 rpcMethod = pluginManager.getRpcMethodType(functionName);
-                _context.next = 8;
+                _context4.next = 10;
                 return rpcMethod.serializeArguments(args, this.name);
 
-              case 8:
-                serializedArgs = _context.sent;
+              case 10:
+                serializedArgs = _context4.sent;
                 filteredAndSerializedArgs = this.filterArgs(serializedArgs, pluginManager, sessionId); // now actually call the worker
 
                 callP = worker.call(functionName, filteredAndSerializedArgs, _objectSpread({
@@ -334,17 +407,17 @@ var BaseRpcDriver = /*#__PURE__*/function () {
                 // killed before the call could return
 
                 resultP = Promise.race([callP, killedP]);
-                return _context.abrupt("return", rpcMethod.deserializeReturn(resultP, args, this.name));
+                return _context4.abrupt("return", rpcMethod.deserializeReturn(resultP, args, this.name));
 
-              case 14:
+              case 16:
               case "end":
-                return _context.stop();
+                return _context4.stop();
             }
           }
-        }, _callee, this);
+        }, _callee4, this);
       }));
 
-      function call(_x4, _x5, _x6, _x7) {
+      function call(_x12, _x13, _x14, _x15) {
         return _call.apply(this, arguments);
       }
 

package/rpc/BaseRpcDriver.test.js

@@ -333,9 +333,28 @@ var MockRpcDriver = /*#__PURE__*/function (_BaseRpcDriver) {
 
   (0, _createClass2.default)(MockRpcDriver, [{
     key: "makeWorker",
-    value: function makeWorker(_pluginManager) {
-      return new MockWorkerHandle();
-    }
+    value: function () {
+      var _makeWorker = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(_pluginManager) {
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                return _context5.abrupt("return", new MockWorkerHandle());
+
+              case 1:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5);
+      }));
+
+      function makeWorker(_x2) {
+        return _makeWorker.apply(this, arguments);
+      }
+
+      return makeWorker;
+    }()
   }]);
   return MockRpcDriver;
 }(_BaseRpcDriver2.default);
@@ -362,16 +381,16 @@ var MockRendererTimeout = /*#__PURE__*/function (_RpcMethodType) {
   (0, _createClass2.default)(MockRendererTimeout, [{
     key: "execute",
     value: function () {
-      var _execute = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
-        return _regenerator.default.wrap(function _callee5$(_context5) {
+      var _execute = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
+        return _regenerator.default.wrap(function _callee6$(_context6) {
           while (1) {
-            switch (_context5.prev = _context5.next) {
+            switch (_context6.prev = _context6.next) {
               case 0:
               case "end":
-                return _context5.stop();
+                return _context6.stop();
             }
           }
-        }, _callee5);
+        }, _callee6);
       }));
 
       function execute() {
@@ -408,16 +427,16 @@ var MockRendererShort = /*#__PURE__*/function (_RpcMethodType2) {
   (0, _createClass2.default)(MockRendererShort, [{
     key: "execute",
     value: function () {
-      var _execute2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
-        return _regenerator.default.wrap(function _callee6$(_context6) {
+      var _execute2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+        return _regenerator.default.wrap(function _callee7$(_context7) {
           while (1) {
-            switch (_context6.prev = _context6.next) {
+            switch (_context7.prev = _context7.next) {
               case 0:
               case "end":
-                return _context6.stop();
+                return _context7.stop();
             }
           }
-        }, _callee6);
+        }, _callee7);
       }));
 
       function execute() {
@@ -431,11 +450,11 @@ var MockRendererShort = /*#__PURE__*/function (_RpcMethodType2) {
 }(_RpcMethodType3.default);
 
 exports.MockRendererShort = MockRendererShort;
-test('test RPC driver operation timeout and worker replace', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+test('test RPC driver operation timeout and worker replace', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
   var config, driver, pluginManager;
-  return _regenerator.default.wrap(function _callee7$(_context7) {
+  return _regenerator.default.wrap(function _callee8$(_context8) {
     while (1) {
-      switch (_context7.prev = _context7.next) {
+      switch (_context8.prev = _context8.next) {
         case 0:
           console.error = jest.fn();
           console.warn = jest.fn();
@@ -452,35 +471,35 @@ test('test RPC driver operation timeout and worker replace', /*#__PURE__*/(0, _a
             return new MockRendererShort(pluginManager);
           });
           pluginManager.createPluggableElements();
-          _context7.prev = 9;
-          _context7.next = 12;
+          _context8.prev = 9;
+          _context8.next = 12;
           return driver.call(pluginManager, 'sessionId', 'MockRenderTimeout', {}, {});
 
         case 12:
-          _context7.next = 17;
+          _context8.next = 17;
           break;
 
         case 14:
-          _context7.prev = 14;
-          _context7.t0 = _context7["catch"](9);
-          expect("".concat(_context7.t0)).toMatch(/operation timed out/);
+          _context8.prev = 14;
+          _context8.t0 = _context8["catch"](9);
+          expect("".concat(_context8.t0)).toMatch(/operation timed out/);
 
         case 17:
-          _context7.next = 19;
+          _context8.next = 19;
           return driver.call(pluginManager, 'sessionId', 'MockRenderShort', {}, {});
 
         case 19:
         case "end":
-          return _context7.stop();
+          return _context8.stop();
       }
     }
-  }, _callee7, null, [[9, 14]]);
+  }, _callee8, null, [[9, 14]]);
 })));
-test('remote abort', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
+test('remote abort', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9() {
   var config, driver, pluginManager, controller, resP;
-  return _regenerator.default.wrap(function _callee8$(_context8) {
+  return _regenerator.default.wrap(function _callee9$(_context9) {
     while (1) {
-      switch (_context8.prev = _context8.next) {
+      switch (_context9.prev = _context9.next) {
         case 0:
           console.error = jest.fn();
           console.warn = jest.fn();
@@ -494,28 +513,28 @@ test('remote abort', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/
             return new MockRendererShort(pluginManager);
           });
           pluginManager.createPluggableElements();
-          _context8.prev = 8;
+          _context9.prev = 8;
           controller = new AbortController();
           resP = driver.call(pluginManager, 'sessionId', 'MockRenderShort', {}, {
             signal: controller.signal
           });
           controller.abort();
-          _context8.next = 14;
+          _context9.next = 14;
           return resP;
 
         case 14:
-          _context8.next = 19;
+          _context9.next = 19;
           break;
 
         case 16:
-          _context8.prev = 16;
-          _context8.t0 = _context8["catch"](8);
-          expect("".concat(_context8.t0)).toMatch(/abort/);
+          _context9.prev = 16;
+          _context9.t0 = _context9["catch"](8);
+          expect("".concat(_context9.t0)).toMatch(/abort/);
 
         case 19:
         case "end":
-          return _context8.stop();
+          return _context9.stop();
       }
     }
-  }, _callee8, null, [[8, 16]]);
+  }, _callee9, null, [[8, 16]]);
 })));

package/rpc/MainThreadRpcDriver.d.ts

@@ -11,7 +11,7 @@ declare class DummyHandle {
  */
 export default class MainThreadRpcDriver extends BaseRpcDriver {
     name: string;
-    makeWorker: () => DummyHandle;
+    makeWorker: () => Promise<DummyHandle>;
     constructor(args: RpcDriverConstructorArgs);
     call(pluginManager: PluginManager, sessionId: string, functionName: string, args: {}): Promise<unknown>;
 }

package/rpc/MainThreadRpcDriver.js

@@ -89,25 +89,34 @@ var MainThreadRpcDriver = /*#__PURE__*/function (_BaseRpcDriver) {
     _this = _super.call(this, args);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "name", 'MainThreadRpcDriver');
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "makeWorker", void 0);
-
-    _this.makeWorker = function () {
-      return new DummyHandle();
-    };
-
+    _this.makeWorker = /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", new DummyHandle());
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
     return _this;
   }
 
   (0, _createClass2.default)(MainThreadRpcDriver, [{
     key: "call",
     value: function () {
-      var _call2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(pluginManager, sessionId, functionName, args) {
+      var _call2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(pluginManager, sessionId, functionName, args) {
         var rpcMethod, serializedArgs, result;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
           while (1) {
-            switch (_context2.prev = _context2.next) {
+            switch (_context3.prev = _context3.next) {
               case 0:
                 if (sessionId) {
-                  _context2.next = 2;
+                  _context3.next = 2;
                   break;
                 }
 
@@ -115,24 +124,24 @@ var MainThreadRpcDriver = /*#__PURE__*/function (_BaseRpcDriver) {
 
               case 2:
                 rpcMethod = pluginManager.getRpcMethodType(functionName);
-                _context2.next = 5;
+                _context3.next = 5;
                 return rpcMethod.serializeArguments(args, this.name);
 
               case 5:
-                serializedArgs = _context2.sent;
-                _context2.next = 8;
+                serializedArgs = _context3.sent;
+                _context3.next = 8;
                 return rpcMethod.execute(serializedArgs, this.name);
 
               case 8:
-                result = _context2.sent;
-                return _context2.abrupt("return", rpcMethod.deserializeReturn(result, args, this.name));
+                result = _context3.sent;
+                return _context3.abrupt("return", rpcMethod.deserializeReturn(result, args, this.name));
 
               case 10:
               case "end":
-                return _context2.stop();
+                return _context3.stop();
             }
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
 
       function call(_x3, _x4, _x5, _x6) {

package/rpc/RpcManager.d.ts

@@ -15,7 +15,7 @@ export default class RpcManager {
     pluginManager: PluginManager;
     mainConfiguration: AnyConfigurationModel;
     backendConfigurations: BackendConfigurations;
-    static configSchema: import("../configuration/configurationSchema").AnyConfigurationSchemaType;
+    static configSchema: import("../configuration").AnyConfigurationSchemaType;
     driverObjects: Map<string, DriverClass>;
     constructor(pluginManager: PluginManager, mainConfiguration: AnyConfigurationModel, backendConfigurations: BackendConfigurations);
     getDriver(backendName: keyof typeof DriverClasses): DriverClass;

package/rpc/WebWorkerRpcDriver.d.ts

@@ -24,6 +24,6 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
     constructor(args: WebWorkerRpcDriverConstructorArgs, workerBootConfiguration: {
         plugins: PluginDefinition[];
     });
-    makeWorker(): WebWorkerHandle;
+    makeWorker(): Promise<WebWorkerHandle>;
 }
 export {};