feat(swingset): xsnap vat worker

.gitmodules

@@ -1,7 +1,3 @@
-[submodule "packages/xs-vat-worker/moddable"]
-	path = packages/xs-vat-worker/moddable
-	url = https://github.com/agoric-labs/moddable.git
-	branch = ag-linux-cli
 [submodule "packages/xsnap/moddable"]
 	path = packages/xsnap/moddable
 	url = https://github.com/Moddable-OpenSource/moddable.git

packages/SwingSet/package.json

@@ -48,7 +48,7 @@
     "@agoric/tame-metering": "^1.3.0",
     "@agoric/transform-eventual-send": "^1.4.0",
     "@agoric/transform-metering": "^1.4.0",
-    "@agoric/xs-vat-worker": "^0.4.0",
+    "@agoric/xsnap": "^0.1.0",
     "@babel/core": "^7.5.0",
     "@babel/generator": "^7.6.4",
     "anylogger": "^0.21.0",

packages/SwingSet/src/controller.js

@@ -1,7 +1,8 @@
 import fs from 'fs';
-import path from 'path';
 import process from 'process';
 import re2 from 're2';
+import { spawn } from 'child_process';
+import { type as osType } from 'os';
 import { Worker } from 'worker_threads';
 import * as babelCore from '@babel/core';
 import * as babelParser from '@agoric/babel-parser';
@@ -14,7 +15,7 @@ import { importBundle } from '@agoric/import-bundle';
 import { initSwingStore } from '@agoric/swing-store-simple';
 import { makeMeteringTransformer } from '@agoric/transform-metering';
 import { makeTransform } from '@agoric/transform-eventual-send';
-import { locateWorkerBin } from '@agoric/xs-vat-worker';
+import { xsnap } from '@agoric/xsnap';
 
 import { WeakRef, FinalizationRegistry } from './weakref';
 import { startSubprocessWorker } from './spawnSubprocessWorker';
@@ -144,24 +145,36 @@ export async function makeSwingsetController(
     // TODO: after we move away from `-r esm` and use real ES6 modules, point
     // this at nodeWorkerSupervisor.js instead of the CJS intermediate
     const supercode = require.resolve(
-      './kernel/vatManager/nodeWorkerSupervisorCJS.js',
+      './kernel/vatManager/supervisor-nodeworker-cjs.js',
     );
     return new Worker(supercode);
   }
 
   // launch a worker in a subprocess (which runs Node.js)
   function startSubprocessWorkerNode() {
     const supercode = require.resolve(
-      './kernel/vatManager/subprocessSupervisor.js',
+      './kernel/vatManager/supervisor-subprocess-node.js',
     );
     return startSubprocessWorker(process.execPath, ['-r', 'esm', supercode]);
   }
 
-  let startSubprocessWorkerXS;
-  const xsWorkerBin = locateWorkerBin({ resolve: path.resolve });
-  if (fs.existsSync(xsWorkerBin)) {
-    startSubprocessWorkerXS = () => startSubprocessWorker(xsWorkerBin);
-  }
+  const startXSnap = (name, handleCommand) => {
+    const worker = xsnap({
+      os: osType(),
+      spawn,
+      handleCommand,
+      name,
+      stdout: 'inherit',
+      stderr: 'inherit',
+      // debug: true,
+    });
+
+    const bundles = {
+      lockdown: JSON.parse(hostStorage.get('lockdownBundle')),
+      supervisor: JSON.parse(hostStorage.get('supervisorBundle')),
+    };
+    return harden({ worker, bundles });
+  };
 
   const slogF =
     slogFile && (await fs.createWriteStream(slogFile, { flags: 'a' })); // append
