@agoric/swingset-vat 0.33.0-u18.1 → 0.33.0-u19.0

package/src/kernel/slogger.js

@@ -1,120 +1,127 @@
 import { q } from '@endo/errors';
+import { makeLimitedConsole } from '@agoric/internal/src/ses-utils.js';
+
+/** @import {LimitedConsole} from '@agoric/internal/src/js-utils.js'; */
 
 const IDLE = 'idle';
 const STARTUP = 'startup';
 const DELIVERY = 'delivery';
 
-function makeCallbackRegistry(callbacks) {
-  const todo = new Set(Object.keys(callbacks));
+const noopFinisher = harden(() => {});
+
+/** @typedef {(...finishArgs: unknown[]) => unknown} AnyFinisher */
+/** @typedef {Partial<Record<Exclude<keyof KernelSlog, 'write'>, (methodName: string, args: unknown[], finisher: AnyFinisher) => unknown>>} SlogWrappers */
+
+/**
+ * Support composition of asynchronous callbacks that are invoked at the start
+ * of an operation and return either a non-function result or a "finisher"
+ * function to be invoked upon operation completion.
+ * This maker accepts a collection of wrapper functions that receive the same
+ * arguments as the method they wrap, along with the result of that method
+ * (e.g., its finisher), and are expected to return a finisher of their own that
+ * will invoke that wrapped finisher.
+ *
+ * @param {SlogWrappers} wrappers
+ */
+function makeFinishersKit(wrappers) {
+  const unused = new Set(Object.keys(wrappers));
   return harden({
     /**
-     * Robustly wrap a method with a callbacks[method] function, if defined.  We
-     * incur no runtime overhead if the given callback method isn't defined.
+     * Robustly wrap a method if a wrapper is defined.
      *
-     * @param {string} method wrap with callbacks[method]
-     * @param {(...args: Array<unknown>) => unknown} impl the original
-     * implementation of the method
-     * @returns {(...args: Array<unknown>) => unknown} the wrapped method if the
-     * callback is defined, or original method if not
+     * @template {(...args: unknown[]) => (Finisher | unknown)} F
+     * @template {AnyFinisher} [Finisher=AnyFinisher]
+     * @param {string} method name
+     * @param {F} impl the original implementation
+     * @returns {F} the wrapped method
      */
-    registerCallback(method, impl) {
-      todo.delete(method);
-      const cb = callbacks[method];
-      if (!cb) {
-        // No registered callback, just use the implementation directly.
-        // console.error('no registered callback for', method);
-        return impl;
-      }
+    wrap(method, impl) {
+      unused.delete(method);
+      const wrapper = wrappers[method];
+
+      // If there is no registered wrapper, return the implementation directly.
+      if (!wrapper) return impl;
 
-      return (...args) => {
-        // Invoke the implementation first.
-        const ret = impl(...args);
+      const wrapped = (...args) => {
+        const maybeFinisher = /** @type {Finisher} */ (impl(...args));
         try {
-          // Allow the callback to observe the call synchronously, and affect
-          // the finisher function, but not to throw an exception.
-          const cbRet = cb(method, args, ret);
-          if (typeof ret === 'function') {
-            // We wrap the finisher in the callback's return value.
-            return (...finishArgs) => {
-              try {
-                return cbRet(...finishArgs);
-              } catch (e) {
-                console.error(
-                  `failed to call registered ${method}.finish function:`,
-                  e,
-                );
-              }
-              return ret(...args);
-            };
-          }
-          // We just return the callback's return value.
-          return cbRet;
+          // Allow the callback to observe the call synchronously, and replace
+          // the implementation's finisher function, but not to throw an exception.
+          const wrapperFinisher = wrapper(method, args, maybeFinisher);
+          if (typeof maybeFinisher !== 'function') return wrapperFinisher;
+
+          // We wrap the finisher in the callback's return value.
+          return (...finishArgs) => {
+            try {
+              return /** @type {Finisher} */ (wrapperFinisher)(...finishArgs);
+            } catch (e) {
+              console.error(`${method} wrapper finisher failed:`, e);
+              return maybeFinisher(...finishArgs);
+            }
+          };
         } catch (e) {
-          console.error('failed to call registered', method, 'callback:', e);
+          console.error(`${method} wrapper failed:`, e);
+          return maybeFinisher;
         }
-        return ret;
       };
+      return /** @type {F} */ (wrapped);
     },
     /**
-     * Declare that all the methods have been registered.
+     * Declare that all wrapping is done.
      *
-     * @param {string} errorUnusedMsg message to display if there are callback
-     * names that don't correspond to a registration
+     * @param {string} msg message to display if there are unused wrappers
      */
-    doneRegistering(errorUnusedMsg = `Unrecognized callback names:`) {
-      const cbNames = [...todo.keys()];
-      if (!cbNames.length) {
-        return;
-      }
-      console.warn(errorUnusedMsg, cbNames.map(q).sort().join(', '));
+    done(msg = 'Unused wrappers') {
+      if (!unused.size) return;
+      console.warn(msg, ...[...unused.keys()].sort().map(q));
     },
   });
 }
 
+export const badConsole = makeLimitedConsole(level => () => {
+  throw Error(`unexpected use of badConsole.${level}`);
+});
+export const noopConsole = makeLimitedConsole(_level => () => {});
+
 /**
- * @param {*} slogCallbacks
- * @param {Pick<Console, 'debug'|'log'|'info'|'warn'|'error'>} dummyConsole
+ * @param {SlogWrappers} slogCallbacks
+ * @param {LimitedConsole} [dummyConsole]
  * @returns {KernelSlog}
  */
-export function makeDummySlogger(slogCallbacks, dummyConsole) {
-  const { registerCallback: reg, doneRegistering } =
-    makeCallbackRegistry(slogCallbacks);
+export function makeDummySlogger(slogCallbacks, dummyConsole = badConsole) {
+  const { wrap, done } = makeFinishersKit(slogCallbacks);
   const dummySlogger = harden({
-    provideVatSlogger: reg('provideVatSlogger', () =>
-      harden({
-        vatSlog: {
-          delivery: () => () => 0,
-        },
-      }),
-    ),
-    vatConsole: reg('vatConsole', () => dummyConsole),
-    startup: reg('startup', () => () => 0), // returns nop finish() function
-    replayVatTranscript: reg('replayVatTranscript', () => () => 0),
-    delivery: reg('delivery', () => () => 0),
-    syscall: reg('syscall', () => () => 0),
-    changeCList: reg('changeCList', () => () => 0),
-    terminateVat: reg('terminateVat', () => () => 0),
-    write: () => 0,
+    provideVatSlogger: wrap('provideVatSlogger', () => {
+      return harden({ vatSlog: { delivery: () => noopFinisher } });
+    }),
+    vatConsole: wrap('vatConsole', () => dummyConsole),
+    startup: wrap('startup', () => noopFinisher),
+    replayVatTranscript: wrap('replayVatTranscript', () => noopFinisher),
+    delivery: wrap('delivery', () => noopFinisher),
+    syscall: wrap('syscall', () => noopFinisher),
+    changeCList: wrap('changeCList', () => noopFinisher),
+    terminateVat: wrap('terminateVat', () => noopFinisher),
+    write: noopFinisher,
   });
-  doneRegistering(`Unrecognized makeDummySlogger slogCallbacks names:`);
-  // @ts-expect-error xxx
+  done('Unused makeDummySlogger slogCallbacks method names');
   return dummySlogger;
 }
 
 /**
- * @param {*} slogCallbacks
- * @param {*} writeObj
+ * @param {SlogWrappers} slogCallbacks
+ * @param {(obj: object) => void} [writeObj]
  * @returns {KernelSlog}
  */
 export function makeSlogger(slogCallbacks, writeObj) {
-  const safeWrite = e => {
-    try {
-      writeObj(e);
-    } catch (err) {
-      console.error('WARNING: slogger write error', err);
-    }
-  };
-  const write = writeObj ? safeWrite : () => 0;
+  const safeWrite = writeObj
+    ? obj => {
+        try {
+          writeObj(obj);
+        } catch (err) {
+          console.error('WARNING: slogger write error', err);
+        }
+      }
+    : () => {};
 
   const vatSlogs = new Map(); // vatID -> vatSlog
 
@@ -130,36 +137,33 @@ export function makeSlogger(slogCallbacks, writeObj) {
         console.error(
           `WARNING: slogger state confused: vat ${vatID} in ${state}, not ${exp}: ${msg}`,
         );
-        write({ type: 'slogger-confused', vatID, state, exp, msg });
+        safeWrite({ type: 'slogger-confused', vatID, state, exp, msg });
       }
     }
 
     function vatConsole(sourcedConsole) {
-      const vc = {};
-      for (const level of ['debug', 'log', 'info', 'warn', 'error']) {
-        vc[level] = (sourceTag, ...args) => {
-          if (replay) {
-            // Don't duplicate stale console output.
-            return;
-          }
-          sourcedConsole[level](sourceTag, ...args);
-          const when = { state, crankNum, vatID, deliveryNum };
-          const source = sourceTag === 'ls' ? 'liveslots' : sourceTag;
-          write({ type: 'console', source, ...when, level, args });
-        };
-      }
-      return harden(vc);
+      return makeLimitedConsole(level => (source, ...args) => {
+        // Don't duplicate stale output.
+        if (replay) return;
+
+        // Write to the console, then to the slog.
+        sourcedConsole[level](source, ...args);
+        // TODO: Just use "liveslots" rather than "ls"?
+        if (source === 'ls') source = 'liveslots';
+        const when = { state, crankNum, vatID, deliveryNum };
+        safeWrite({ type: 'console', source, ...when, level, args });
+      });
     }
 
     function startup() {
       // provide a context for console calls during startup
       checkOldState(IDLE, 'did startup get called twice?');
       state = STARTUP;
-      write({ type: 'vat-startup-start', vatID });
+      safeWrite({ type: 'vat-startup-start', vatID });
       function finish() {
         checkOldState(STARTUP, 'startup-finish called twice?');
         state = IDLE;
-        write({ type: 'vat-startup-finish', vatID });
+        safeWrite({ type: 'vat-startup-finish', vatID });
       }
       return harden(finish);
     }
@@ -172,13 +176,13 @@ export function makeSlogger(slogCallbacks, writeObj) {
       deliveryNum = newDeliveryNum;
       replay = inReplay;
       const when = { crankNum, vatID, deliveryNum, replay };
-      write({ type: 'deliver', ...when, kd, vd });
+      safeWrite({ type: 'deliver', ...when, kd, vd });
       syscallNum = 0;
 
       // dr: deliveryResult
       function finish(dr) {
         checkOldState(DELIVERY, 'delivery-finish called twice?');
-        write({ type: 'deliver-result', ...when, dr });
+        safeWrite({ type: 'deliver-result', ...when, dr });
         state = IDLE;
       }
       return harden(finish);
@@ -188,24 +192,24 @@ export function makeSlogger(slogCallbacks, writeObj) {
     function syscall(ksc, vsc) {
       checkOldState(DELIVERY, 'syscall invoked outside of delivery');
       const when = { crankNum, vatID, deliveryNum, syscallNum, replay };
-      write({ type: 'syscall', ...when, ksc, vsc });
+      safeWrite({ type: 'syscall', ...when, ksc, vsc });
       syscallNum += 1;
 
       // ksr: kernelSyscallResult, vsr: vatSyscallResult
       function finish(ksr, vsr) {
         checkOldState(DELIVERY, 'syscall finished after delivery?');
-        write({ type: 'syscall-result', ...when, ksr, vsr });
+        safeWrite({ type: 'syscall-result', ...when, ksr, vsr });
       }
       return harden(finish);
     }
 
     // mode: 'import' | 'export' | 'drop'
     function changeCList(crank, mode, kobj, vobj) {
-      write({ type: 'clist', crankNum: crank, mode, vatID, kobj, vobj });
+      safeWrite({ type: 'clist', crankNum: crank, mode, vatID, kobj, vobj });
     }
 
     function terminateVat(shouldReject, info) {
-      write({ type: 'terminate', vatID, shouldReject, info });
+      safeWrite({ type: 'terminate', vatID, shouldReject, info });
     }
 
     return harden({
@@ -233,7 +237,7 @@ export function makeSlogger(slogCallbacks, writeObj) {
     }
     const vatSlog = makeVatSlog(vatID);
     vatSlogs.set(vatID, vatSlog);
-    write({
+    safeWrite({
       type: 'create-vat',
       vatID,
       dynamic,
@@ -247,43 +251,42 @@ export function makeSlogger(slogCallbacks, writeObj) {
   }
 
   function replayVatTranscript(vatID) {
-    write({ type: 'replay-transcript-start', vatID });
+    safeWrite({ type: 'replay-transcript-start', vatID });
     function finish() {
-      write({ type: 'replay-transcript-finish', vatID });
+      safeWrite({ type: 'replay-transcript-finish', vatID });
     }
     return harden(finish);
   }
 
   // function annotateVat(vatID, data) {
-  //   write({ type: 'annotate-vat', vatID, data });
+  //   safeWrite({ type: 'annotate-vat', vatID, data });
   // }
 
-  const { registerCallback: reg, doneRegistering } =
-    makeCallbackRegistry(slogCallbacks);
+  const { wrap, done } = makeFinishersKit(slogCallbacks);
   const slogger = harden({
-    provideVatSlogger: reg('provideVatSlogger', provideVatSlogger),
-    vatConsole: reg('vatConsole', (vatID, ...args) =>
+    provideVatSlogger: wrap('provideVatSlogger', provideVatSlogger),
+    vatConsole: wrap('vatConsole', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.vatConsole(...args),
     ),
-    startup: reg('startup', (vatID, ...args) =>
+    startup: wrap('startup', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.startup(...args),
     ),
+    // TODO: Remove this seemingly dead code.
     replayVatTranscript,
-    delivery: reg('delivery', (vatID, ...args) =>
+    delivery: wrap('delivery', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.delivery(...args),
     ),
-    syscall: reg('syscall', (vatID, ...args) =>
+    syscall: wrap('syscall', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.syscall(...args),
     ),
-    changeCList: reg('changeCList', (vatID, ...args) =>
+    changeCList: wrap('changeCList', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.changeCList(...args),
     ),
-    terminateVat: reg('terminateVat', (vatID, ...args) =>
+    terminateVat: wrap('terminateVat', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.terminateVat(...args),
     ),
-    write,
+    write: safeWrite,
   });
-  doneRegistering(`Unrecognized makeSlogger slogCallbacks names:`);
-  // @ts-expect-error xxx
+  done('Unused makeSlogger slogCallbacks method names');
   return slogger;
 }

package/src/kernel/state/kernelKeeper.js

@@ -1,5 +1,7 @@
 import { Nat, isNat } from '@endo/nat';
 import { assert, Fail } from '@endo/errors';
+import { naturalCompare } from '@agoric/internal/src/natural-sort.js';
+import { makeDummySlogger, noopConsole } from '../slogger.js';
 import {
   initializeVatState,
   makeVatKeeper,
@@ -329,7 +331,7 @@ export const DEFAULT_GC_KREFS_PER_BOYD = 20;
 /**
  * @param {SwingStoreKernelStorage} kernelStorage
  * @param {number | 'uninitialized'} expectedVersion
- * @param {KernelSlog} [kernelSlog]
+ * @param {KernelSlog} [kernelSlog] optional only for expectedVersion 'uninitialized'
  */
 export default function makeKernelKeeper(
   kernelStorage,
@@ -355,10 +357,13 @@ export default function makeKernelKeeper(
     if (versionString) {
       throw Error(`kernel DB already initialized (v${versionString})`);
     }
+    kernelSlog ||= makeDummySlogger({}, noopConsole);
   } else if (expectedVersion !== version) {
     throw Error(
       `kernel DB is too old: has version v${version}, but expected v${expectedVersion}`,
     );
+  } else if (!kernelSlog) {
+    throw Error('kernelSlog is required for an already-initialized kernel DB');
   } else {
     // DB is up-to-date, so populate any caches we use
     terminatedVats = JSON.parse(getRequired('vats.terminated'));
@@ -1886,39 +1891,12 @@ export default function makeKernelKeeper(
       }
     }
 
-    function compareNumbers(a, b) {
-      return Number(a - b);
-    }
-
-    function compareStrings(a, b) {
-      // natural-sort strings having a shared prefix followed by digits
-      // (e.g., 'ko42' and 'ko100')
-      const [_a, aPrefix, aDigits] = /^(\D+)(\d+)$/.exec(a) || [];
-      if (aPrefix) {
-        const [_b, bPrefix, bDigits] = /^(\D+)(\d+)$/.exec(b) || [];
-        if (bPrefix === aPrefix) {
-          return compareNumbers(aDigits, bDigits);
-        }
-      }
-
-      // otherwise use the default string ordering
-      if (a > b) {
-        return 1;
-      }
-      if (a < b) {
-        return -1;
-      }
-      return 0;
-    }
-
+    // Perform an element-by-element natural sort.
     kernelTable.sort(
       (a, b) =>
-        compareStrings(a[0], b[0]) ||
-        compareStrings(a[1], b[1]) ||
-        compareNumbers(a[2], b[2]) ||
-        compareStrings(a[3], b[3]) ||
-        compareNumbers(a[4], b[4]) ||
-        compareNumbers(a[5], b[5]) ||
+        naturalCompare(a[0], b[0]) ||
+        naturalCompare(a[1], b[1]) ||
+        naturalCompare(a[2], b[2]) ||
         0,
     );
 
@@ -1931,7 +1909,7 @@ export default function makeKernelKeeper(
         promises.push({ id: kpid, ...getKernelPromise(kpid) });
       }
     }
-    promises.sort((a, b) => compareStrings(a.id, b.id));
+    promises.sort((a, b) => naturalCompare(a.id, b.id));
 
     const objects = [];
     const nextObjectID = Nat(BigInt(getRequired('ko.nextID')));

package/src/kernel/state/vatKeeper.js

@@ -86,7 +86,7 @@ export function initializeVatState(
 /**
  * @typedef {object} VatKeeperPowers
  * @property {TranscriptStore} transcriptStore  Accompanying transcript store, for the transcripts
- * @property {*} kernelSlog
+ * @property {KernelSlog} kernelSlog
  * @property {*} addKernelObject  Kernel function to add a new object to the kernel's mapping tables.
  * @property {*} addKernelPromiseForVat  Kernel function to add a new promise to the kernel's mapping tables.
  * @property {(kernelSlot: string) => boolean} kernelObjectExists
@@ -411,15 +411,13 @@ export function makeVatKeeper(
         // update any necessary refcounts consistently
         kvStore.set(kernelKey, buildReachableAndVatSlot(false, vatSlot));
         kvStore.set(vatKey, kernelSlot);
-        if (kernelSlog) {
-          kernelSlog.changeCList(
-            vatID,
-            getCrankNumber(),
-            'export',
-            kernelSlot,
-            vatSlot,
-          );
-        }
+        kernelSlog.changeCList(
+          vatID,
+          getCrankNumber(),
+          'export',
+          kernelSlot,
+          vatSlot,
+        );
         kdebug(`Add mapping v->k ${kernelKey}<=>${vatKey}`);
       } else {
         // the vat didn't allocate it, and the kernel didn't allocate it
@@ -486,15 +484,13 @@ export function makeVatKeeper(
       incStat('clistEntries');
       kvStore.set(vatKey, kernelSlot);
       kvStore.set(kernelKey, buildReachableAndVatSlot(false, vatSlot));
-      if (kernelSlog) {
-        kernelSlog.changeCList(
-          vatID,
-          getCrankNumber(),
-          'import',
-          kernelSlot,
-          vatSlot,
-        );
-      }
+      kernelSlog.changeCList(
+        vatID,
+        getCrankNumber(),
+        'import',
+        kernelSlot,
+        vatSlot,
+      );
       kdebug(`Add mapping k->v ${kernelKey}<=>${vatKey}`);
     }
 
@@ -537,15 +533,13 @@ export function makeVatKeeper(
     const vatKey = `${vatID}.c.${vatSlot}`;
     assert(kvStore.has(kernelKey));
     kdebug(`Delete mapping ${kernelKey}<=>${vatKey}`);
-    if (kernelSlog) {
-      kernelSlog.changeCList(
-        vatID,
-        getCrankNumber(),
-        'drop',
-        kernelSlot,
-        vatSlot,
-      );
-    }
+    kernelSlog.changeCList(
+      vatID,
+      getCrankNumber(),
+      'drop',
+      kernelSlot,
+      vatSlot,
+    );
     const isExport = allocatedByVat;
     // We tolerate the object kref not being present in the kernel object
     // table, either because we're being called during the translation of
@@ -677,13 +671,7 @@ export function makeVatKeeper(
       restartWorker,
     );
 
-    const {
-      hash: snapshotID,
-      uncompressedSize,
-      dbSaveSeconds,
-      compressedSize,
-      compressSeconds,
-    } = info;
+    const { hash: snapshotID } = info;
 
     // push a save-snapshot transcript entry
     addToTranscript(makeSaveSnapshotItem(snapshotID));
@@ -695,18 +683,6 @@ export function makeVatKeeper(
     // always starts with an initialize-worker or load-snapshot
     // pseudo-delivery
     addToTranscript(makeLoadSnapshotItem(snapshotID));
-
-    kernelSlog.write({
-      type: 'heap-snapshot-save',
-      vatID,
-      snapshotID,
-      uncompressedSize,
-      dbSaveSeconds,
-      compressedSize,
-      compressSeconds,
-      endPosition,
-      restartWorker,
-    });
   }
 
   /**