refactor(compass-shell): Refactor child process creation to avoid writing to fs; Use worker in child process to work around vm SIGINT issue

Author: gribnoysup

packages/compass-shell/src/modules/runtime.js

@@ -69,7 +69,7 @@ function reduceSetupRuntime(state, action) {
   const newRuntime = new WorkerRuntime(url, options);
 
   // TODO: For testing purposes
-  window.restart = newRuntime.restart.bind(newRuntime);
+  window.shellRuntime = newRuntime;
 
   return {
     error: action.error,

packages/compass-shell/src/modules/worker-runtime/child.js

@@ -0,0 +1,25 @@
+import { SHARE_ENV, Worker } from 'worker_threads';
+import { exposeAll, createCaller } from './rpc';
+
+import workerSrc from 'inline-entry-loader!./worker';
+
+const workerProcess = new Worker(workerSrc, { eval: true, env: SHARE_ENV });
+
+const worker = createCaller(
+  ['init', 'evaluate', 'getCompletions', 'ping'],
+  workerProcess
+);
+
+const evaluationListener = createCaller(
+  ['onPrint', 'onPrompt', 'toggleTelemetry'],
+  process
+);
+
+exposeAll(worker, process);
+exposeAll(evaluationListener, workerProcess);
+
+workerProcess.once('message', () => {
+  process.nextTick(() => {
+    process.send('ready');
+  });
+});

packages/compass-shell/src/modules/worker-runtime/runtime.js

@@ -1,23 +1,12 @@
-import path from 'path';
-import fs from 'fs';
-// eslint-disable-next-line camelcase
-import child_process from 'child_process';
-import crypto from 'crypto';
-import electron from 'electron';
-import worker from 'inline-entry-loader!./worker';
+import { once } from 'events';
+import { spawn } from 'child_process';
 import { createCaller, exposeAll } from './rpc';
 
-function createChildFromSource(src) {
-  const tmpFile = path.resolve(
-    (electron.app || electron.remote.app).getPath('temp'),
-    `worker-runtime-${crypto.randomBytes(32).toString('hex')}`
-  );
+import childSrc from 'inline-entry-loader!./child';
 
-  // eslint-disable-next-line no-sync
-  fs.writeFileSync(tmpFile, src, 'utf8');
-
-  const childProcess = child_process.spawn(process.execPath, [tmpFile], {
-    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+async function createChildFromSource(src) {
+  const childProcess = spawn(process.execPath, [], {
+    stdio: ['pipe', 'inherit', 'inherit', 'ipc'],
     env: { ...process.env, ELECTRON_RUN_AS_NODE: 1 },
     /**
      * This would be awesome, but only supported since node 12.16.0, compass
@@ -27,22 +16,34 @@ function createChildFromSource(src) {
     serialization: 'advanced',
   });
 
+  childProcess.stdin.write(src);
+  childProcess.stdin.end();
+
+  // First message is a "ready" message
+  await once(childProcess, 'message');
+
   return childProcess;
 }
 
 class WorkerRuntime {
   constructor(uri, options, cliOptions) {
     this.initOptions = { uri, options, cliOptions };
+    // Creating worker is an async process, we want to "lock"
+    // evaluate/getCompletions methods until worker is initiated from the get-go
+    this.initPromiseResolve = null;
+    this.initPromise = new Promise((resolve) => {
+      this.initPromiseResolve = resolve;
+    });
     this.evaluationListener = null;
     this.cancelEvaluate = () => {};
     this.initWorker();
   }
 
-  initWorker() {
+  async initWorker() {
     const { uri, options, cliOptions } = this.initOptions;
-    this.childProcess = createChildFromSource(worker);
+    this.childProcess = await createChildFromSource(childSrc);
     this.worker = createCaller(
-      ['init', 'evaluate', 'getCompletions'],
+      ['init', 'evaluate', 'getCompletions', 'ping'],
       this.childProcess
     );
     this.workerEvaluationListener = exposeAll(
@@ -68,7 +69,7 @@ class WorkerRuntime {
       },
       this.childProcess
     );
-    this.initPromise = this.worker.init(uri, options, cliOptions);
+    this.initPromiseResolve(await this.worker.init(uri, options, cliOptions));
   }
 
   async evaluate(code) {
@@ -108,18 +109,23 @@ class WorkerRuntime {
     return prev;
   }
 
+  interruptWorker() {
+    this.childProcess.kill('SIGINT');
+  }
+
   terminateWorker() {
     this.cancelEvaluate();
     this.childProcess.kill();
+    this.childProcess = null;
   }
 
-  restart() {
+  restartWorker() {
     this.terminateWorker();
     this.initWorker();
   }
 
   waitForCancelEvaluate() {
-    return new Promise((resolve, reject) => {
+    return new Promise((_resolve, reject) => {
       this.cancelEvaluate = () => {
         reject(new Error('Script execution was interrupted'));
       };

packages/compass-shell/src/modules/worker-runtime/worker.js

@@ -1,3 +1,4 @@
+import { parentPort } from 'worker_threads';
 import { ElectronRuntime } from '@mongosh/browser-runtime-electron';
 import { CliServiceProvider } from '@mongosh/service-provider-server';
 import { exposeAll, createCaller } from './rpc';
@@ -8,7 +9,7 @@ let runtime = null;
 
 const evaluationListener = createCaller(
   ['onPrint', 'onPrompt', 'toggleTelemetry'],
-  process
+  parentPort
 );
 
 async function init(uri, options, cliOptions) {
@@ -56,4 +57,8 @@ async function getCompletions(code) {
 
 const worker = { init, evaluate, getCompletions };
 
-exposeAll(worker, process);
+exposeAll(worker, parentPort);
+
+process.nextTick(() => {
+  parentPort.postMessage('ready');
+});