@@ -186,7 +199,7 @@ export async function makeSwingsetController(
     transformTildot,
     makeNodeWorker,
     startSubprocessWorkerNode,
-    startSubprocessWorkerXS,
+    startXSnap,
     writeSlogObject,
     WeakRef,
     FinalizationRegistry,

packages/SwingSet/src/initializeSwingset.js

@@ -8,27 +8,33 @@ import { initSwingStore } from '@agoric/swing-store-simple';
 import { insistStorageAPI } from './storageAPI';
 import { initializeKernel } from './kernel/initializeKernel';
 
+const zip = (xs, ys) => xs.map((x, i) => [x, ys[i]]);
+const { keys, values, fromEntries } = Object;
+const allValues = async obj =>
+  fromEntries(zip(keys(obj), await Promise.all(values(obj))));
+
 /**
- * Build the kernel source bundles.
- *
+ * Build the source bundles for the kernel and xsnap vat worker.
  */
 export async function buildKernelBundles() {
   // this takes 2.7s on my computer
-  const sources = {
-    kernel: require.resolve('./kernel/kernel.js'),
-    adminDevice: require.resolve('./kernel/vatAdmin/vatAdmin-src'),
-    adminVat: require.resolve('./kernel/vatAdmin/vatAdminWrapper'),
-    comms: require.resolve('./vats/comms'),
-    vattp: require.resolve('./vats/vat-tp'),
-    timer: require.resolve('./vats/vat-timerWrapper'),
-  };
-  const kernelBundles = {};
-  for (const name of Object.keys(sources)) {
-    // this was harder to read with Promise.all
-    // eslint-disable-next-line no-await-in-loop
-    kernelBundles[name] = await bundleSource(sources[name]);
-  }
-  return harden(kernelBundles);
+
+  const src = rel => bundleSource(require.resolve(rel));
+  const srcGE = rel => bundleSource(require.resolve(rel), 'getExport');
+
+  const bundles = await allValues({
+    kernel: src('./kernel/kernel.js'),
+    adminDevice: src('./kernel/vatAdmin/vatAdmin-src'),
+    adminVat: src('./kernel/vatAdmin/vatAdminWrapper'),
+    comms: src('./vats/comms'),
+    vattp: src('./vats/vat-tp'),
+    timer: src('./vats/vat-timerWrapper'),
+
+    lockdown: srcGE('./kernel/vatManager/lockdown-subprocess-xsnap.js'),
+    supervisor: srcGE('./kernel/vatManager/supervisor-subprocess-xsnap.js'),
+  });
+
+  return harden(bundles);
 }
 
 function byName(a, b) {
@@ -246,6 +252,8 @@ export async function initializeSwingset(
   const { kernelBundles = await buildKernelBundles() } = initializationOptions;
 
   hostStorage.set('kernelBundle', JSON.stringify(kernelBundles.kernel));
+  hostStorage.set('lockdownBundle', JSON.stringify(kernelBundles.lockdown));
+  hostStorage.set('supervisorBundle', JSON.stringify(kernelBundles.supervisor));
 
   if (config.bootstrap && argv) {
     if (config.vats[config.bootstrap]) {

packages/SwingSet/src/kernel/kernel.js

@@ -98,7 +98,7 @@ export default function buildKernel(
     transformTildot,
     makeNodeWorker,
     startSubprocessWorkerNode,
-    startSubprocessWorkerXS,
+    startXSnap,
     writeSlogObject,
     WeakRef,
     FinalizationRegistry,
@@ -560,7 +560,7 @@ export default function buildKernel(
     waitUntilQuiescent,
     makeNodeWorker,
     startSubprocessWorkerNode,
-    startSubprocessWorkerXS,
+    startXSnap,
     gcTools,
   });
 

packages/SwingSet/src/kernel/vatManager/factory.js

@@ -1,8 +1,9 @@
 import { assert } from '@agoric/assert';
 import { assertKnownOptions } from '../../assertOptions';
-import { makeLocalVatManagerFactory } from './localVatManager';
-import { makeNodeWorkerVatManagerFactory } from './nodeWorker';
-import { makeNodeSubprocessFactory } from './worker-subprocess-node';
+import { makeLocalVatManagerFactory } from './manager-local';
+import { makeNodeWorkerVatManagerFactory } from './manager-nodeworker';
+import { makeNodeSubprocessFactory } from './manager-subprocess-node';
+import { makeXsSubprocessFactory } from './manager-subprocess-xsnap';
 
 export function makeVatManagerFactory({
   allVatPowers,
@@ -13,7 +14,7 @@ export function makeVatManagerFactory({
   waitUntilQuiescent,
   makeNodeWorker,
   startSubprocessWorkerNode,
-  startSubprocessWorkerXS,
+  startXSnap,
   gcTools,
 }) {
   const localFactory = makeLocalVatManagerFactory({
@@ -40,8 +41,8 @@ export function makeVatManagerFactory({
     decref: gcTools.decref,
   });
 
-  const xsWorkerFactory = makeNodeSubprocessFactory({
-    startSubprocessWorker: startSubprocessWorkerXS,
+  const xsWorkerFactory = makeXsSubprocessFactory({
+    startXSnap,
     kernelKeeper,
     testLog: allVatPowers.testLog,
     decref: gcTools.decref,
@@ -98,9 +99,6 @@ export function makeVatManagerFactory({
     }
 
     if (managerType === 'xs-worker') {
-      if (!startSubprocessWorkerXS) {
-        throw new Error('manager type xs-worker not available');
-      }
       return xsWorkerFactory.createFromBundle(vatID, bundle, managerOptions);
     }
 

packages/SwingSet/src/kernel/vatManager/lockdown-subprocess-xsnap.js

@@ -0,0 +1 @@
+import '@agoric/xsnap/lib/bootstrap';

packages/SwingSet/src/kernel/vatManager/manager-subprocess-xsnap.js

@@ -0,0 +1,183 @@
+// @ts-check
+import { assert, details } from '@agoric/assert';
+import { makeTranscriptManager } from './transcript';
+import { createSyscall } from './syscall';
+
+// eslint-disable-next-line no-unused-vars
+function parentLog(first, ...args) {
+  // console.error(`--parent: ${first}`, ...args);
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+/**
+ * @param {{
+ *   startXSnap: (name: string, handleCommand: SyncHandler) => { worker: XSnap, bundles: Record<string, ExportBundle> },
+ *   kernelKeeper: KernelKeeper,
+ *   testLog: (...args: unknown[]) => void,
+ *   decref: (vatID: unknown, vref: unknown, count: number) => void,
+ * }} tools
+ * @returns { VatManagerFactory }
+ *
+ * @typedef { { moduleFormat: 'getExport', source: string } } ExportBundle
+ * @typedef { (msg: Uint8Array) => Uint8Array } SyncHandler
+ * @typedef { ReturnType<typeof import('@agoric/xsnap').xsnap> } XSnap
+ * @typedef { ReturnType<typeof import('../state/kernelKeeper').default> } KernelKeeper
+ * @typedef { ReturnType<typeof import('./manager-nodeworker').makeNodeWorkerVatManagerFactory> } VatManagerFactory
+ * @typedef { [unknown, ...unknown[]] } Tagged
+ */
+export function makeXsSubprocessFactory({
+  startXSnap,
+  kernelKeeper,
+  testLog,
+  decref,
+}) {
+  /**
+   * @param { unknown } vatID
+   * @param { unknown } bundle
+   * @param { ManagerOptions } managerOptions
+   */
+  async function createFromBundle(vatID, bundle, managerOptions) {
+    parentLog('createFromBundle', { vatID });
+    const { vatParameters, virtualObjectCacheSize } = managerOptions;
+    assert(!managerOptions.metered, 'not supported yet');
+    assert(!managerOptions.enableSetup, 'not supported at all');
+    if (managerOptions.enableInternalMetering) {
+      // TODO: warn+ignore, rather than throw, because the kernel enables it
+      // for all vats, because the Spawner still needs it. When the kernel
+      // stops doing that, turn this into a regular assert
+      console.log(`xsnap worker does not support enableInternalMetering`);
+    }
+    const vatKeeper = kernelKeeper.getVatKeeper(vatID);
+    const transcriptManager = makeTranscriptManager(
+      kernelKeeper,
+      vatKeeper,
+      vatID,
+    );
+
+    const { doSyscall, setVatSyscallHandler } = createSyscall(
+      transcriptManager,
+    );
+
+    /** @type { (vatSyscallObject: Tagged) => unknown } */
+    function handleSyscall(vatSyscallObject) {
+      return doSyscall(vatSyscallObject);
+    }
+
+    /** @type { (vref: unknown, count: number) => void } */
+    function vatDecref(vref, count) {
+      decref(vatID, vref, count);
+    }
+
+    /** @type { (item: Tagged) => unknown } */
+    function handleUpstream([type, ...args]) {
+      parentLog(`handleUpstream`, type, args.length);
+      switch (type) {
+        case 'syscall': {
+          parentLog(`syscall`, args);
+          const [scTag, ...vatSyscallArgs] = args;
+          return handleSyscall([scTag, ...vatSyscallArgs]);
+        }
+        case 'console': {
+          const [level, tag, ...rest] = args;
+          if (typeof level === 'string' && level in console) {
+            console[level](tag, ...rest);
+          } else {
+            console.error('bad console level', level);
+          }
+          return ['ok'];
+        }
+        case 'testLog':
+          testLog(...args);
+          return ['OK'];
+        case 'decref': {
+          const [vref, count] = args;
+          assert(typeof count === 'number');
+          vatDecref(vref, count);
+          return ['OK'];
+        }
+        default:
+          throw new Error(`unrecognized uplink message ${type}`);
+      }
+    }
+
+    /** @type { (msg: Uint8Array) => Uint8Array } */
+    function handleCommand(msg) {
+      parentLog('handleCommand', { length: msg.byteLength });
+      const tagged = handleUpstream(JSON.parse(decoder.decode(msg)));
+      return encoder.encode(JSON.stringify(tagged));
+    }
+
+    // start the worker and establish a connection
+    const { worker, bundles } = startXSnap(`${vatID}`, handleCommand);
+    for await (const [it, superCode] of Object.entries(bundles)) {
+      parentLog('bundle', it);
+      assert(
+        superCode.moduleFormat === 'getExport',
+        details`${it} unexpected: ${superCode.moduleFormat}`,
+      );
+      await worker.evaluate(`(${superCode.source}\n)()`.trim());
+    }
+
+    /** @type { (item: Tagged) => Promise<Tagged> } */
+    async function issueTagged(item) {
+      parentLog('issueTagged', item[0]);
+      const txt = await worker.issueStringCommand(JSON.stringify(item));
+      const reply = JSON.parse(txt);
+      assert(Array.isArray(reply));
+      const [tag, ...rest] = reply;
+      return [tag, ...rest];
+    }
+
+    parentLog(`instructing worker to load bundle..`);
+    const bundleReply = await issueTagged([
+      'setBundle',
+      vatID,
+      bundle,
+      vatParameters,
+      virtualObjectCacheSize,
+    ]);
+    if (bundleReply[0] === 'dispatchReady') {
+      parentLog(`bundle loaded. dispatch ready.`);
+    } else {
+      throw new Error(`failed to setBundle: ${bundleReply}`);
+    }
+
+    /** @type { (item: Tagged) => Promise<Tagged> } */
+    async function deliver(delivery) {
+      parentLog(`sending delivery`, delivery);
+      const result = await issueTagged(['deliver', ...delivery]);
+      parentLog(`deliverDone`, result[0], result.length);
+      return result;
+    }
+
+    async function replayTranscript() {
+      transcriptManager.startReplay();
+      for (const t of vatKeeper.getTranscript()) {
+        transcriptManager.checkReplayError();
+        transcriptManager.startReplayDelivery(t.syscalls);
+        // eslint-disable-next-line no-await-in-loop
+        await deliver(t.d);
+      }
+      transcriptManager.checkReplayError();
+      transcriptManager.finishReplay();
+    }
+
+    function shutdown() {
+      return worker.close();
+    }
+
+    const manager = harden({
+      replayTranscript,
+      setVatSyscallHandler,
+      deliver,
+      shutdown,
+    });
+
+    parentLog('manager', Object.keys(manager));
+    return manager;
+  }
+
+  return harden({ createFromBundle });
+}